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/Master.lean
blah4
[24, 1]
[33, 25]
apply Nat.le_add_right
case h a b x : ℕ ⊢ a ≤ a + b
no goals
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah5
[35, 1]
[37, 30]
simp
a b x : ℕ ⊢ x ^ (a + b) - x ^ a ≤ (x + 0) ^ (a + b) - (x + 0) ^ a
no goals
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
cases a <;> cases b <;> cases y <;> simp [Nat.pow_add]
a b y : ℕ ⊢ (0 + y) ^ a - 0 ^ a ≤ (0 + y) ^ (a + b) - 0 ^ (a + b)
case succ.succ.succ n✝² n✝¹ n✝ : ℕ ⊢ 1 ≤ Nat.succ n✝ ^ Nat.succ n✝¹
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
exact le_trans (Nat.pow_le_pow_right (Nat.zero_lt_succ 0) (Nat.succ_le_succ (Nat.zero_le _))) (Nat.pow_le_pow_left (Nat.succ_le_succ (Nat.zero_le _)) _)
case succ.succ.succ n✝² n✝¹ n✝ : ℕ ⊢ 1 ≤ Nat.succ n✝ ^ Nat.succ n✝¹
no goals
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.le_sub_of_add_le
a b y x : ℕ ⊢ (x + 1 + y) ^ a - (x + 1) ^ a ≤ (x + 1 + y) ^ (a + b) - (x + 1) ^ (a + b)
case h a b y x : ℕ ⊢ (x + 1 + y) ^ a - (x + 1) ^ a + (x + 1) ^ (a + b) ≤ (x + 1 + y) ^ (a + b)
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
rw [← Nat.sub_add_comm, add_comm (_ ^ _), Nat.sub_add_comm]
case h a b y x : ℕ ⊢ (x + 1 + y) ^ a - (x + 1) ^ a + (x + 1) ^ (a + b) ≤ (x + 1 + y) ^ (a + b)
case h a b y x : ℕ ⊢ (x + 1) ^ (a + b) - (x + 1) ^ a + (x + 1 + y) ^ a ≤ (x + 1 + y) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.add_le_of_le_sub _ blah5
case h a b y x : ℕ ⊢ (x + 1) ^ (a + b) - (x + 1) ^ a + (x + 1 + y) ^ a ≤ (x + 1 + y) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
a b y x : ℕ ⊢ (x + 1 + y) ^ a ≤ (x + 1 + y) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.pow_le_pow_right
a b y x : ℕ ⊢ (x + 1 + y) ^ a ≤ (x + 1 + y) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
case hx a b y x : ℕ ⊢ x + 1 + y > 0 case a a b y x : ℕ ⊢ a ≤ a + b case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.lt_add_right _ (Nat.zero_lt_succ _)
case hx a b y x : ℕ ⊢ x + 1 + y > 0 case a a b y x : ℕ ⊢ a ≤ a + b case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
case a a b y x : ℕ ⊢ a ≤ a + b case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.le_add_right
case a a b y x : ℕ ⊢ a ≤ a + b case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.pow_le_pow_right
case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1) ^ (a + b) case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
case h.hx a b y x : ℕ ⊢ x + 1 > 0 case h.a a b y x : ℕ ⊢ a ≤ a + b case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.zero_lt_succ _
case h.hx a b y x : ℕ ⊢ x + 1 > 0 case h.a a b y x : ℕ ⊢ a ≤ a + b case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
case h.a a b y x : ℕ ⊢ a ≤ a + b case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.le_add_right
case h.a a b y x : ℕ ⊢ a ≤ a + b case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.pow_le_pow_left
case h a b y x : ℕ ⊢ (x + 1) ^ a ≤ (x + 1 + y) ^ a
case h.h a b y x : ℕ ⊢ x + 1 ≤ x + 1 + y
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah6
[39, 1]
[55, 25]
apply Nat.le_add_right
case h.h a b y x : ℕ ⊢ x + 1 ≤ x + 1 + y
no goals
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah7
[57, 1]
[62, 14]
apply (Nat.exists_eq_add_of_le hab).elim
a b x y : ℕ hab : a ≤ b hxy : x ≤ y ⊢ y ^ a - x ^ a ≤ y ^ b - x ^ b
a b x y : ℕ hab : a ≤ b hxy : x ≤ y ⊢ ∀ (a_1 : ℕ), b = a + a_1 → y ^ a - x ^ a ≤ y ^ b - x ^ b
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah7
[57, 1]
[62, 14]
apply (Nat.exists_eq_add_of_le hxy).elim
a b x y : ℕ hab : a ≤ b hxy : x ≤ y ⊢ ∀ (a_1 : ℕ), b = a + a_1 → y ^ a - x ^ a ≤ y ^ b - x ^ b
a b x y : ℕ hab : a ≤ b hxy : x ≤ y ⊢ ∀ (a_1 : ℕ), y = x + a_1 → ∀ (a_3 : ℕ), b = a + a_3 → y ^ a - x ^ a ≤ y ^ b - x ^ b
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah7
[57, 1]
[62, 14]
intro _ hxy _ hab
a b x y : ℕ hab : a ≤ b hxy : x ≤ y ⊢ ∀ (a_1 : ℕ), y = x + a_1 → ∀ (a_3 : ℕ), b = a + a_3 → y ^ a - x ^ a ≤ y ^ b - x ^ b
a b x y : ℕ hab✝ : a ≤ b hxy✝ : x ≤ y a✝¹ : ℕ hxy : y = x + a✝¹ a✝ : ℕ hab : b = a + a✝ ⊢ y ^ a - x ^ a ≤ y ^ b - x ^ b
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah7
[57, 1]
[62, 14]
rw [hxy, hab]
a b x y : ℕ hab✝ : a ≤ b hxy✝ : x ≤ y a✝¹ : ℕ hxy : y = x + a✝¹ a✝ : ℕ hab : b = a + a✝ ⊢ y ^ a - x ^ a ≤ y ^ b - x ^ b
a b x y : ℕ hab✝ : a ≤ b hxy✝ : x ≤ y a✝¹ : ℕ hxy : y = x + a✝¹ a✝ : ℕ hab : b = a + a✝ ⊢ (x + a✝¹) ^ a - x ^ a ≤ (x + a✝¹) ^ (a + a✝) - x ^ (a + a✝)
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
blah7
[57, 1]
[62, 14]
exact blah6
a b x y : ℕ hab✝ : a ≤ b hxy✝ : x ≤ y a✝¹ : ℕ hxy : y = x + a✝¹ a✝ : ℕ hab : b = a + a✝ ⊢ (x + a✝¹) ^ a - x ^ a ≤ (x + a✝¹) ^ (a + a✝) - x ^ (a + a✝)
no goals
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
induction n using Nat.case_strong_induction_on with | hi n₀ ih => intro a hsz apply le_trans (splitTimeCost _ _) apply le_of_eq_of_le apply Eq.trans apply Nat.add_right_comm _ _ _ apply Nat.add_comm apply add_le_add _ apply hsi apply le_trans apply Trace.CostedProgram.recurseTimeCostBound (x := x * n₀ + x) intro arg harg apply le_trans _ (add_le_add_right (mul_le_mul (le_refl _ ) _ (zero_le _) (zero_le _)) _) use sz arg specialize ih (sz arg) _ apply Nat.succ_le_succ_iff.mp apply le_of_le_of_eq _ hsz apply Nat.succ_le_of_lt harg specialize ih _ rfl simp only [p.costedMatches'] apply ih apply Nat.succ_le_succ_iff.mp apply le_of_le_of_eq _ hsz apply Nat.succ_le_of_lt harg simp only [p.costedMatches, hr, one_mul, Nat.mul_succ] apply le_refl | hz => intro a hsz apply le_trans (splitTimeCost _ _) apply le_of_eq_of_le apply Eq.trans apply Nat.add_right_comm _ _ _ apply Nat.add_comm apply add_le_add _ apply hsi apply le_of_eq_of_le _ (zero_le _) apply Trace.CostedProgram.recurseTimeCost_leaf (costed_sound h) _ hsz
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n : ℕ ⊢ ∀ (a : α), sz a = n → timeCost' p h a ≤ x * n + x
no goals
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
intro a hsz
case hi TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x ⊢ ∀ (a : α), sz a = Nat.succ n₀ → timeCost' p h a ≤ x * Nat.succ n₀ + x
case hi TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ timeCost' p h a ≤ x * Nat.succ n₀ + x
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_trans (splitTimeCost _ _)
case hi TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ timeCost' p h a ≤ x * Nat.succ n₀ + x
case hi TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a ≤ x * Nat.succ n₀ + x
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_of_eq_of_le
case hi TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a ≤ x * Nat.succ n₀ + x
case hi.h₁ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a = ?hi.b case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?hi.b ≤ x * Nat.succ n₀ + x case hi.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Eq.trans
case hi.h₁ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a = ?hi.b case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?hi.b ≤ x * Nat.succ n₀ + x case hi.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ
case hi.h₁.h₁ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a = ?hi.h₁.b case hi.h₁.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?hi.h₁.b = ?hi.b case hi.h₁.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?hi.b ≤ x * Nat.succ n₀ + x case hi.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Nat.add_right_comm _ _ _
case hi.h₁.h₁ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a = ?hi.h₁.b case hi.h₁.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?hi.h₁.b = ?hi.b case hi.h₁.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?hi.b ≤ x * Nat.succ n₀ + x case hi.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ
case hi.h₁.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ subroutineTimeCost h a + localTimeCost h a + recurseTimeCost h a = ?hi.b case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?hi.b ≤ x * Nat.succ n₀ + x case hi.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Nat.add_comm
case hi.h₁.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ subroutineTimeCost h a + localTimeCost h a + recurseTimeCost h a = ?hi.b case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?hi.b ≤ x * Nat.succ n₀ + x case hi.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ
case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ recurseTimeCost h a + (subroutineTimeCost h a + localTimeCost h a) ≤ x * Nat.succ n₀ + x
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply add_le_add _
case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ recurseTimeCost h a + (subroutineTimeCost h a + localTimeCost h a) ≤ x * Nat.succ n₀ + x
case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ subroutineTimeCost h a + localTimeCost h a ≤ x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ recurseTimeCost h a ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply hsi
case hi.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ subroutineTimeCost h a + localTimeCost h a ≤ x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ recurseTimeCost h a ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ recurseTimeCost h a ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_trans
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ recurseTimeCost h a ≤ x * Nat.succ n₀
case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ recurseTimeCost h a ≤ ?b case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?b ≤ x * Nat.succ n₀ case b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Trace.CostedProgram.recurseTimeCostBound (x := x * n₀ + x)
case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ recurseTimeCost h a ≤ ?b case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ?b ≤ x * Nat.succ n₀ case b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ℕ
case a.hsz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ∀ (arg : α), sz arg < sz a → timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * n₀ + x case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
intro arg harg
case a.hsz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ ∀ (arg : α), sz arg < sz a → timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * n₀ + x case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
case a.hsz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * n₀ + x case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_trans _ (add_le_add_right (mul_le_mul (le_refl _ ) _ (zero_le _) (zero_le _)) _)
case a.hsz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * n₀ + x case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ ℕ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * ?m.159899 + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ ?m.159899 ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
use sz arg
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ ℕ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * ?m.159899 + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ ?m.159899 ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
specialize ih (sz arg) _
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : ∀ (a : α), sz a = sz arg → timeCost' p h a ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Nat.succ_le_succ_iff.mp
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : ∀ (a : α), sz a = sz arg → timeCost' p h a ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ Nat.succ (sz arg) ≤ Nat.succ n₀ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : ∀ (a : α), sz a = sz arg → timeCost' p h a ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_of_le_of_eq _ hsz
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ Nat.succ (sz arg) ≤ Nat.succ n₀ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : ∀ (a : α), sz a = sz arg → timeCost' p h a ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ Nat.succ (sz arg) ≤ sz a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : ∀ (a : α), sz a = sz arg → timeCost' p h a ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Nat.succ_le_of_lt harg
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ Nat.succ (sz arg) ≤ sz a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : ∀ (a : α), sz a = sz arg → timeCost' p h a ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : ∀ (a : α), sz a = sz arg → timeCost' p h a ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
specialize ih _ rfl
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : ∀ (a : α), sz a = sz arg → timeCost' p h a ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : timeCost' p h arg ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
simp only [p.costedMatches']
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : timeCost' p h arg ≤ x * sz arg + x ⊢ timeCost (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (_ : haltsOn (Trace.TracedProgram.toProgram (Trace.CostedProgram.toTracedProgram (costed p))) (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : timeCost' p h arg ≤ x * sz arg + x ⊢ timeCost p (_ : haltsOn p (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply ih
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ih : timeCost' p h arg ≤ x * sz arg + x ⊢ timeCost p (_ : haltsOn p (Complexity.encode arg)) ≤ x * sz arg + x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Nat.succ_le_succ_iff.mp
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ sz arg ≤ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ Nat.succ (sz arg) ≤ Nat.succ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_of_le_of_eq _ hsz
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ Nat.succ (sz arg) ≤ Nat.succ n₀ case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ Nat.succ (sz arg) ≤ sz a case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Nat.succ_le_of_lt harg
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ arg : α harg : sz arg < sz a ⊢ Nat.succ (sz arg) ≤ sz a case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
simp only [p.costedMatches, hr, one_mul, Nat.mul_succ]
case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ maxRecurse (Trace.CostedProgram.toProgram (costed p)) * (x * n₀ + x) ≤ x * Nat.succ n₀
case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ x * n₀ + x ≤ x * n₀ + x
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_refl
case a TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 n₀ : ℕ ih : ∀ m ≤ n₀, ∀ (a : α), sz a = m → timeCost' p h a ≤ x * m + x a : α hsz : sz a = Nat.succ n₀ ⊢ x * n₀ + x ≤ x * n₀ + x
no goals
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
intro a hsz
case hz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 ⊢ ∀ (a : α), sz a = 0 → timeCost' p h a ≤ x * 0 + x
case hz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ timeCost' p h a ≤ x * 0 + x
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_trans (splitTimeCost _ _)
case hz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ timeCost' p h a ≤ x * 0 + x
case hz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a ≤ x * 0 + x
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_of_eq_of_le
case hz TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a ≤ x * 0 + x
case hz.h₁ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a = ?hz.b case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ?hz.b ≤ x * 0 + x case hz.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ℕ
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Eq.trans
case hz.h₁ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a = ?hz.b case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ?hz.b ≤ x * 0 + x case hz.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ℕ
case hz.h₁.h₁ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a = ?hz.h₁.b case hz.h₁.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ?hz.h₁.b = ?hz.b case hz.h₁.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ℕ case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ?hz.b ≤ x * 0 + x case hz.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ℕ
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Nat.add_right_comm _ _ _
case hz.h₁.h₁ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ (subroutineTimeCost h + recurseTimeCost h + localTimeCost h) a = ?hz.h₁.b case hz.h₁.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ?hz.h₁.b = ?hz.b case hz.h₁.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ℕ case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ?hz.b ≤ x * 0 + x case hz.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ℕ
case hz.h₁.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ subroutineTimeCost h a + localTimeCost h a + recurseTimeCost h a = ?hz.b case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ?hz.b ≤ x * 0 + x case hz.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ℕ
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Nat.add_comm
case hz.h₁.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ subroutineTimeCost h a + localTimeCost h a + recurseTimeCost h a = ?hz.b case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ?hz.b ≤ x * 0 + x case hz.b TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ ℕ
case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ recurseTimeCost h a + (subroutineTimeCost h a + localTimeCost h a) ≤ x * 0 + x
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply add_le_add _
case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ recurseTimeCost h a + (subroutineTimeCost h a + localTimeCost h a) ≤ x * 0 + x
case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ subroutineTimeCost h a + localTimeCost h a ≤ x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ recurseTimeCost h a ≤ x * 0
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply hsi
case hz.h₂ TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ subroutineTimeCost h a + localTimeCost h a ≤ x TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ recurseTimeCost h a ≤ x * 0
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ recurseTimeCost h a ≤ x * 0
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply le_of_eq_of_le _ (zero_le _)
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ recurseTimeCost h a ≤ x * 0
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ recurseTimeCost h a = 0
https://github.com/calcu16/lean_complexity.git
d267eb4f3952c654f130a119311692c1c1a7cd71
HMem/Trace/Master.lean
HMem.Program.simpleLoopCost
[170, 1]
[213, 74]
apply Trace.CostedProgram.recurseTimeCost_leaf (costed_sound h) _ hsz
TracedProgram : Sort ?u.75510 α : Type u_1 inst✝² : Complexity.Coding α Memory β : Type u_2 inst✝¹ : Complexity.Encoding β Memory f : α → β tp : TracedProgram sz : α → ℕ p : Program inst✝ : Trace.HasCostedProgram p h : sound p f sz x : ℕ hsi : subroutineTimeCost h + localTimeCost h ≤ fun x_1 => x hr : maxRecurse p = 1 a : α hsz : sz a = 0 ⊢ recurseTimeCost h a = 0
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
mul_of_mul_base_exp
[34, 1]
[40, 11]
match c with | 0 => simp only [exp] | z+1 => simp only [exp,Nat.add] rw [mul_of_mul_base_exp a b z] ac_rfl
a b c : ℕ ⊢ exp (a * b) c = exp a c * exp b c
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
mul_of_mul_base_exp
[34, 1]
[40, 11]
simp only [exp]
a b c : ℕ ⊢ exp (a * b) 0 = exp a 0 * exp b 0
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
mul_of_mul_base_exp
[34, 1]
[40, 11]
simp only [exp,Nat.add]
a b c z : ℕ ⊢ exp (a * b) (z + 1) = exp a (z + 1) * exp b (z + 1)
a b c z : ℕ ⊢ exp (a * b) z * (a * b) = exp a z * a * (exp b z * b)
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
mul_of_mul_base_exp
[34, 1]
[40, 11]
rw [mul_of_mul_base_exp a b z]
a b c z : ℕ ⊢ exp (a * b) z * (a * b) = exp a z * a * (exp b z * b)
a b c z : ℕ ⊢ exp a z * exp b z * (a * b) = exp a z * a * (exp b z * b)
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
mul_of_mul_base_exp
[34, 1]
[40, 11]
ac_rfl
a b c z : ℕ ⊢ exp a z * exp b z * (a * b) = exp a z * a * (exp b z * b)
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
zero_times
[117, 1]
[122, 21]
match n with | 0 => simp | n'+1 => simp [times] exact zero_times
α : Type n : ℕ ⊢ times 0 n = 0
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
zero_times
[117, 1]
[122, 21]
simp
α : Type n : ℕ ⊢ times 0 0 = 0
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
zero_times
[117, 1]
[122, 21]
simp [times]
α : Type n n' : ℕ ⊢ times 0 (n' + 1) = 0
α : Type n n' : ℕ ⊢ times 0 n' = 0
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
zero_times
[117, 1]
[122, 21]
exact zero_times
α : Type n n' : ℕ ⊢ times 0 n' = 0
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
succ_times
[125, 1]
[132, 11]
match m with | 0 => simp [times] | m'+1 => simp [times] rw [@succ_times n m'] ac_rfl
α : Type n m : ℕ ⊢ times (n + 1) m = times n m + m
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
succ_times
[125, 1]
[132, 11]
simp [times]
α : Type n m : ℕ ⊢ times (n + 1) 0 = times n 0 + 0
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
succ_times
[125, 1]
[132, 11]
simp [times]
α : Type n m m' : ℕ ⊢ times (n + 1) (m' + 1) = times n (m' + 1) + (m' + 1)
α : Type n m m' : ℕ ⊢ times (n + 1) m' + (n + 1) = times n m' + n + (m' + 1)
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
succ_times
[125, 1]
[132, 11]
rw [@succ_times n m']
α : Type n m m' : ℕ ⊢ times (n + 1) m' + (n + 1) = times n m' + n + (m' + 1)
α : Type n m m' : ℕ ⊢ times n m' + m' + (n + 1) = times n m' + n + (m' + 1)
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
succ_times
[125, 1]
[132, 11]
ac_rfl
α : Type n m m' : ℕ ⊢ times n m' + m' + (n + 1) = times n m' + n + (m' + 1)
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
times_comm
[134, 1]
[142, 25]
match n,m with | n, 0 => simp [times] | n, m'+1 => simp [times] rw [times_comm n m']
α : Type n m : ℕ ⊢ times n m = times m n
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
times_comm
[134, 1]
[142, 25]
simp [times]
α : Type n✝ m n : ℕ ⊢ times n 0 = times 0 n
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
times_comm
[134, 1]
[142, 25]
simp [times]
α : Type n✝ m n m' : ℕ ⊢ times n (m' + 1) = times (m' + 1) n
α : Type n✝ m n m' : ℕ ⊢ times n m' + n = times m' n + n
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/Induction.lean
times_comm
[134, 1]
[142, 25]
rw [times_comm n m']
α : Type n✝ m n m' : ℕ ⊢ times n m' + n = times m' n + n
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.sorted_tail_of_sorted
[50, 1]
[54, 30]
match h with | single => apply nil | longer _ h'' => exact h''
α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α h : Sorted r (a :: as) ⊢ Sorted r as
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.sorted_tail_of_sorted
[50, 1]
[54, 30]
apply nil
α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α h : Sorted r (a :: as) ⊢ Sorted r []
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.sorted_tail_of_sorted
[50, 1]
[54, 30]
exact h''
α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α h : Sorted r (a :: as) a₂✝ : α as✝ : List α h✝ : r a a₂✝ h'' : Sorted r (a₂✝ :: as✝) ⊢ Sorted r (a₂✝ :: as✝)
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.len_insert_eq_succ_len
[79, 1]
[85, 54]
simp [insert]
α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α ⊢ List.length (insert r a []) = List.length [] + 1
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.len_insert_eq_succ_len
[79, 1]
[85, 54]
simp [insert, h]
α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α a' : α as : List α h : r a a' ⊢ List.length (insert r a (a' :: as)) = List.length (a' :: as) + 1
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.len_insert_eq_succ_len
[79, 1]
[85, 54]
simp [insert, h]
α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α a' : α as : List α h : ¬r a a' ⊢ List.length (insert r a (a' :: as)) = List.length (a' :: as) + 1
α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α a' : α as : List α h : ¬r a a' ⊢ List.length (insert r a as) = List.length as + 1
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.len_insert_eq_succ_len
[79, 1]
[85, 54]
apply len_insert_eq_succ_len
α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α a' : α as : List α h : ¬r a a' ⊢ List.length (insert r a as) = List.length as + 1
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.ordered_cons_insert_of_unordered
[134, 1]
[142, 55]
simp [insert]
α : Type r : α → α → Prop inst✝ : DecidableRel r a a' : α as : List α h' : r a' a h : Sorted r [a'] ⊢ r a' (insert r a [])[0]
α : Type r : α → α → Prop inst✝ : DecidableRel r a a' : α as : List α h' : r a' a h : Sorted r [a'] ⊢ r a' a
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.ordered_cons_insert_of_unordered
[134, 1]
[142, 55]
assumption
α : Type r : α → α → Prop inst✝ : DecidableRel r a a' : α as : List α h' : r a' a h : Sorted r [a'] ⊢ r a' a
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.ordered_cons_insert_of_unordered
[134, 1]
[142, 55]
simpa [insert, h'']
α : Type r : α → α → Prop inst✝ : DecidableRel r a a' : α as : List α h' : r a' a a'' : α as' : List α h : Sorted r (a' :: a'' :: as') h'' : r a a'' ⊢ r a' (insert r a (a'' :: as'))[0]
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.ordered_cons_insert_of_unordered
[134, 1]
[142, 55]
simp [insert, h'']
α : Type r : α → α → Prop inst✝ : DecidableRel r a a' : α as : List α h' : r a' a a'' : α as' : List α h : Sorted r (a' :: a'' :: as') h'' : ¬r a a'' ⊢ r a' (insert r a (a'' :: as'))[0]
α : Type r : α → α → Prop inst✝ : DecidableRel r a a' : α as : List α h' : r a' a a'' : α as' : List α h : Sorted r (a' :: a'' :: as') h'' : ¬r a a'' ⊢ r a' a''
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.ordered_cons_insert_of_unordered
[134, 1]
[142, 55]
apply ordered_of_sorted r h
α : Type r : α → α → Prop inst✝ : DecidableRel r a a' : α as : List α h' : r a' a a'' : α as' : List α h : Sorted r (a' :: a'' :: as') h'' : ¬r a a'' ⊢ r a' a''
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.insert_sorted_of_sorted
[146, 1]
[159, 39]
simp [insert, h']
α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : r a a' ⊢ Sorted r (insert r a (a' :: as))
α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : r a a' ⊢ Sorted r (a :: a' :: as)
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.insert_sorted_of_sorted
[146, 1]
[159, 39]
apply longer h' h
α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : r a a' ⊢ Sorted r (a :: a' :: as)
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.insert_sorted_of_sorted
[146, 1]
[159, 39]
simp [insert, h']
α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ Sorted r (insert r a (a' :: as))
α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ Sorted r (a' :: insert r a as)
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.insert_sorted_of_sorted
[146, 1]
[159, 39]
apply cons r
α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ Sorted r (a' :: insert r a as)
case h₁ α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ Sorted r (insert r a as) case h₃ α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ r a' (insert r a as)[0] case h₂ α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ List.length (insert r a as) > 0
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.insert_sorted_of_sorted
[146, 1]
[159, 39]
apply insert_sorted_of_sorted <| sorted_tail_of_sorted r a' as h
case h₁ α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ Sorted r (insert r a as)
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.insert_sorted_of_sorted
[146, 1]
[159, 39]
apply ordered_cons_insert_of_unordered r h
case h₃ α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ r a' (insert r a as)[0]
case h₃ α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ r a' a
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.insert_sorted_of_sorted
[146, 1]
[159, 39]
apply asym
case h₃ α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ r a' a
case h₃.a α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ ¬r a a'
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.insert_sorted_of_sorted
[146, 1]
[159, 39]
assumption
case h₃.a α : Type r : α → α → Prop inst✝¹ : DecidableRel r a : α l : List α inst✝ : Asymmetric r a' : α as : List α h : Sorted r (a' :: as) h' : ¬r a a' ⊢ ¬r a a'
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.sorted_of_insertSort
[163, 1]
[169, 63]
dsimp [insertSort]
α : Type r : α → α → Prop inst✝¹ : DecidableRel r l : List α inst✝ : Asymmetric r a : α as : List α ⊢ Sorted r (insertSort r (a :: as))
α : Type r : α → α → Prop inst✝¹ : DecidableRel r l : List α inst✝ : Asymmetric r a : α as : List α ⊢ Sorted r (insert r a (insertSort r as))
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.sorted_of_insertSort
[163, 1]
[169, 63]
apply insert_sorted_of_sorted r <| sorted_of_insertSort as
α : Type r : α → α → Prop inst✝¹ : DecidableRel r l : List α inst✝ : Asymmetric r a : α as : List α ⊢ Sorted r (insert r a (insertSort r as))
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.totally_ordered_of_sorted
[180, 1]
[216, 42]
rw [List.length_nil] at h'
α : Type r : α → α → Prop inst✝² : DecidableRel r inst✝¹ : Trans r r r inst✝ : Transitive r l : List α h : Sorted r l i✝ j✝ : ℕ x✝¹ : i✝ < j✝ h' : i✝ < List.length [] x✝ : j✝ < List.length [] ⊢ False
α : Type r : α → α → Prop inst✝² : DecidableRel r inst✝¹ : Trans r r r inst✝ : Transitive r l : List α h : Sorted r l i✝ j✝ : ℕ x✝¹ : i✝ < j✝ h' : i✝ < 0 x✝ : j✝ < List.length [] ⊢ False
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.totally_ordered_of_sorted
[180, 1]
[216, 42]
exact Nat.not_lt_zero _ h'
α : Type r : α → α → Prop inst✝² : DecidableRel r inst✝¹ : Trans r r r inst✝ : Transitive r l : List α h : Sorted r l i✝ j✝ : ℕ x✝¹ : i✝ < j✝ h' : i✝ < 0 x✝ : j✝ < List.length [] ⊢ False
no goals
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.totally_ordered_of_sorted
[180, 1]
[216, 42]
dsimp at hi hj
α : Type r : α → α → Prop inst✝² : DecidableRel r inst✝¹ : Trans r r r inst✝ : Transitive r l : List α h✝ : Sorted r l i✝ j✝ : ℕ a✝ : α h : i✝ < j✝ hi : i✝ < List.length [a✝] hj : j✝ < List.length [a✝] ⊢ r [a✝][i✝] [a✝][j✝]
α : Type r : α → α → Prop inst✝² : DecidableRel r inst✝¹ : Trans r r r inst✝ : Transitive r l : List α h✝ : Sorted r l i✝ j✝ : ℕ a✝ : α h : i✝ < j✝ hi : i✝ < 1 hj : j✝ < 1 ⊢ r [a✝][i✝] [a✝][j✝]
https://github.com/UofSC-Spring-2023-SCHC-411-H01/notes.git
72bc9ee3a0c93523fec747000cb89a6983f00afb
Notes4/IndPred2.lean
Notes.totally_ordered_of_sorted
[180, 1]
[216, 42]
apply False.elim
α : Type r : α → α → Prop inst✝² : DecidableRel r inst✝¹ : Trans r r r inst✝ : Transitive r l : List α h✝ : Sorted r l i✝ j✝ : ℕ a✝ : α h : i✝ < j✝ hi : i✝ < 1 hj : j✝ < 1 ⊢ r [a✝][i✝] [a✝][j✝]
case h α : Type r : α → α → Prop inst✝² : DecidableRel r inst✝¹ : Trans r r r inst✝ : Transitive r l : List α h✝ : Sorted r l i✝ j✝ : ℕ a✝ : α h : i✝ < j✝ hi : i✝ < 1 hj : j✝ < 1 ⊢ False