Prefixes, suffixes, infixes

This file proves properties about

• List.isPrefix: l₁ is a prefix of l₂ if l₂ starts with l₁.
• List.isSuffix: l₁ is a suffix of l₂ if l₂ ends with l₁.
• List.isInfix: l₁ is an infix of l₂ if l₁ is a prefix of some suffix of l₂.
• List.inits: The list of prefixes of a list.
• List.tails: The list of prefixes of a list.
• insert on lists

All those (except insert) are defined in Mathlib.Data.List.Defs.

Notation

• l₁ <+: l₂: l₁ is a prefix of l₂.
• l₁ <:+ l₂: l₁ is a suffix of l₂.
• l₁ <:+: l₂: l₁ is an infix of l₂.

prefix, suffix, infix

@[deprecated List.IsSuffix.reverse]

theorem List.isSuffix.reverse {α✝ : Type u_1} {l₁ l₂ : List α✝} : l₁ <:+ l₂ → l₁.reverse <+: l₂.reverse

Alias of List.IsSuffix.reverse.

@[deprecated List.IsPrefix.reverse]

theorem List.isPrefix.reverse {α✝ : Type u_1} {l₁ l₂ : List α✝} : l₁ <+: l₂ → l₁.reverse <:+ l₂.reverse

Alias of List.IsPrefix.reverse.

@[deprecated List.IsInfix.reverse]

theorem List.isInfix.reverse {α✝ : Type u_1} {l₁ l₂ : List α✝} : l₁ <:+: l₂ → l₁.reverse <:+: l₂.reverse

Alias of List.IsInfix.reverse.

@[deprecated List.IsInfix.eq_of_length]

theorem List.eq_of_infix_of_length_eq {α : Type u_1} {l₁ l₂ : List α} (h : l₁ <:+: l₂) : l₁.length = l₂.length → l₁ = l₂

@[deprecated List.IsPrefix.eq_of_length]

theorem List.eq_of_prefix_of_length_eq {α : Type u_1} {l₁ l₂ : List α} (h : l₁ <+: l₂) : l₁.length = l₂.length → l₁ = l₂

@[deprecated List.IsSuffix.eq_of_length]

theorem List.eq_of_suffix_of_length_eq {α : Type u_1} {l₁ l₂ : List α} (h : l₁ <:+ l₂) : l₁.length = l₂.length → l₁ = l₂

theorem List.IsPrefix.take {α : Type u_1} {l₁ l₂ : List α} (h : l₁ <+: l₂) (n : ℕ) : List.take n l₁ <+: List.take n l₂

theorem List.IsPrefix.drop {α : Type u_1} {l₁ l₂ : List α} (h : l₁ <+: l₂) (n : ℕ) : List.drop n l₁ <+: List.drop n l₂

theorem List.isPrefix_append_of_length {α : Type u_1} {l₁ l₂ l₃ : List α} (h : l₁.length ≤ l₂.length) : l₁ <+: l₂ ++ l₃ ↔ l₁ <+: l₂

@[simp]

theorem List.take_isPrefix_take {α : Type u_1} {l : List α} {m n : ℕ} : List.take m l <+: List.take n l ↔ m ≤ n ∨ l.length ≤ n

theorem List.dropSlice_sublist {α : Type u_1} (n m : ℕ) (l : List α) : (List.dropSlice n m l).Sublist l

theorem List.dropSlice_subset {α : Type u_1} (n m : ℕ) (l : List α) : List.dropSlice n m l ⊆ l

theorem List.mem_of_mem_dropSlice {α : Type u_1} {n m : ℕ} {l : List α} {a : α} (h : a ∈ List.dropSlice n m l) : a ∈ l

theorem List.tail_subset {α : Type u_1} (l : List α) : l.tail ⊆ l

theorem List.mem_of_mem_dropLast {α : Type u_1} {l : List α} {a : α} (h : a ∈ l.dropLast) : a ∈ l

theorem List.concat_get_prefix {α : Type u_1} {x y : List α} (h : x <+: y) (hl : x.length < y.length) : x ++ [y.get ⟨x.length, hl⟩] <+: y

instance List.decidableInfix {α : Type u_1} [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <:+: l₂)

Equations

• [].decidableInfix x = isTrue ⋯
• (a :: l₁).decidableInfix [] = isFalse ⋯
• x.decidableInfix (b :: l₂) = decidable_of_decidable_of_iff ⋯

@[deprecated List.cons_prefix_cons]

theorem List.cons_prefix_iff {α : Type u_1} {l₁ l₂ : List α} {a b : α} : a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂

@[deprecated List.IsPrefix.filterMap]

theorem List.IsPrefix.filter_map {α : Type u_1} {β : Type u_2} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) : List.filterMap f l₁ <+: List.filterMap f l₂

Alias of List.IsPrefix.filterMap.

theorem List.IsPrefix.reduceOption {α : Type u_1} {l₁ l₂ : List (Option α)} (h : l₁ <+: l₂) : l₁.reduceOption <+: l₂.reduceOption

theorem List.instIsPartialOrderIsPrefix {α : Type u_1} : IsPartialOrder (List α) fun (x1 x2 : List α) => x1 <+: x2

theorem List.instIsPartialOrderIsSuffix {α : Type u_1} : IsPartialOrder (List α) fun (x1 x2 : List α) => x1 <:+ x2

theorem List.instIsPartialOrderIsInfix {α : Type u_1} : IsPartialOrder (List α) fun (x1 x2 : List α) => x1 <:+: x2

@[simp]

theorem List.mem_inits {α : Type u_1} (s t : List α) : s ∈ t.inits ↔ s <+: t

@[simp]

theorem List.mem_tails {α : Type u_1} (s t : List α) : s ∈ t.tails ↔ s <:+ t

theorem List.inits_cons {α : Type u_1} (a : α) (l : List α) : (a :: l).inits = [] :: List.map (fun (t : List α) => a :: t) l.inits

theorem List.tails_cons {α : Type u_1} (a : α) (l : List α) : (a :: l).tails = (a :: l) :: l.tails

@[simp]

theorem List.inits_append {α : Type u_1} (s t : List α) : (s ++ t).inits = s.inits ++ List.map (fun (l : List α) => s ++ l) t.inits.tail

@[simp]

theorem List.tails_append {α : Type u_1} (s t : List α) : (s ++ t).tails = List.map (fun (l : List α) => l ++ t) s.tails ++ t.tails.tail

theorem List.inits_eq_tails {α : Type u_1} (l : List α) : l.inits = (List.map List.reverse l.reverse.tails).reverse

theorem List.tails_eq_inits {α : Type u_1} (l : List α) : l.tails = (List.map List.reverse l.reverse.inits).reverse

theorem List.inits_reverse {α : Type u_1} (l : List α) : l.reverse.inits = (List.map List.reverse l.tails).reverse

theorem List.tails_reverse {α : Type u_1} (l : List α) : l.reverse.tails = (List.map List.reverse l.inits).reverse

theorem List.map_reverse_inits {α : Type u_1} (l : List α) : List.map List.reverse l.inits = l.reverse.tails.reverse

theorem List.map_reverse_tails {α : Type u_1} (l : List α) : List.map List.reverse l.tails = l.reverse.inits.reverse

@[simp]

theorem List.length_tails {α : Type u_1} (l : List α) : l.tails.length = l.length + 1

@[simp]

theorem List.length_inits {α : Type u_1} (l : List α) : l.inits.length = l.length + 1

@[simp]

theorem List.getElem_tails {α : Type u_1} (l : List α) (n : ℕ) (h : n < l.tails.length) : l.tails[n] = List.drop n l

theorem List.get_tails {α : Type u_1} (l : List α) (n : Fin l.tails.length) : l.tails.get n = List.drop (↑n) l

@[simp]

theorem List.getElem_inits {α : Type u_1} (l : List α) (n : ℕ) (h : n < l.inits.length) : l.inits[n] = List.take n l

theorem List.get_inits {α : Type u_1} (l : List α) (n : Fin l.inits.length) : l.inits.get n = List.take (↑n) l

theorem List.map_inits {α : Type u_1} {l : List α} {β : Type u_2} (g : α → β) : (List.map g l).inits = List.map (List.map g) l.inits

theorem List.map_tails {α : Type u_1} {l : List α} {β : Type u_2} (g : α → β) : (List.map g l).tails = List.map (List.map g) l.tails

theorem List.take_inits {α : Type u_1} {l : List α} {n : ℕ} : (List.take n l).inits = List.take (n + 1) l.inits

insert

theorem List.insert_eq_ite {α : Type u_1} [DecidableEq α] (a : α) (l : List α) : insert a l = if a ∈ l then l else a :: l

@[simp]

theorem List.suffix_insert {α : Type u_1} [DecidableEq α] (a : α) (l : List α) : l <:+ List.insert a l

theorem List.infix_insert {α : Type u_1} [DecidableEq α] (a : α) (l : List α) : l <:+: List.insert a l

theorem List.sublist_insert {α : Type u_1} [DecidableEq α] (a : α) (l : List α) : l.Sublist (List.insert a l)

theorem List.subset_insert {α : Type u_1} [DecidableEq α] (a : α) (l : List α) : l ⊆ List.insert a l

@[deprecated List.IsSuffix.mem]

theorem List.mem_of_mem_suffix {α✝ : Type u_1} {l₁ : List α✝} {a : α✝} {l₂ : List α✝} (hx : a ∈ l₁) (hl : l₁ <:+ l₂) : a ∈ l₂

Alias of List.IsSuffix.mem.

@[deprecated List.IsPrefix.getElem]

theorem List.IsPrefix.get_eq {α : Type u_1} {x y : List α} (h : x <+: y) {n : ℕ} (hn : n < x.length) : x.get ⟨n, hn⟩ = y.get ⟨n, ⋯⟩

@[deprecated List.IsPrefix.head]

theorem List.IsPrefix.head_eq {α : Type u_1} {x y : List α} (h : x <+: y) (hx : x ≠ []) : x.head hx = y.head ⋯

Alias of List.IsPrefix.head.