url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
|
|---|---|---|---|---|---|---|---|---|
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply hcost.cost_ale.le_bound | case h₀
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)),
current := Encoding.getProgram fs✝, function := Encoding.getProgram fs✝ }
[])
?m.173938 ≤
?m.173011
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.halts
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)),
current := Encoding.getProgram fs✝, function := Encoding.getProgram fs✝ }
[])
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next), function := toProgram fcp }
[])
?m.173010
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.173010 + ?m.173011 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.halts
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)),
current := Encoding.getProgram fs✝, function := Encoding.getProgram fs✝ }
[])
case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next), function := toProgram fcp }
[])
?m.173010
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.173010 +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | exact (hcost.toComputable.has_result _).elim λ _ h ↦ ⟨(_, _), h⟩ | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.halts
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)),
current := Encoding.getProgram fs✝, function := Encoding.getProgram fs✝ }
[])
case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next), function := toProgram fcp }
[])
?m.173010
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.173010 +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a | case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next), function := toProgram fcp }
[])
?m.173010
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.173010 +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply splitTimeCost hf (TracedProgram.sound'_subroutine_next h) | case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next), function := toProgram fcp }
[])
?m.173010
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.173010 +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a | case h₁.a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))) ∈
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝) (Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)
?h₁.a
case h₁.a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ α
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
?h₁.a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.mem_bind_of_mem hm | case h₁.a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))) ∈
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝) (Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)
?h₁.a
case h₁.a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ α
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
?h₁.a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a | case h₁.a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))) ∈
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝) (Complexity.decode γ✝ (Memory.getms m src✝))
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.mem_map_of_mem | case h₁.a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Memory.setms m dst✝
(Complexity.encode
(fs✝
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)))) ∈
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝) (Complexity.decode γ✝ (Memory.getms m src✝))
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a | case h₁.a.h
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true) ∈
Complexity.decode γ✝ (Memory.getms m src✝)
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.get_mem | case h₁.a.h
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true) ∈
Complexity.decode γ✝ (Memory.getms m src✝)
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_le_of_eq _ | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.174514 = (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
?m.174514 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Nat.add_assoc | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.174514 = (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
?m.174514 | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a +
Complexity.CostFunction.flatMap fm 1 a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_le_add _ | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a +
Complexity.CostFunction.flatMap fm 1 a | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ 1 ≤ Complexity.CostFunction.flatMap fm 1 a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply (le_of_eq (Eq.symm (Complexity.CostFunction.flatMap_some hm _))) | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ 1 ≤ Complexity.CostFunction.flatMap fm 1 a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_eq_of_le | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a | case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) =
?b
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Eq.trans | case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) =
?b
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ | case h₁.h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) =
?h₁.b
case h₁.h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?h₁.b = ?b
case h₁.b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_comm | case h₁.h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) =
?h₁.b
case h₁.h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?h₁.b = ?b
case h₁.b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ | case h₁.h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a =
?b
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply (Nat.add_assoc _ _ _).symm | case h₁.h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a =
?b
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_le_add _ (le_refl _) | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a ≤
(subroutineTimeCost h + recurseTimeCost hf h) a +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a ≤
(subroutineTimeCost h + recurseTimeCost hf h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_eq_of_le | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a ≤
(subroutineTimeCost h + recurseTimeCost hf h) a | case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a =
?b
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost hf h) a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply (Nat.add_assoc _ _ _).symm | case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm)))
a =
?b
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost hf h) a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a ≤
(subroutineTimeCost h + recurseTimeCost hf h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_le_add _ (le_refl _) | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a ≤
(subroutineTimeCost h + recurseTimeCost hf h) a | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a ≤
subroutineTimeCost h a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_eq_of_le | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a ≤
subroutineTimeCost h a | case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a =
?b
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤ subroutineTimeCost h a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_comm | case h₁
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) +
subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a =
?b
case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?b ≤ subroutineTimeCost h a
case b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
subroutineTimeCost h a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_le_add (le_refl _) | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ fs✝)
(Complexity.decode γ✝ (Memory.getms m src✝))) ∘
fm))
a +
Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
subroutineTimeCost h a | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Complexity.CostFunction.flatMap (TracedProgram.sound'_subroutine_arg h) (Encoding.getBound hcost) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_le_of_eq _ | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Complexity.CostFunction.flatMap (TracedProgram.sound'_subroutine_arg h) (Encoding.getBound hcost) a | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.178694 = Complexity.CostFunction.flatMap (TracedProgram.sound'_subroutine_arg h) (Encoding.getBound hcost) a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
?m.178694 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Eq.symm | case h₂
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?m.178694 = Complexity.CostFunction.flatMap (TracedProgram.sound'_subroutine_arg h) (Encoding.getBound hcost) a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
?m.178694 | case h₂.h
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.CostFunction.flatMap (TracedProgram.sound'_subroutine_arg h) (Encoding.getBound hcost) a = ?m.178694
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
?m.178694 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Complexity.CostFunction.flatMap_some | case h₂.h
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.CostFunction.flatMap (TracedProgram.sound'_subroutine_arg h) (Encoding.getBound hcost) a = ?m.178694
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ℕ
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
?m.178694 | case h₂.h.h
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ TracedProgram.sound'_subroutine_arg h a = some ?h₂.h.b
case h₂.h.b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ γ✝
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost ?h₂.h.b |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.mem_bind_of_mem | case h₂.h.h
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ TracedProgram.sound'_subroutine_arg h a = some ?h₂.h.b
case h₂.h.b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ γ✝
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost ?h₂.h.b | case h₂.h.h.ha
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?h₂.h.h.a ∈ fm a
case h₂.h.h.hf
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?h₂.h.b ∈ (Complexity.decode γ✝ ∘ flip Memory.getms src✝) ?h₂.h.h.a
case h₂.h.h.a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Memory
case h₂.h.b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ γ✝
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost ?h₂.h.b |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply hm | case h₂.h.h.ha
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?h₂.h.h.a ∈ fm a
case h₂.h.h.hf
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?h₂.h.b ∈ (Complexity.decode γ✝ ∘ flip Memory.getms src✝) ?h₂.h.h.a
case h₂.h.h.a
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Memory
case h₂.h.b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ γ✝
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost ?h₂.h.b | case h₂.h.h.hf
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?h₂.h.b ∈ (Complexity.decode γ✝ ∘ flip Memory.getms src✝) m
case h₂.h.b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ γ✝
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost ?h₂.h.b |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.get_mem | case h₂.h.h.hf
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ ?h₂.h.b ∈ (Complexity.decode γ✝ ∘ flip Memory.getms src✝) m
case h₂.h.b
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ γ✝
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost ?h₂.h.b | case h₂.h.h.hf.h
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Option.isSome ((Complexity.decode γ✝ ∘ flip Memory.getms src✝) m) = true
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost (Option.get ((Complexity.decode γ✝ ∘ flip Memory.getms src✝) m) ?h₂.h.h.hf.h) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply (h.left _ _ hm).elim λ hsome _ ↦ hsome | case h₂.h.h.hf.h
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Option.isSome ((Complexity.decode γ✝ ∘ flip Memory.getms src✝) m) = true
α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost (Option.get ((Complexity.decode γ✝ ∘ flip Memory.getms src✝) m) ?h₂.h.h.hf.h) | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost
(Option.get ((Complexity.decode γ✝ ∘ flip Memory.getms src✝) m)
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_refl | α : Type u_1
inst✝⁷ : Complexity.Coding α Memory
β : Type u_2
inst✝⁶ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁵ : Complexity.Coding γ Memory
inst✝⁴ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝³ : Complexity.Computable Encoding.Model fs
inst✝² : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
γ✝ δ✝ : Type
inst✝¹ : Complexity.Coding γ✝ Memory
inst✝ : Complexity.Encoding δ✝ Memory
fs✝ : γ✝ → δ✝
cs✝ : Complexity.CostFunction γ✝ ℕ
hcost : Complexity Encoding.Model fs✝ cs✝
next : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (subroutine' dst✝ src✝ inst✝¹ inst✝ fs✝ cs✝ hcost next)) fm
a : α
m : Memory
hm : m ∈ fm a
⊢ Complexity.ALE.bound Complexity.cost_ale
(Option.get (Complexity.decode γ✝ (Memory.getms m src✝))
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) ≤
Encoding.getBound hcost
(Option.get ((Complexity.decode γ✝ ∘ flip Memory.getms src✝) m)
(_ : Option.isSome (Complexity.decode γ✝ (Memory.getms m src✝)) = true)) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Stack.hasTimeCost_recurse_le _ | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution { state := x✝, current := toProgram (recurse dst✝ src✝ next✝), function := toProgram fcp } [])
((subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹) | case hr
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasResult
(Stack.execution { state := Memory.getms x✝ src✝, current := toProgram fcp, function := toProgram fcp } [])
?m.179017
case h₀
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution { state := Memory.getms x✝ src✝, current := toProgram fcp, function := toProgram fcp } [])
?m.179014
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{ state := Memory.setms x✝ dst✝ ?m.179017, current := TracedProgram.toProgram (toTracedProgram next✝),
function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 + ?m.179014 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | rw [TracedProgram.sound_recurse_arg (TracedProgram.sound_of_sound' h _ _ hm)] | case hr
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasResult
(Stack.execution { state := Memory.getms x✝ src✝, current := toProgram fcp, function := toProgram fcp } [])
?m.179017
case h₀
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution { state := Memory.getms x✝ src✝, current := toProgram fcp, function := toProgram fcp } [])
?m.179014
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{ state := Memory.setms x✝ dst✝ ?m.179017, current := TracedProgram.toProgram (toTracedProgram next✝),
function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 + ?m.179014 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | case hr
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasResult
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
?m.179017
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory
case h₀
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution { state := Memory.getms x✝ src✝, current := toProgram fcp, function := toProgram fcp } [])
?m.179014
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{ state := Memory.setms x✝ dst✝ ?m.179017, current := TracedProgram.toProgram (toTracedProgram next✝),
function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 + ?m.179014 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Program.hasResult_of_sound hf | case hr
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasResult
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
?m.179017
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory
case h₀
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution { state := Memory.getms x✝ src✝, current := toProgram fcp, function := toProgram fcp } [])
?m.179014
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{ state := Memory.setms x✝ dst✝ ?m.179017, current := TracedProgram.toProgram (toTracedProgram next✝),
function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 + ?m.179014 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | case h₀
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution { state := Memory.getms x✝ src✝, current := toProgram fcp, function := toProgram fcp } [])
?m.179014
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next✝), function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 + ?m.179014 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | rw [TracedProgram.sound_recurse_arg (TracedProgram.sound_of_sound' h _ _ hm)] | case h₀
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution { state := Memory.getms x✝ src✝, current := toProgram fcp, function := toProgram fcp } [])
?m.179014
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next✝), function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 + ?m.179014 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | case h₀
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
?m.179014
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next✝), function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 + ?m.179014 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Stack.timeCost_sound | case h₀
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
?m.179014
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next✝), function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 + ?m.179014 + 1 ≤ (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | case h₀.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.halts
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next✝), function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
?h₀.h +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Program.halts_of_sound hf | case h₀.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.halts
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next✝), function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
?h₀.h +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next✝), function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply splitTimeCost hf (TracedProgram.sound'_recurse_next h) | case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.hasTimeCost
(Stack.execution
{
state :=
Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))),
current := TracedProgram.toProgram (toTracedProgram next✝), function := toProgram fcp }
[])
?m.179013
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179013 +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | case h₁.a
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ∈
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm)
?h₁.a
case h₁.a
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ α
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
?h₁.a +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.mem_bind_of_mem hm | case h₁.a
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ∈
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm)
?h₁.a
case h₁.a
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ α
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
?h₁.a +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | case h₁.a
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ∈
Option.map (Memory.setms x✝ dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms x✝ src✝))
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.mem_map_of_mem | case h₁.a
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory.setms x✝ dst✝
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ∈
Option.map (Memory.setms x✝ dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms x✝ src✝))
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | case h₁.a.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true) ∈
Complexity.decode α (Memory.getms x✝ src✝)
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.get_mem | case h₁.a.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true) ∈
Complexity.decode α (Memory.getms x✝ src✝)
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_le_of_eq _ | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹ | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179858 = (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
?m.179858 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Nat.add_assoc | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.179858 = (subroutineTimeCost h + recurseTimeCost hf h + localTimeCost h) x✝¹
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
?m.179858 | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ +
Complexity.CostFunction.flatMap fm 1 x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_le_add _ | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
1 ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ +
Complexity.CostFunction.flatMap fm 1 x✝¹ | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ 1 ≤ Complexity.CostFunction.flatMap fm 1 x✝¹
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply (le_of_eq (Eq.symm (Complexity.CostFunction.flatMap_some hm _))) | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ 1 ≤ Complexity.CostFunction.flatMap fm 1 x✝¹
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_eq_of_le | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ | case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) =
?b
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Eq.trans | case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) =
?b
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ | case h₁.h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) =
?h₁.b
case h₁.h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₁.b = ?b
case h₁.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_comm | case h₁.h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) =
?h₁.b
case h₁.h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₁.b = ?b
case h₁.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ | case h₁.h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ =
?b
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply (Nat.add_assoc _ _ _).symm | case h₁.h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ =
?b
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_le_add _ (le_refl _) | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ +
localTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_eq_of_le | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ | case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ =
?b
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost hf h) x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Eq.trans | case h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ =
?b
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost hf h) x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ | case h₁.h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ =
?h₁.b
case h₁.h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₁.b = ?b
case h₁.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost hf h) x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_comm | case h₁.h₁
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) +
(subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ =
?h₁.b
case h₁.h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₁.b = ?b
case h₁.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost hf h) x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ | case h₁.h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) =
?b
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost hf h) x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Nat.add_assoc _ _ _ | case h₁.h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ (subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)) +
recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm)))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) =
?b
case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost hf h) x✝¹
case b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ +
(recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true))))) ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_le_add (le_refl _) | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ subroutineTimeCost
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ +
(recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f)
(Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true))))) ≤
(subroutineTimeCost h + recurseTimeCost hf h) x✝¹ | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
recurseTimeCost hf h x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply add_le_add (le_refl _) | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ recurseTimeCost hf
(_ :
TracedProgram.sound' f size (toTracedProgram next✝)
((flip Option.bind fun m =>
Option.map (Memory.setms m dst✝ ∘ Complexity.encode ∘ f) (Complexity.decode α (Memory.getms m src✝))) ∘
fm))
x✝¹ +
Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
recurseTimeCost hf h x✝¹ | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Complexity.CostFunction.flatMap (TracedProgram.sound'_recurse_arg h)
(fun arg =>
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode arg)))
x✝¹ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_of_le_of_eq _ | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Complexity.CostFunction.flatMap (TracedProgram.sound'_recurse_arg h)
(fun arg =>
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode arg)))
x✝¹ | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.183728 =
Complexity.CostFunction.flatMap (TracedProgram.sound'_recurse_arg h)
(fun arg =>
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode arg)))
x✝¹
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
?m.183728 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Eq.symm | case h₂
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?m.183728 =
Complexity.CostFunction.flatMap (TracedProgram.sound'_recurse_arg h)
(fun arg =>
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode arg)))
x✝¹
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
?m.183728 | case h₂.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Complexity.CostFunction.flatMap (TracedProgram.sound'_recurse_arg h)
(fun arg =>
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode arg)))
x✝¹ =
?m.183728
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
?m.183728 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Complexity.CostFunction.flatMap_some | case h₂.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Complexity.CostFunction.flatMap (TracedProgram.sound'_recurse_arg h)
(fun arg =>
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode arg)))
x✝¹ =
?m.183728
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ℕ
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
?m.183728 | case h₂.h.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ TracedProgram.sound'_recurse_arg h x✝¹ = some ?h₂.h.b
case h₂.h.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ α
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode ?h₂.h.b)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.mem_bind_of_mem | case h₂.h.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ TracedProgram.sound'_recurse_arg h x✝¹ = some ?h₂.h.b
case h₂.h.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ α
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode ?h₂.h.b)) | case h₂.h.h.ha
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₂.h.h.a ∈ fm x✝¹
case h₂.h.h.hf
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₂.h.b ∈ (Complexity.decode α ∘ flip Memory.getms src✝) ?h₂.h.h.a
case h₂.h.h.a
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory
case h₂.h.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ α
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode ?h₂.h.b)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply hm | case h₂.h.h.ha
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₂.h.h.a ∈ fm x✝¹
case h₂.h.h.hf
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₂.h.b ∈ (Complexity.decode α ∘ flip Memory.getms src✝) ?h₂.h.h.a
case h₂.h.h.a
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Memory
case h₂.h.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ α
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode ?h₂.h.b)) | case h₂.h.h.hf
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₂.h.b ∈ (Complexity.decode α ∘ flip Memory.getms src✝) x✝
case h₂.h.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ α
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode ?h₂.h.b)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply Option.get_mem | case h₂.h.h.hf
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ ?h₂.h.b ∈ (Complexity.decode α ∘ flip Memory.getms src✝) x✝
case h₂.h.b
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ α
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ : Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp)) (Complexity.encode ?h₂.h.b)) | case h₂.h.h.hf.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Option.isSome ((Complexity.decode α ∘ flip Memory.getms src✝) x✝) = true
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode (Option.get ((Complexity.decode α ∘ flip Memory.getms src✝) x✝) ?h₂.h.h.hf.h))) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply (h.left _ _ hm).elim λ hsome _ ↦ hsome | case h₂.h.h.hf.h
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Option.isSome ((Complexity.decode α ∘ flip Memory.getms src✝) x✝) = true
α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode (Option.get ((Complexity.decode α ∘ flip Memory.getms src✝) x✝) ?h₂.h.h.hf.h))) | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get ((Complexity.decode α ∘ flip Memory.getms src✝) x✝)
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Trace.CostedProgram.splitTimeCost | [244, 1] | [349, 16] | apply le_refl | α : Type u_1
inst✝⁵ : Complexity.Coding α Memory
β : Type u_2
inst✝⁴ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝³ : Complexity.Coding γ Memory
inst✝² : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝¹ : Complexity.Computable Encoding.Model fs
inst✝ : Complexity Encoding.Model fs cs
size : α → ℕ
fm : α → Option Memory
fcp : CostedProgram
hf : Program.sound (TracedProgram.toProgram (toTracedProgram fcp)) f size
dst✝ src✝ : Source
next✝ : CostedProgram
h : TracedProgram.sound' f size (toTracedProgram (recurse dst✝ src✝ next✝)) fm
x✝¹ : α
x✝ : Memory
hm : x✝ ∈ fm x✝¹
⊢ Stack.timeCost
(Stack.execution
{
state :=
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)),
current := toProgram fcp, function := toProgram fcp }
[])
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get (Complexity.decode α (Memory.getms x✝ src✝))
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) ≤
Program.timeCost (TracedProgram.toProgram (toTracedProgram fcp))
(_ :
Program.haltsOn (TracedProgram.toProgram (toTracedProgram fcp))
(Complexity.encode
(Option.get ((Complexity.decode α ∘ flip Memory.getms src✝) x✝)
(_ : Option.isSome (Complexity.decode α (Memory.getms x✝ src✝)) = true)))) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Program.splitTimeCost | [433, 1] | [438, 18] | intro a | TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
⊢ timeCost' p h ≤ subroutineTimeCost h + recurseTimeCost h + localTimeCost h | TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ timeCost' p h a ≤ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Program.splitTimeCost | [433, 1] | [438, 18] | apply le_trans | TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ timeCost' p h a ≤ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a | case a
TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ timeCost' p h a ≤ ?b
case a
TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a
case b
TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Program.splitTimeCost | [433, 1] | [438, 18] | exact (Stack.timeCost_le_iff _ (Program.halts_of_sound h _)).mp (p.costedMatches ▸ p.costed.splitTimeCost (costed_sound h) (costed_sound' h) a _ (Option.mem_some_iff.mpr rfl)) | case a
TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ timeCost' p h a ≤ ?b
case a
TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ ?b ≤ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a
case b
TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ ℕ | case a
TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ (Trace.CostedProgram.subroutineTimeCost
(_ :
Trace.TracedProgram.sound' f sz (Trace.CostedProgram.toTracedProgram (costed p))
(some ∘ Complexity.encode)) +
Trace.CostedProgram.recurseTimeCost
(_ : sound (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) f sz)
(_ :
Trace.TracedProgram.sound' f sz (Trace.CostedProgram.toTracedProgram (costed p))
(some ∘ Complexity.encode)) +
Trace.CostedProgram.localTimeCost
(_ :
Trace.TracedProgram.sound' f sz (Trace.CostedProgram.toTracedProgram (costed p))
(some ∘ Complexity.encode)))
a ≤
(subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Cost.lean | HMem.Program.splitTimeCost | [433, 1] | [438, 18] | exact le_refl _ | case a
TracedProgram : Sort ?u.211566
α : Type u_1
inst✝⁶ : Complexity.Coding α Memory
β : Type u_2
inst✝⁵ : Complexity.Encoding β Memory
f : α → β
tp : TracedProgram
γ δ : Type
inst✝⁴ : Complexity.Coding γ Memory
inst✝³ : Complexity.Encoding δ Memory
fs : γ → δ
cs : Complexity.CostFunction γ ℕ
inst✝² : Complexity.Computable Encoding.Model fs
inst✝¹ : Complexity Encoding.Model fs cs
sz : α → ℕ
p : Program
inst✝ : Trace.HasCostedProgram p
h : sound p f sz
a : α
⊢ (Trace.CostedProgram.subroutineTimeCost
(_ :
Trace.TracedProgram.sound' f sz (Trace.CostedProgram.toTracedProgram (costed p))
(some ∘ Complexity.encode)) +
Trace.CostedProgram.recurseTimeCost
(_ : sound (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) f sz)
(_ :
Trace.TracedProgram.sound' f sz (Trace.CostedProgram.toTracedProgram (costed p))
(some ∘ Complexity.encode)) +
Trace.CostedProgram.localTimeCost
(_ :
Trace.TracedProgram.sound' f sz (Trace.CostedProgram.toTracedProgram (costed p))
(some ∘ Complexity.encode)))
a ≤
(subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_sum_getm_t | [73, 9] | [74, 59] | cases v <;> simp | α : Type u_1
β : Type u_2
inst✝¹ : Encoding α Memory
inst✝ : Encoding β Memory
v : α ⊕ β
⊢ Memory.getm (encode v) true = 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeList_inj | [88, 1] | [92, 90] | simp[encodeList] | α : Type u_1
inst✝ : Encoding α Memory
head✝ : α
tail✝ : List α
⊢ encodeList [] = encodeList (head✝ :: tail✝) → [] = head✝ :: tail✝ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeList_inj | [88, 1] | [92, 90] | simp[encodeList] | α : Type u_1
inst✝ : Encoding α Memory
head✝ : α
tail✝ : List α
⊢ encodeList (head✝ :: tail✝) = encodeList [] → head✝ :: tail✝ = [] | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeList_inj | [88, 1] | [92, 90] | simp[encodeList, Iff.intro (encodeList_inj lhs rhs) λ h ↦ h ▸ rfl] | α : Type u_1
inst✝ : Encoding α Memory
head✝¹ : α
lhs : List α
head✝ : α
rhs : List α
⊢ encodeList (head✝¹ :: lhs) = encodeList (head✝ :: rhs) → head✝¹ :: lhs = head✝ :: rhs | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.rawDecodeList_inv | [101, 1] | [103, 87] | simpa [encodeList, decodeList, rawDecodeList] using rawDecodeList_inv tl | α : Type u_1
inst✝ : Coding α Memory
head✝ : α
tl : List α
⊢ decodeList (encodeList (head✝ :: tl)) = some (head✝ :: tl) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.tupleInj_eq | [145, 9] | [147, 44] | simp [encodeFinTuple_def, List.ofFn_inj'] | α : Type u_1
inst✝ : Encoding α Memory
N₀ N₁ : ℕ
f₀ : Fin N₀ → α
f₁ : Fin N₁ → α
⊢ (encode f₀ = encode f₁) = (N₀ = N₁ ∧ HEq f₀ f₁) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_inj | [168, 1] | [180, 41] | simpa [encodeOp] using λ h ↦ funext λ x ↦ Subsingleton.elim _ x ▸ h | α : Type u_1
inst✝ : Encoding α Memory
f₀ f₁ : (Fin 0 → Bool) → α
⊢ encodeOp f₀ = encodeOp f₁ → f₀ = f₁ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_inj | [168, 1] | [180, 41] | simpa [encodeOp,
λ b ↦ Iff.intro
(encodeOp_inj
(f₀ ∘ (Fin.cons (α := λ _ ↦ Bool) b))
(f₁ ∘ (Fin.cons (α := λ _ ↦ Bool) b)))
(λ h ↦ h ▸ rfl)]
using λ hf ht ↦ funext λ y ↦ Fin.cons_self_tail y ▸
match y 0 with
| false => congrFun hf (Fin.tail y)
| true => congrFun ht (Fin.tail y) | α : Type u_1
inst✝ : Encoding α Memory
N : ℕ
f₀ f₁ : (Fin (N + 1) → Bool) → α
⊢ encodeOp f₀ = encodeOp f₁ → f₀ = f₁ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | simpa [decodeOp, encodeOp]
using funext λ _ ↦ congrArg _ (funext finZeroElim) | α : Type u_1
inst✝ : Coding α Memory
x✝ : (Fin 0 → Bool) → α
⊢ decodeOp (encodeOp x✝) = some x✝ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | simp [decodeOp, encodeOp, decodeOp_inv (N := N)] | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
⊢ decodeOp (encodeOp g) = some g | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
⊢ (fun g_1 =>
match g_1 0 with
| false => g (Fin.cons false (Fin.tail g_1))
| true => g (Fin.cons true (Fin.tail g_1))) =
g |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | apply funext | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
⊢ (fun g_1 =>
match g_1 0 with
| false => g (Fin.cons false (Fin.tail g_1))
| true => g (Fin.cons true (Fin.tail g_1))) =
g | case h
α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
⊢ ∀ (x : Fin (N + 1) → Bool),
(match x 0 with
| false => g (Fin.cons false (Fin.tail x))
| true => g (Fin.cons true (Fin.tail x))) =
g x |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | intro x | case h
α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
⊢ ∀ (x : Fin (N + 1) → Bool),
(match x 0 with
| false => g (Fin.cons false (Fin.tail x))
| true => g (Fin.cons true (Fin.tail x))) =
g x | case h
α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
x : Fin (N + 1) → Bool
⊢ (match x 0 with
| false => g (Fin.cons false (Fin.tail x))
| true => g (Fin.cons true (Fin.tail x))) =
g x |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | match h:x 0 with
| true =>
apply congrArg g
exact h ▸ Fin.cons_self_tail _
| false =>
apply congrArg g
exact h ▸ Fin.cons_self_tail _ | case h
α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
x : Fin (N + 1) → Bool
⊢ (match x 0 with
| false => g (Fin.cons false (Fin.tail x))
| true => g (Fin.cons true (Fin.tail x))) =
g x | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | apply congrArg g | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
x : Fin (N + 1) → Bool
h : x 0 = true
⊢ (match true with
| false => g (Fin.cons false (Fin.tail x))
| true => g (Fin.cons true (Fin.tail x))) =
g x | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
x : Fin (N + 1) → Bool
h : x 0 = true
⊢ Fin.cons true (Fin.tail x) = x |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | exact h ▸ Fin.cons_self_tail _ | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
x : Fin (N + 1) → Bool
h : x 0 = true
⊢ Fin.cons true (Fin.tail x) = x | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | apply congrArg g | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
x : Fin (N + 1) → Bool
h : x 0 = false
⊢ (match false with
| false => g (Fin.cons false (Fin.tail x))
| true => g (Fin.cons true (Fin.tail x))) =
g x | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
x : Fin (N + 1) → Bool
h : x 0 = false
⊢ Fin.cons false (Fin.tail x) = x |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decodeOp_inv | [195, 1] | [209, 35] | exact h ▸ Fin.cons_self_tail _ | α : Type u_1
inst✝ : Coding α Memory
N : ℕ
g : (Fin (N + 1) → Bool) → α
x : Fin (N + 1) → Bool
h : x 0 = false
⊢ Fin.cons false (Fin.tail x) = x | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_injN | [221, 1] | [226, 53] | cases N₁ <;> simp [encodeOp_zeroDef, encodeOp_succDef] | α : Type u_1
inst✝ : Encoding α Memory
N₁ : ℕ
x✝¹ : (Fin 0 → Bool) → α
x✝ : (Fin N₁ → Bool) → α
⊢ encode x✝¹ = encode x✝ → 0 = N₁ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_injN | [221, 1] | [226, 53] | simp [encodeOp_zeroDef, encodeOp_succDef] | α : Type u_1
inst✝ : Encoding α Memory
N₀ : ℕ
x✝¹ : (Fin (N₀ + 1) → Bool) → α
x✝ : (Fin 0 → Bool) → α
⊢ encode x✝¹ = encode x✝ → N₀ + 1 = 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_injN | [221, 1] | [226, 53] | simpa [encodeOp_succDef] using λ _ ↦ encodeOp_injN | α : Type u_1
inst✝ : Encoding α Memory
N₀ N₁ : ℕ
f₀ : (Fin (N₀ + 1) → Bool) → α
f₁ : (Fin (N₁ + 1) → Bool) → α
⊢ encode f₀ = encode f₁ → N₀ + 1 = N₁ + 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_injEq | [228, 9] | [232, 48] | cases (encodeOp_injN h) | α : Type u_1
inst✝ : Encoding α Memory
N₀ N₁ : ℕ
f₀ : (Fin N₀ → Bool) → α
f₁ : (Fin N₁ → Bool) → α
h : encode f₀ = encode f₁
⊢ N₀ = N₁ ∧ HEq f₀ f₁ | case refl
α : Type u_1
inst✝ : Encoding α Memory
N₀ : ℕ
f₀ f₁ : (Fin N₀ → Bool) → α
h : encode f₀ = encode f₁
⊢ N₀ = N₀ ∧ HEq f₀ f₁ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_injEq | [228, 9] | [232, 48] | simp [h, ← encodeInjEq] | case refl
α : Type u_1
inst✝ : Encoding α Memory
N₀ : ℕ
f₀ f₁ : (Fin N₀ → Bool) → α
h : encode f₀ = encode f₁
⊢ N₀ = N₀ ∧ HEq f₀ f₁ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_injEq | [228, 9] | [232, 48] | cases h.left | α : Type u_1
inst✝ : Encoding α Memory
N₀ N₁ : ℕ
f₀ : (Fin N₀ → Bool) → α
f₁ : (Fin N₁ → Bool) → α
h : N₀ = N₁ ∧ HEq f₀ f₁
⊢ encode f₀ = encode f₁ | case refl
α : Type u_1
inst✝ : Encoding α Memory
N₀ : ℕ
f₀ f₁ : (Fin N₀ → Bool) → α
h : N₀ = N₀ ∧ HEq f₀ f₁
⊢ encode f₀ = encode f₁ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_injEq | [228, 9] | [232, 48] | cases h.right | case refl
α : Type u_1
inst✝ : Encoding α Memory
N₀ : ℕ
f₀ f₁ : (Fin N₀ → Bool) → α
h : N₀ = N₀ ∧ HEq f₀ f₁
⊢ encode f₀ = encode f₁ | case refl.refl
α : Type u_1
inst✝ : Encoding α Memory
N₀ : ℕ
f₀ : (Fin N₀ → Bool) → α
h : N₀ = N₀ ∧ HEq f₀ f₀
⊢ encode f₀ = encode f₀ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encodeOp_injEq | [228, 9] | [232, 48] | rfl | case refl.refl
α : Type u_1
inst✝ : Encoding α Memory
N₀ : ℕ
f₀ : (Fin N₀ → Bool) → α
h : N₀ = N₀ ∧ HEq f₀ f₀
⊢ encode f₀ = encode f₀ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | refine Nat.binaryRec' (n := n) Memory.zero_def'.symm ?hi | n : ℕ
⊢ encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2)) | case hi
n : ℕ
⊢ ∀ (b : Bool) (n : ℕ),
(n = 0 → b = true) →
encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2)) →
encode (Nat.bit b n) =
Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | intro b n hn _ | case hi
n : ℕ
⊢ ∀ (b : Bool) (n : ℕ),
(n = 0 → b = true) →
encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2)) →
encode (Nat.bit b n) =
Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2)) | case hi
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode (Nat.bit b n) =
Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | apply Eq.trans | case hi
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode (Nat.bit b n) =
Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2)) | case hi.h₁
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode (Nat.bit b n) = ?hi.b
case hi.h₂
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ ?hi.b = Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2))
case hi.b
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ Memory |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | apply congrArg (encode (α := List Bool)) | case hi.h₁
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode (Nat.bit b n) = ?hi.b
case hi.h₂
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ ?hi.b = Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2))
case hi.b
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ Memory | case hi.h₁
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ Nat.bits (Nat.bit b n) = ?m.80295
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ List Bool
case hi.h₂
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode ?m.80295 =
Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | apply Nat.bits_append_bit _ _ hn | case hi.h₁
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ Nat.bits (Nat.bit b n) = ?m.80295
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ List Bool
case hi.h₂
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode ?m.80295 =
Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2)) | case hi.h₂
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode (b :: Nat.bits n) =
Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | apply Memory.mk_inj_iff.mpr | case hi.h₂
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode (b :: Nat.bits n) =
Memory.mk (decide (Nat.bit b n ≠ 0)) (encode (decide (Nat.bit b n % 2 = 1))) (encode (Nat.bit b n / 2)) | case hi.h₂
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ true = decide (Nat.bit b n ≠ 0) ∧
encode b = encode (decide (Nat.bit b n % 2 = 1)) ∧ encodeList (Nat.bits n) = encode (Nat.bit b n / 2) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | apply And.intro | case hi.h₂
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ true = decide (Nat.bit b n ≠ 0) ∧
encode b = encode (decide (Nat.bit b n % 2 = 1)) ∧ encodeList (Nat.bits n) = encode (Nat.bit b n / 2) | case hi.h₂.left
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ true = decide (Nat.bit b n ≠ 0)
case hi.h₂.right
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode b = encode (decide (Nat.bit b n % 2 = 1)) ∧ encodeList (Nat.bits n) = encode (Nat.bit b n / 2) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | exact Eq.symm (decide_eq_true λ h ↦ absurd ((Nat.bit_eq_zero.mp h).right.symm.trans (hn (Nat.bit_eq_zero.mp h).left)) Bool.noConfusion) | case hi.h₂.left
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ true = decide (Nat.bit b n ≠ 0)
case hi.h₂.right
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode b = encode (decide (Nat.bit b n % 2 = 1)) ∧ encodeList (Nat.bits n) = encode (Nat.bit b n / 2) | case hi.h₂.right
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode b = encode (decide (Nat.bit b n % 2 = 1)) ∧ encodeList (Nat.bits n) = encode (Nat.bit b n / 2) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | cases b <;> simp [-Nat.bit_false, -Nat.bit_true, Nat.bit_mod_two, Nat.bit_div_2] | case hi.h₂.right
n✝ : ℕ
b : Bool
n : ℕ
hn : n = 0 → b = true
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
⊢ encode b = encode (decide (Nat.bit b n % 2 = 1)) ∧ encodeList (Nat.bits n) = encode (Nat.bit b n / 2) | case hi.h₂.right.false
n✝ n : ℕ
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
hn : n = 0 → false = true
⊢ encodeList (Nat.bits n) = encode n
case hi.h₂.right.true
n✝ n : ℕ
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
hn : n = 0 → true = true
⊢ encodeList (Nat.bits n) = encode n |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.