Theory HOL-Library.Time_Functions

(*
  File:    Library/Time_Functions.thy
  Author:  Manuel Eberl, Tobias Nipkow, TU München
*)

section ‹Time functions for various standard library operations›

theory Time_Functions
  imports Time_Commands
begin

time_fun fst
time_fun snd

lemma T_fst_0[simp]: "T_fst x = 0"
  by (metis T_fst.elims)

lemma T_snd_0[simp]: "T_snd x = 0"
  by (metis T_snd.elims)

time_fun the


subsection ‹List›

time_fun hd

lemma T_hd[simp]: "xs ≠ [] ⟹ T_hd xs = 0"
by (cases xs) simp_all

time_fun tl

lemma T_tl: "T_tl xs = 0"
by (cases xs) simp_all

declare T_tl.simps[simp del]

time_fun "(@)"

lemma T_append[simp]: "T_append xs ys = length xs + 1"
by(induction xs) auto

class T_size =
  fixes T_size :: "'a ⇒ nat"

instantiation list :: (_) T_size
begin

time_fun length

instance ..

end

abbreviation T_length :: "'a list ⇒ nat" where
"T_length ≡ T_size"

lemma T_length: "T_length xs = length xs + 1"
  by (induction xs) auto

lemmas [simp del] = T_size_list.simps

time_fun map

lemma T_map_simps [simp,code]:
  "T_map T_f [] = 1"
  "T_map T_f (x # xs) = T_f x + T_map T_f xs + 1"
by (simp_all add: T_map_def)

lemma T_map: "T_map T_f xs = (∑x←xs. T_f x) + length xs + 1"
  by (induction xs) auto

lemmas [simp del] = T_map_simps

lemma T_map_bound:
  "∀x ∈ set xs. T_P x ≤ k ⟹ T_map T_P xs ≤ k * length xs + length xs + 1"
using sum_list_bound[of "map T_P xs"] by(simp add: T_map)

time_fun filter

lemma T_filter_simps [code]:
  "T_filter T_P [] = 1"
  "T_filter T_P (x # xs) = T_P x + T_filter T_P xs + 1"
by (simp_all add: T_filter_def)

lemma T_filter: "T_filter T_P xs = (∑x←xs. T_P x) + length xs + 1"
by (induction xs) (auto simp: T_filter_simps)

lemma T_filter_eq_T_map: "T_filter T_f xs = T_map T_f xs"
by (simp add: T_filter T_map)

lemma T_filter_bound:
  "∀x ∈ set xs. T_P x ≤ k ⟹ T_filter T_P xs ≤ k * length xs + length xs + 1"
by (metis T_filter_eq_T_map T_map_bound)

time_fun nth

lemma T_nth: "n < length xs ⟹ T_nth xs n = n + 1"
  by (induction xs n rule: T_nth.induct) (auto split: nat.splits)

lemmas [simp del] = T_nth.simps

time_fun take
time_fun drop

lemma T_take: "T_take n xs = min n (length xs) + 1"
  by (induction xs arbitrary: n) (auto split: nat.splits)

lemma T_drop: "T_drop n xs = min n (length xs) + 1"
  by (induction xs arbitrary: n) (auto split: nat.splits)

time_fun zip

lemma T_zip: "length xs = length ys ⟹ T_zip xs ys = length ys + 1"
  by (induction xs ys rule: list_induct2) auto

time_fun rev

lemma T_rev: "T_rev xs ≤ (length xs + 1)^2"
by(induction xs) (auto simp: T_append power2_eq_square)

fun itrev :: "'a list ⇒ 'a list ⇒ 'a list" where
"itrev [] ys = ys" |
"itrev (x#xs) ys = itrev xs (x # ys)"

lemma itrev: "itrev xs ys = rev xs @ ys"
by(induction xs arbitrary: ys) auto

lemma itrev_Nil: "itrev xs [] = rev xs"
by(simp add: itrev)

time_fun itrev

lemma T_itrev: "T_itrev xs ys = length xs + 1"
by(induction xs arbitrary: ys) auto

time_fun list_update

lemma T_list_update[simp]: "i < length xs ⟹ T_list_update xs i x = i + 1"
by(induction xs arbitrary: i) (auto split: nat.splits)

time_fun last

lemma T_last[simp]: "as ≠ [] ⟹ T_last as = length as"
  by (induction as) auto

end