Datasets:

akjadhav
/

leandojo-lean4-formal-informal-strings-split

Dataset card Data Studio Files Files and versions Community

Split (3)

train · 47.4k rows

formal stringlengths 41 427k	informal stringclasses 1 value
List.get?_set_eq_of_lt α : Type u_1 a : α n : Nat l : List α h : n < length l ⊢ get? (set l n a) n = some a rw [get?_set_eq, get?_eq_get h] α : Type u_1 a : α n : Nat l : List α h : n < length l ⊢ (fun x => a) <$> some (get l { val := n, isLt := h }) = some a rfl ** Qed
List.get?_set α : Type u_1 a : α m n : Nat l : List α ⊢ get? (set l m a) n = if m = n then (fun x => a) <$> get? l n else get? l n by_cases m = n <;> simp [, get?_set_eq, get?_set_ne] * Qed
List.get?_set_of_lt α : Type u_1 a : α m n : Nat l : List α h : n < length l ⊢ get? (set l m a) n = if m = n then some a else get? l n simp [get?_set, get?_eq_get h] ** Qed
List.get?_set_of_lt' α : Type u_1 a : α m n : Nat l : List α h : m < length l ⊢ get? (set l m a) n = if m = n then some a else get? l n simp [get?_set] α : Type u_1 a : α m n : Nat l : List α h : m < length l ⊢ (if m = n then Option.map (fun x => a) (get? l n) else get? l n) = if m = n then some a else get? l n split <;> subst_vars <;> simp [, get?_eq_get h] * Qed
List.set_comm α : Type u_1 a b : α x✝² x✝¹ : Nat x✝ : x✝² ≠ x✝¹ ⊢ set (set [] x✝² a) x✝¹ b = set (set [] x✝¹ b) x✝² a simp α : Type u_1 a b : α n : Nat head✝ : α tail✝ : List α x✝ : n + 1 ≠ 0 ⊢ set (set (head✝ :: tail✝) (n + 1) a) 0 b = set (set (head✝ :: tail✝) 0 b) (n + 1) a simp [set] α : Type u_1 a b : α m : Nat head✝ : α tail✝ : List α x✝ : 0 ≠ m + 1 ⊢ set (set (head✝ :: tail✝) 0 a) (m + 1) b = set (set (head✝ :: tail✝) (m + 1) b) 0 a simp [set] ** Qed
List.set_set α : Type u_1 a b : α x✝ : Nat ⊢ set (set [] x✝ a) x✝ b = set [] x✝ b simp α : Type u_1 a b head✝ : α tail✝ : List α ⊢ set (set (head✝ :: tail✝) 0 a) 0 b = set (head✝ :: tail✝) 0 b simp [set] α : Type u_1 a b head✝ : α tail✝ : List α n✝ : Nat ⊢ set (set (head✝ :: tail✝) (n✝ + 1) a) (n✝ + 1) b = set (head✝ :: tail✝) (n✝ + 1) b simp [set, set_set] ** Qed
List.get_set_eq α : Type u_1 l : List α i : Nat a : α h : i < length (set l i a) ⊢ get (set l i a) { val := i, isLt := h } = a rw [← Option.some_inj, ← get?_eq_get, get?_set_eq, get?_eq_get] <;> simp_all ** Qed
List.get_set_ne α : Type ?u.125696 l : List α i j : Nat h : i ≠ j a : α hj : j < length (set l i a) ⊢ j < length l simp at hj α : Type ?u.125696 l : List α i j : Nat h : i ≠ j a : α hj : j < length l ⊢ j < length l exact hj α : Type u_1 l : List α i j : Nat h : i ≠ j a : α hj : j < length (set l i a) ⊢ get (set l i a) { val := j, isLt := hj } = get l { val := j, isLt := (_ : j < length l) } rw [← Option.some_inj, ← get?_eq_get, get?_set_ne _ _ h, get?_eq_get] ** Qed
List.length_removeNth α : Type u_1 head✝ : α tail✝ : List α x✝ : 0 < length (head✝ :: tail✝) ⊢ length (removeNth (head✝ :: tail✝) 0) = length (head✝ :: tail✝) - 1 simp [removeNth] α : Type u_1 x : α xs : List α i : Nat h : i + 1 < length (x :: xs) ⊢ length (removeNth (x :: xs) (i + 1)) = length (x :: xs) - 1 have : i < length xs := Nat.lt_of_succ_lt_succ h α : Type u_1 x : α xs : List α i : Nat h : i + 1 < length (x :: xs) this : i < length xs ⊢ length (removeNth (x :: xs) (i + 1)) = length (x :: xs) - 1 simp [removeNth, ← Nat.add_one] α : Type u_1 x : α xs : List α i : Nat h : i + 1 < length (x :: xs) this : i < length xs ⊢ length (removeNth xs i) + 1 = length xs rw [length_removeNth this, Nat.sub_add_cancel (Nat.lt_of_le_of_lt (Nat.zero_le _) this)] ** Qed
List.length_tail α : Type u_1 l : List α ⊢ length (tail l) = length l - 1 cases l <;> rfl ** Qed
List.all_eq_true α : Type u_1 p : α → Bool l : List α ⊢ all l p = true ↔ ∀ (x : α), x ∈ l → p x = true induction l <;> simp [] * Qed
List.any_eq_true α : Type u_1 p : α → Bool l : List α ⊢ any l p = true ↔ ∃ x, x ∈ l ∧ p x = true induction l <;> simp [] * Qed
List.contains_cons α : Type u_1 a : α as : List α x : α inst✝ : BEq α ⊢ contains (a :: as) x = (x == a \|\| contains as x) simp only [contains, elem] α : Type u_1 a : α as : List α x : α inst✝ : BEq α ⊢ (match x == a with \| true => true \| false => elem x as) = (x == a \|\| elem x as) split <;> simp_all ** Qed
List.contains_eq_any_beq α : Type u_1 inst✝ : BEq α l : List α a : α ⊢ contains l a = any l fun x => a == x induction l with simp \| cons b l => cases a == b <;> simp [] * case cons α : Type u_1 inst✝ : BEq α a b : α l : List α tail_ih✝ : contains l a = any l fun x => a == x ⊢ (a == b \|\| contains l a) = (a == b \|\| any l fun x => a == x) ** cases a == b <;> simp [] * Qed
List.mem_reverseAux α : Type u_1 x a : α tail✝ x✝ : List α ⊢ x ∈ reverseAux (a :: tail✝) x✝ ↔ x ∈ a :: tail✝ ∨ x ∈ x✝ rw [reverseAux, mem_cons, or_assoc, or_left_comm, mem_reverseAux, mem_cons] ** Qed
List.mem_reverse α : Type u_1 x : α as : List α ⊢ x ∈ reverse as ↔ x ∈ as simp [reverse] ** Qed
List.insert_of_mem α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l ⊢ List.insert a l = l simp only [List.insert, if_pos h] ** Qed
List.insert_of_not_mem α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : ¬a ∈ l ⊢ List.insert a l = a :: l simp only [List.insert, if_neg h] ** Qed
List.mem_insert_iff α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l if h : b ∈ l then rw [insert_of_mem h] constructor; {apply Or.inr} intro \| Or.inl h' => rw [h']; exact h \| Or.inr h' => exact h' else rw [insert_of_not_mem h, mem_cons] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l rw [insert_of_mem h] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a ∈ l ↔ a = b ∨ a ∈ l constructor case mp α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a ∈ l → a = b ∨ a ∈ l case mpr α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a = b ∨ a ∈ l → a ∈ l {apply Or.inr} case mpr α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a = b ∨ a ∈ l → a ∈ l intro \| Or.inl h' => rw [h']; exact h \| Or.inr h' => exact h' α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l x✝ : a = b ∨ a ∈ l h' : a = b ⊢ a ∈ l rw [h'] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l x✝ : a = b ∨ a ∈ l h' : a = b ⊢ b ∈ l exact h α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l x✝ : a = b ∨ a ∈ l h' : a ∈ l ⊢ a ∈ l exact h' α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : ¬b ∈ l ⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l rw [insert_of_not_mem h, mem_cons] ** Qed
List.length_insert_of_mem α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l ⊢ length (List.insert a l) = length l rw [insert_of_mem h] ** Qed
List.length_insert_of_not_mem α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : ¬a ∈ l ⊢ length (List.insert a l) = length l + 1 rw [insert_of_not_mem h] α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : ¬a ∈ l ⊢ length (a :: l) = length l + 1 rfl ** Qed
List.eraseP_cons_of_pos α : Type u_1 a : α l : List α p : α → Bool h : p a = true ⊢ eraseP p (a :: l) = l simp [eraseP_cons, h] ** Qed
List.eraseP_cons_of_neg α : Type u_1 a : α l : List α p : α → Bool h : ¬p a = true ⊢ eraseP p (a :: l) = a :: eraseP p l simp [eraseP_cons, h] ** Qed
List.eraseP_of_forall_not α : Type u_1 p : α → Bool l : List α h : ∀ (a : α), a ∈ l → ¬p a = true ⊢ eraseP p l = l induction l with \| nil => rfl \| cons _ _ ih => simp [h _ (.head ..), ih (forall_mem_cons.1 h).2] case nil α : Type u_1 p : α → Bool h : ∀ (a : α), a ∈ [] → ¬p a = true ⊢ eraseP p [] = [] rfl case cons α : Type u_1 p : α → Bool head✝ : α tail✝ : List α ih : (∀ (a : α), a ∈ tail✝ → ¬p a = true) → eraseP p tail✝ = tail✝ h : ∀ (a : α), a ∈ head✝ :: tail✝ → ¬p a = true ⊢ eraseP p (head✝ :: tail✝) = head✝ :: tail✝ simp [h _ (.head ..), ih (forall_mem_cons.1 h).2] ** Qed
List.exists_of_eraseP α : Type u_1 p : α → Bool b : α l : List α a : α al : a ∈ b :: l pa : p a = true pb : p b = true ⊢ b :: l = [] ++ b :: l ∧ eraseP p (b :: l) = [] ++ l simp [pb] α : Type u_1 p : α → Bool b✝ : α l : List α a : α al✝ : a ∈ b✝ :: l pa : p a = true b : α al : Mem a l pb : ¬p b = true c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ b :: l = b :: l₁ ++ c :: l₂ rw [h₃, cons_append] α : Type u_1 p : α → Bool b✝ : α l : List α a : α al✝ : a ∈ b✝ :: l pa : p a = true b : α al : Mem a l pb : ¬p b = true c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ eraseP p (b :: l) = b :: l₁ ++ l₂ simp [pb, h₄] ** Qed
List.length_eraseP_of_mem α✝ : Type u_1 a : α✝ l : List α✝ p : α✝ → Bool al : a ∈ l pa : p a = true ⊢ length (eraseP p l) = pred (length l) let ⟨_, l₁, l₂, _, _, e₁, e₂⟩ := exists_of_eraseP al pa α✝ : Type u_1 a : α✝ l : List α✝ p : α✝ → Bool al : a ∈ l pa : p a = true w✝ : α✝ l₁ l₂ : List α✝ left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true left✝ : p w✝ = true e₁ : l = l₁ ++ w✝ :: l₂ e₂ : eraseP p l = l₁ ++ l₂ ⊢ length (eraseP p l) = pred (length l) rw [e₂] α✝ : Type u_1 a : α✝ l : List α✝ p : α✝ → Bool al : a ∈ l pa : p a = true w✝ : α✝ l₁ l₂ : List α✝ left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true left✝ : p w✝ = true e₁ : l = l₁ ++ w✝ :: l₂ e₂ : eraseP p l = l₁ ++ l₂ ⊢ length (l₁ ++ l₂) = pred (length l) simp [length_append, e₁] α✝ : Type u_1 a : α✝ l : List α✝ p : α✝ → Bool al : a ∈ l pa : p a = true w✝ : α✝ l₁ l₂ : List α✝ left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true left✝ : p w✝ = true e₁ : l = l₁ ++ w✝ :: l₂ e₂ : eraseP p l = l₁ ++ l₂ ⊢ length l₁ + length l₂ = pred (length l₁ + succ (length l₂)) rfl ** Qed
List.eraseP_append_left α : Type u_1 p : α → Bool a : α pa : p a = true x : α xs l₂ : List α h : a ∈ x :: xs ⊢ eraseP p (x :: xs ++ l₂) = eraseP p (x :: xs) ++ l₂ by_cases h' : p x <;> simp [h'] case neg α : Type u_1 p : α → Bool a : α pa : p a = true x : α xs l₂ : List α h : a ∈ x :: xs h' : ¬p x = true ⊢ eraseP p (xs ++ l₂) = eraseP p xs ++ l₂ rw [eraseP_append_left pa l₂ ((mem_cons.1 h).resolve_left (mt _ h'))] α : Type u_1 p : α → Bool a : α pa : p a = true x : α xs l₂ : List α h : a ∈ x :: xs h' : ¬p x = true ⊢ a = x → p x = true intro \| rfl => exact pa α : Type u_1 p : α → Bool a : α pa : p a = true x : α xs l₂ : List α x✝ : a = x h : a ∈ a :: xs h' : ¬p a = true ⊢ p a = true exact pa ** Qed
List.eraseP_append_right α : Type u_1 p : α → Bool x : α xs l₂ : List α h : ∀ (b : α), b ∈ x :: xs → ¬p b = true ⊢ eraseP p (x :: xs ++ l₂) = x :: xs ++ eraseP p l₂ simp [(forall_mem_cons.1 h).1, eraseP_append_right _ (forall_mem_cons.1 h).2] ** Qed
List.eraseP_sublist α : Type u_1 p : α → Bool l : List α ⊢ eraseP p l <+ l match exists_or_eq_self_of_eraseP p l with \| .inl h => rw [h]; apply Sublist.refl \| .inr ⟨c, l₁, l₂, _, _, h₃, h₄⟩ => rw [h₄, h₃]; simp α : Type u_1 p : α → Bool l : List α h : eraseP p l = l ⊢ eraseP p l <+ l rw [h] α : Type u_1 p : α → Bool l : List α h : eraseP p l = l ⊢ l <+ l apply Sublist.refl α : Type u_1 p : α → Bool l : List α c : α l₁ l₂ : List α left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true left✝ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ eraseP p l <+ l rw [h₄, h₃] α : Type u_1 p : α → Bool l : List α c : α l₁ l₂ : List α left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true left✝ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ l₁ ++ l₂ <+ l₁ ++ c :: l₂ simp ** Qed
List.Sublist.eraseP α✝ : Type u_1 l₁✝ l₂ : List α✝ p : α✝ → Bool l₁ l₂✝ : List α✝ a : α✝ s : l₁ <+ l₂✝ ⊢ List.eraseP p l₁ <+ List.eraseP p (a :: l₂✝) by_cases h : p a <;> simp [h] case pos α✝ : Type u_1 l₁✝ l₂ : List α✝ p : α✝ → Bool l₁ l₂✝ : List α✝ a : α✝ s : l₁ <+ l₂✝ h : p a = true ⊢ List.eraseP p l₁ <+ l₂✝ case neg α✝ : Type u_1 l₁✝ l₂ : List α✝ p : α✝ → Bool l₁ l₂✝ : List α✝ a : α✝ s : l₁ <+ l₂✝ h : ¬p a = true ⊢ List.eraseP p l₁ <+ a :: List.eraseP p l₂✝ exacts [s.eraseP.trans (eraseP_sublist _), s.eraseP.cons _] α✝ : Type u_1 l₁ l₂ : List α✝ p : α✝ → Bool l₁✝ l₂✝ : List α✝ a : α✝ s : l₁✝ <+ l₂✝ ⊢ List.eraseP p (a :: l₁✝) <+ List.eraseP p (a :: l₂✝) by_cases h : p a <;> simp [h] case pos α✝ : Type u_1 l₁ l₂ : List α✝ p : α✝ → Bool l₁✝ l₂✝ : List α✝ a : α✝ s : l₁✝ <+ l₂✝ h : p a = true ⊢ l₁✝ <+ l₂✝ case neg α✝ : Type u_1 l₁ l₂ : List α✝ p : α✝ → Bool l₁✝ l₂✝ : List α✝ a : α✝ s : l₁✝ <+ l₂✝ h : ¬p a = true ⊢ a :: List.eraseP p l₁✝ <+ a :: List.eraseP p l₂✝ exacts [s, s.eraseP.cons₂ _] ** Qed
List.mem_eraseP_of_neg α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true ⊢ a ∈ eraseP p l ↔ a ∈ l refine ⟨mem_of_mem_eraseP, fun al => ?_⟩ α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l ⊢ a ∈ eraseP p l match exists_or_eq_self_of_eraseP p l with \| .inl h => rw [h]; assumption \| .inr ⟨c, l₁, l₂, h₁, h₂, h₃, h₄⟩ => rw [h₄]; rw [h₃] at al have : a ≠ c := fun h => (h ▸ pa).elim h₂ simp [this] at al; simp [al] α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l h : eraseP p l = l ⊢ a ∈ eraseP p l rw [h] α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l h : eraseP p l = l ⊢ a ∈ l assumption α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ a ∈ eraseP p l rw [h₄] α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ a ∈ l₁ ++ l₂ rw [h₃] at al α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true c : α l₁ l₂ : List α al : a ∈ l₁ ++ c :: l₂ h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ a ∈ l₁ ++ l₂ have : a ≠ c := fun h => (h ▸ pa).elim h₂ α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true c : α l₁ l₂ : List α al : a ∈ l₁ ++ c :: l₂ h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ this : a ≠ c ⊢ a ∈ l₁ ++ l₂ simp [this] at al α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ this : a ≠ c al : a ∈ l₁ ∨ a ∈ l₂ ⊢ a ∈ l₁ ++ l₂ simp [al] ** Qed
List.erase_cons_head α : Type u_1 inst✝ : DecidableEq α a : α l : List α ⊢ List.erase (a :: l) a = l simp [erase_cons] ** Qed
List.erase_cons_tail α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ≠ a ⊢ List.erase (b :: l) a = b :: List.erase l a simp only [erase_cons, if_neg h] ** Qed
List.erase_eq_eraseP α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l) if h : a = b then simp [h] else simp [h, Ne.symm h, erase_eq_eraseP a l] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : a = b ⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l) simp [h] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : ¬a = b ⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l) simp [h, Ne.symm h, erase_eq_eraseP a l] ** Qed
List.erase_of_not_mem α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : ¬a ∈ b :: l ⊢ List.erase (b :: l) a = b :: l rw [mem_cons, not_or] at h α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : ¬a = b ∧ ¬a ∈ l ⊢ List.erase (b :: l) a = b :: l rw [erase_cons, if_neg (Ne.symm h.1), erase_of_not_mem h.2] ** Qed
List.exists_erase_eq α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l ⊢ ∃ l₁ l₂, ¬a ∈ l₁ ∧ l = l₁ ++ a :: l₂ ∧ List.erase l a = l₁ ++ l₂ let ⟨_, l₁, l₂, h₁, e, h₂, h₃⟩ := exists_of_eraseP h (beq_self_eq_true _) α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l w✝ : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬(a == b) = true e : (a == w✝) = true h₂ : l = l₁ ++ w✝ :: l₂ h₃ : eraseP (BEq.beq a) l = l₁ ++ l₂ ⊢ ∃ l₁ l₂, ¬a ∈ l₁ ∧ l = l₁ ++ a :: l₂ ∧ List.erase l a = l₁ ++ l₂ rw [erase_eq_eraseP] α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l w✝ : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬(a == b) = true e : (a == w✝) = true h₂ : l = l₁ ++ w✝ :: l₂ h₃ : eraseP (BEq.beq a) l = l₁ ++ l₂ ⊢ ∃ l₁ l₂, ¬a ∈ l₁ ∧ l = l₁ ++ a :: l₂ ∧ eraseP (fun b => decide (a = b)) l = l₁ ++ l₂ exact ⟨l₁, l₂, fun h => h₁ _ h (beq_self_eq_true _), eq_of_beq e ▸ h₂, h₃⟩ ** Qed
List.sublist.erase α : Type u_1 inst✝ : DecidableEq α a : α l₁ l₂ : List α h : l₁ <+ l₂ ⊢ List.erase l₁ a <+ List.erase l₂ a simp only [erase_eq_eraseP] α : Type u_1 inst✝ : DecidableEq α a : α l₁ l₂ : List α h : l₁ <+ l₂ ⊢ eraseP (fun b => decide (a = b)) l₁ <+ eraseP (fun b => decide (a = b)) l₂ exact h.eraseP ** Qed
List.erase_comm α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a if ab : a = b then rw [ab] else ?_ α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a if ha : a ∈ l then ?_ else simp only [erase_of_not_mem ha, erase_of_not_mem (mt mem_of_mem_erase ha)] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ha : a ∈ l ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a if hb : b ∈ l then ?_ else simp only [erase_of_not_mem hb, erase_of_not_mem (mt mem_of_mem_erase hb)] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ha : a ∈ l hb : b ∈ l ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a match l, l.erase a, exists_erase_eq ha with \| _, _, ⟨l₁, l₂, ha', rfl, rfl⟩ => if h₁ : b ∈ l₁ then rw [erase_append_left _ h₁, erase_append_left _ h₁, erase_append_right _ (mt mem_of_mem_erase ha'), erase_cons_head] else rw [erase_append_right _ h₁, erase_append_right _ h₁, erase_append_right _ ha', erase_cons_tail _ ab, erase_cons_head] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : a = b ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a rw [ab] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ha : ¬a ∈ l ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a simp only [erase_of_not_mem ha, erase_of_not_mem (mt mem_of_mem_erase ha)] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ha : a ∈ l hb : ¬b ∈ l ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a simp only [erase_of_not_mem hb, erase_of_not_mem (mt mem_of_mem_erase hb)] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b l₁ l₂ : List α ha' : ¬a ∈ l₁ ha : a ∈ l₁ ++ a :: l₂ hb : b ∈ l₁ ++ a :: l₂ ⊢ List.erase (l₁ ++ l₂) b = List.erase (List.erase (l₁ ++ a :: l₂) b) a if h₁ : b ∈ l₁ then rw [erase_append_left _ h₁, erase_append_left _ h₁, erase_append_right _ (mt mem_of_mem_erase ha'), erase_cons_head] else rw [erase_append_right _ h₁, erase_append_right _ h₁, erase_append_right _ ha', erase_cons_tail _ ab, erase_cons_head] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b l₁ l₂ : List α ha' : ¬a ∈ l₁ ha : a ∈ l₁ ++ a :: l₂ hb : b ∈ l₁ ++ a :: l₂ h₁ : b ∈ l₁ ⊢ List.erase (l₁ ++ l₂) b = List.erase (List.erase (l₁ ++ a :: l₂) b) a rw [erase_append_left _ h₁, erase_append_left _ h₁, erase_append_right _ (mt mem_of_mem_erase ha'), erase_cons_head] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b l₁ l₂ : List α ha' : ¬a ∈ l₁ ha : a ∈ l₁ ++ a :: l₂ hb : b ∈ l₁ ++ a :: l₂ h₁ : ¬b ∈ l₁ ⊢ List.erase (l₁ ++ l₂) b = List.erase (List.erase (l₁ ++ a :: l₂) b) a rw [erase_append_right _ h₁, erase_append_right _ h₁, erase_append_right _ ha', erase_cons_tail _ ab, erase_cons_head] ** Qed
List.filter_cons_of_pos α : Type u_1 p : α → Bool a : α l : List α pa : p a = true ⊢ filter p (a :: l) = a :: filter p l rw [filter, pa] ** Qed
List.filter_cons_of_neg α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true ⊢ filter p (a :: l) = filter p l rw [filter, eq_false_of_ne_true pa] ** Qed
List.filter_append α : Type u_1 p : α → Bool a : α l₁ l₂ : List α ⊢ filter p (a :: l₁ ++ l₂) = filter p (a :: l₁) ++ filter p l₂ simp [filter] α : Type u_1 p : α → Bool a : α l₁ l₂ : List α ⊢ (match p a with \| true => a :: filter p (l₁ ++ l₂) \| false => filter p (l₁ ++ l₂)) = (match p a with \| true => a :: filter p l₁ \| false => filter p l₁) ++ filter p l₂ split <;> simp [filter_append l₁] ** Qed
List.filter_sublist α : Type u_1 p : α → Bool a : α l : List α ⊢ filter p (a :: l) <+ a :: l rw [filter] α : Type u_1 p : α → Bool a : α l : List α ⊢ (match p a with \| true => a :: filter p l \| false => filter p l) <+ a :: l split <;> simp [Sublist.cons, Sublist.cons₂, filter_sublist l] ** Qed
List.mem_filter case nil α✝ : Type u_1 x : α✝ p : α✝ → Bool ⊢ x ∈ filter p [] ↔ x ∈ [] ∧ p x = true simp [filter] case cons α✝ : Type u_1 x : α✝ p : α✝ → Bool a : α✝ as : List α✝ ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true ⊢ x ∈ filter p (a :: as) ↔ x ∈ a :: as ∧ p x = true by_cases h : p a <;> simp [, or_and_right] * case pos α✝ : Type u_1 x : α✝ p : α✝ → Bool a : α✝ as : List α✝ ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true h : p a = true ⊢ x = a ∨ x ∈ as ∧ p x = true ↔ x = a ∧ p x = true ∨ x ∈ as ∧ p x = true exact or_congr_left (and_iff_left_of_imp fun \| rfl => h).symm case neg α✝ : Type u_1 x : α✝ p : α✝ → Bool a : α✝ as : List α✝ ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true h : ¬p a = true ⊢ x ∈ as ∧ p x = true ↔ x = a ∧ p x = true ∨ x ∈ as ∧ p x = true exact (or_iff_right fun ⟨rfl, h'⟩ => h h').symm Qed
List.partition_eq_filter_filter α : Type u_1 p : α → Bool l : List α ⊢ partition p l = (filter p l, filter (not ∘ p) l) simp [partition, aux] α : Type u_1 p : α → Bool l as✝ bs✝ : List α ⊢ partition.loop p [] (as✝, bs✝) = (reverse as✝ ++ filter p [], reverse bs✝ ++ filter (not ∘ p) []) simp [partition.loop, filter] α : Type u_1 p : α → Bool l✝ as✝ bs✝ : List α a : α l : List α ⊢ partition.loop p (a :: l) (as✝, bs✝) = (reverse as✝ ++ filter p (a :: l), reverse bs✝ ++ filter (not ∘ p) (a :: l)) cases pa : p a <;> simp [partition.loop, pa, aux, filter, append_assoc] ** Qed
List.filter_congr' α : Type u_1 p q : α → Bool a : α l : List α h : ∀ (x : α), x ∈ a :: l → (p x = true ↔ q x = true) ⊢ filter p (a :: l) = filter q (a :: l) rw [forall_mem_cons] at h α : Type u_1 p q : α → Bool a : α l : List α h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true) ⊢ filter p (a :: l) = filter q (a :: l) by_cases pa : p a case pos α : Type u_1 p q : α → Bool a : α l : List α h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true) pa : p a = true ⊢ filter p (a :: l) = filter q (a :: l) simp [pa, h.1.1 pa, filter_congr' h.2] case neg α : Type u_1 p q : α → Bool a : α l : List α h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true) pa : ¬p a = true ⊢ filter p (a :: l) = filter q (a :: l) simp [pa, mt h.1.2 pa, filter_congr' h.2] ** Qed
List.filterMap_cons_none α : Type u_1 β : Type u_2 f : α → Option β a : α l : List α h : f a = none ⊢ filterMap f (a :: l) = filterMap f l simp only [filterMap, h] ** Qed
List.filterMap_cons_some α : Type u_1 β : Type u_2 f : α → Option β a : α l : List α b : β h : f a = some b ⊢ filterMap f (a :: l) = b :: filterMap f l simp only [filterMap, h] ** Qed
List.filterMap_append α : Type u_1 β : Type u_2 l l' : List α f : α → Option β ⊢ filterMap f (l ++ l') = filterMap f l ++ filterMap f l' induction l <;> simp case cons α : Type u_1 β : Type u_2 l' : List α f : α → Option β head✝ : α tail✝ : List α tail_ih✝ : filterMap f (tail✝ ++ l') = filterMap f tail✝ ++ filterMap f l' ⊢ (match f head✝ with \| none => filterMap f (tail✝ ++ l') \| some b => b :: filterMap f (tail✝ ++ l')) = (match f head✝ with \| none => filterMap f tail✝ \| some b => b :: filterMap f tail✝) ++ filterMap f l' split <;> simp [] * Qed
List.filterMap_eq_map α : Type u_1 β : Type u_2 f : α → β ⊢ filterMap (some ∘ f) = map f funext l case h α : Type u_1 β : Type u_2 f : α → β l : List α ⊢ filterMap (some ∘ f) l = map f l induction l <;> simp [] * Qed
List.filterMap_eq_filter α : Type u_1 p : α → Bool ⊢ filterMap (Option.guard fun x => p x = true) = filter p funext l case h α : Type u_1 p : α → Bool l : List α ⊢ filterMap (Option.guard fun x => p x = true) l = filter p l induction l with \| nil => rfl \| cons a l IH => by_cases pa : p a <;> simp [Option.guard, pa, ← IH] case h.nil α : Type u_1 p : α → Bool ⊢ filterMap (Option.guard fun x => p x = true) [] = filter p [] rfl case h.cons α : Type u_1 p : α → Bool a : α l : List α IH : filterMap (Option.guard fun x => p x = true) l = filter p l ⊢ filterMap (Option.guard fun x => p x = true) (a :: l) = filter p (a :: l) by_cases pa : p a <;> simp [Option.guard, pa, ← IH] ** Qed
List.filterMap_filterMap α : Type u_1 β : Type u_2 γ : Type u_3 f : α → Option β g : β → Option γ l : List α ⊢ filterMap g (filterMap f l) = filterMap (fun x => Option.bind (f x) g) l induction l with \| nil => rfl \| cons a l IH => cases h : f a <;> simp [] * case nil α : Type u_1 β : Type u_2 γ : Type u_3 f : α → Option β g : β → Option γ ⊢ filterMap g (filterMap f []) = filterMap (fun x => Option.bind (f x) g) [] rfl case cons α : Type u_1 β : Type u_2 γ : Type u_3 f : α → Option β g : β → Option γ a : α l : List α IH : filterMap g (filterMap f l) = filterMap (fun x => Option.bind (f x) g) l ⊢ filterMap g (filterMap f (a :: l)) = filterMap (fun x => Option.bind (f x) g) (a :: l) ** cases h : f a <;> simp [] * Qed
List.map_filterMap α : Type u_1 β : Type u_2 γ : Type u_3 f : α → Option β g : β → γ l : List α ⊢ map g (filterMap f l) = filterMap (fun x => Option.map g (f x)) l simp only [← filterMap_eq_map, filterMap_filterMap, Option.map_eq_bind] ** Qed
List.filterMap_map α : Type u_1 β : Type u_2 γ : Type u_3 f : α → β g : β → Option γ l : List α ⊢ filterMap g (map f l) = filterMap (g ∘ f) l rw [← filterMap_eq_map, filterMap_filterMap] α : Type u_1 β : Type u_2 γ : Type u_3 f : α → β g : β → Option γ l : List α ⊢ filterMap (fun x => Option.bind ((some ∘ f) x) g) l = filterMap (g ∘ f) l rfl ** Qed
List.filter_filterMap α : Type u_1 β : Type u_2 f : α → Option β p : β → Bool l : List α ⊢ filter p (filterMap f l) = filterMap (fun x => Option.filter p (f x)) l rw [← filterMap_eq_filter, filterMap_filterMap] α : Type u_1 β : Type u_2 f : α → Option β p : β → Bool l : List α ⊢ filterMap (fun x => Option.bind (f x) (Option.guard fun x => p x = true)) l = filterMap (fun x => Option.filter p (f x)) l congr case e_f α : Type u_1 β : Type u_2 f : α → Option β p : β → Bool l : List α ⊢ (fun x => Option.bind (f x) (Option.guard fun x => p x = true)) = fun x => Option.filter p (f x) funext x case e_f.h α : Type u_1 β : Type u_2 f : α → Option β p : β → Bool l : List α x : α ⊢ Option.bind (f x) (Option.guard fun x => p x = true) = Option.filter p (f x) cases f x <;> simp [Option.filter, Option.guard] ** Qed
List.filterMap_filter α : Type u_1 β : Type u_2 p : α → Bool f : α → Option β l : List α ⊢ filterMap f (filter p l) = filterMap (fun x => if p x = true then f x else none) l rw [← filterMap_eq_filter, filterMap_filterMap] α : Type u_1 β : Type u_2 p : α → Bool f : α → Option β l : List α ⊢ filterMap (fun x => Option.bind (Option.guard (fun x => p x = true) x) f) l = filterMap (fun x => if p x = true then f x else none) l congr case e_f α : Type u_1 β : Type u_2 p : α → Bool f : α → Option β l : List α ⊢ (fun x => Option.bind (Option.guard (fun x => p x = true) x) f) = fun x => if p x = true then f x else none funext x case e_f.h α : Type u_1 β : Type u_2 p : α → Bool f : α → Option β l : List α x : α ⊢ Option.bind (Option.guard (fun x => p x = true) x) f = if p x = true then f x else none by_cases h : p x <;> simp [Option.guard, h] ** Qed
List.filterMap_some α : Type u_1 l : List α ⊢ filterMap some l = l erw [filterMap_eq_map, map_id] ** Qed
List.map_filterMap_some_eq_filter_map_is_some α : Type u_1 β : Type u_2 f : α → Option β l : List α ⊢ map some (filterMap f l) = filter (fun b => Option.isSome b) (map f l) induction l <;> simp case cons α : Type u_1 β : Type u_2 f : α → Option β head✝ : α tail✝ : List α tail_ih✝ : map some (filterMap f tail✝) = filter (fun b => Option.isSome b) (map f tail✝) ⊢ map some (match f head✝ with \| none => filterMap f tail✝ \| some b => b :: filterMap f tail✝) = filter (fun b => Option.isSome b) (f head✝ :: map f tail✝) split <;> simp [] * Qed
List.mem_filterMap α : Type u_1 β : Type u_2 f : α → Option β l : List α b : β ⊢ b ∈ filterMap f l ↔ ∃ a, a ∈ l ∧ f a = some b induction l <;> simp case cons α : Type u_1 β : Type u_2 f : α → Option β b : β head✝ : α tail✝ : List α tail_ih✝ : b ∈ filterMap f tail✝ ↔ ∃ a, a ∈ tail✝ ∧ f a = some b ⊢ (b ∈ match f head✝ with \| none => filterMap f tail✝ \| some b => b :: filterMap f tail✝) ↔ f head✝ = some b ∨ ∃ a, a ∈ tail✝ ∧ f a = some b split <;> simp [, eq_comm] * Qed
List.filterMap_join α : Type u_1 β : Type u_2 f : α → Option β L : List (List α) ⊢ filterMap f (join L) = join (map (filterMap f) L) induction L <;> simp [, filterMap_append] * Qed
List.map_filterMap_of_inv α : Type u_1 β : Type u_2 f : α → Option β g : β → α H : ∀ (x : α), Option.map g (f x) = some x l : List α ⊢ map g (filterMap f l) = l simp only [map_filterMap, H, filterMap_some] ** Qed
List.Sublist.filterMap α : Type u_1 β : Type u_2 l₁ l₂ : List α f : α → Option β s : l₁ <+ l₂ ⊢ List.filterMap f l₁ <+ List.filterMap f l₂ induction s <;> simp <;> split <;> simp [, cons, cons₂] * Qed
List.Sublist.filter α : Type u_1 p : α → Bool l₁ l₂ : List α s : l₁ <+ l₂ ⊢ List.filter p l₁ <+ List.filter p l₂ rw [← filterMap_eq_filter] α : Type u_1 p : α → Bool l₁ l₂ : List α s : l₁ <+ l₂ ⊢ List.filterMap (Option.guard fun x => p x = true) l₁ <+ List.filterMap (Option.guard fun x => p x = true) l₂ apply s.filterMap ** Qed
List.map_filter β : Type u_1 α : Type u_2 p : α → Bool f : β → α l : List β ⊢ filter p (map f l) = map f (filter (p ∘ f) l) rw [← filterMap_eq_map, filter_filterMap, filterMap_filter] β : Type u_1 α : Type u_2 p : α → Bool f : β → α l : List β ⊢ filterMap (fun x => Option.filter p ((some ∘ f) x)) l = filterMap (fun x => if (p ∘ f) x = true then (some ∘ f) x else none) l rfl ** Qed
List.filter_filter α✝ : Type u_1 p q : α✝ → Bool a : α✝ l : List α✝ ⊢ filter p (filter q (a :: l)) = filter (fun a => decide (p a = true ∧ q a = true)) (a :: l) by_cases hp : p a <;> by_cases hq : q a <;> simp [hp, hq, filter_filter _ l] ** Qed
List.filter_eq_nil α✝ : Type u_1 p : α✝ → Bool l : List α✝ ⊢ filter p l = [] ↔ ∀ (a : α✝), a ∈ l → ¬p a = true simp only [eq_nil_iff_forall_not_mem, mem_filter, not_and] ** Qed
List.filter_eq_self α✝ : Type u_1 p : α✝ → Bool l : List α✝ ⊢ filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true induction l with simp \| cons a l ih => cases h : p a <;> simp [] intro h; exact Nat.lt_irrefl _ (h ▸ length_filter_le p l) * case cons α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true ⊢ filter p (a :: l) = a :: l ↔ p a = true ∧ ∀ (a : α✝), a ∈ l → p a = true ** cases h : p a <;> simp [] * case cons.false α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true h : p a = false ⊢ ¬filter p l = a :: l intro h case cons.false α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true h✝ : p a = false h : filter p l = a :: l ⊢ False exact Nat.lt_irrefl _ (h ▸ length_filter_le p l) Qed
List.find?_cons_of_pos α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ h : p a = true ⊢ find? p (a :: l) = some a simp [find?, h] ** Qed
List.find?_cons_of_neg α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ h : ¬p a = true ⊢ find? p (a :: l) = find? p l simp [find?, h] ** Qed
List.find?_eq_none α✝ : Type u_1 p : α✝ → Bool l : List α✝ ⊢ find? p l = none ↔ ∀ (x : α✝), x ∈ l → ¬p x = true induction l <;> simp [find?_cons] case cons α✝ : Type u_1 p : α✝ → Bool head✝ : α✝ tail✝ : List α✝ tail_ih✝ : find? p tail✝ = none ↔ ∀ (x : α✝), x ∈ tail✝ → ¬p x = true ⊢ (match p head✝ with \| true => some head✝ \| false => find? p tail✝) = none ↔ p head✝ = false ∧ ∀ (a : α✝), a ∈ tail✝ → p a = false split <;> simp [] * Qed
List.find?_some α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ H : find? p (b :: l) = some a ⊢ p a = true by_cases h : p b <;> simp [find?, h] at H case pos α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ h : p b = true H : b = a ⊢ p a = true exact H ▸ h case neg α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ h : ¬p b = true H : find? p l = some a ⊢ p a = true exact find?_some H ** Qed
List.mem_of_find?_eq_some α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ H : find? p (b :: l) = some a ⊢ a ∈ b :: l by_cases h : p b <;> simp [find?, h] at H case pos α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ h : p b = true H : b = a ⊢ a ∈ b :: l exact H ▸ .head _ case neg α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ h : ¬p b = true H : find? p l = some a ⊢ a ∈ b :: l exact .tail _ (mem_of_find?_eq_some H) ** Qed
List.findIdx_cons α : Type u_1 p : α → Bool b : α l : List α ⊢ findIdx p (b :: l) = bif p b then 0 else findIdx p l + 1 cases H : p b with \| true => simp [H, findIdx, findIdx.go] \| false => simp [H, findIdx, findIdx.go, findIdx_go_succ] case true α : Type u_1 p : α → Bool b : α l : List α H : p b = true ⊢ findIdx p (b :: l) = bif true then 0 else findIdx p l + 1 simp [H, findIdx, findIdx.go] case false α : Type u_1 p : α → Bool b : α l : List α H : p b = false ⊢ findIdx p (b :: l) = bif false then 0 else findIdx p l + 1 simp [H, findIdx, findIdx.go, findIdx_go_succ] α : Type u_1 p✝ : α → Bool b : α l✝ : List α p : α → Bool l : List α n : Nat ⊢ findIdx.go p l (n + 1) = findIdx.go p l n + 1 cases l with \| nil => unfold findIdx.go; exact Nat.succ_eq_add_one n \| cons head tail => unfold findIdx.go cases p head <;> simp only [cond_false, cond_true] exact findIdx_go_succ p tail (n + 1) case nil α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat ⊢ findIdx.go p [] (n + 1) = findIdx.go p [] n + 1 unfold findIdx.go case nil α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat ⊢ n + 1 = n + 1 exact Nat.succ_eq_add_one n case cons α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat head : α tail : List α ⊢ findIdx.go p (head :: tail) (n + 1) = findIdx.go p (head :: tail) n + 1 unfold findIdx.go case cons α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat head : α tail : List α ⊢ (bif p head then n + 1 else findIdx.go p tail (n + 1 + 1)) = (bif p head then n else findIdx.go p tail (n + 1)) + 1 cases p head <;> simp only [cond_false, cond_true] case cons.false α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat head : α tail : List α ⊢ findIdx.go p tail (n + 1 + 1) = findIdx.go p tail (n + 1) + 1 exact findIdx_go_succ p tail (n + 1) ** Qed
List.findIdx_of_get?_eq_some α : Type u_1 p : α → Bool y : α xs : List α w : get? xs (findIdx p xs) = some y ⊢ p y = true induction xs with \| nil => simp_all \| cons x xs ih => by_cases h : p x <;> simp_all [findIdx_cons] case nil α : Type u_1 p : α → Bool y : α w : get? [] (findIdx p []) = some y ⊢ p y = true simp_all case cons α : Type u_1 p : α → Bool y x : α xs : List α ih : get? xs (findIdx p xs) = some y → p y = true w : get? (x :: xs) (findIdx p (x :: xs)) = some y ⊢ p y = true by_cases h : p x <;> simp_all [findIdx_cons] ** Qed
List.findIdx_lt_length_of_exists case nil α : Type u_1 p : α → Bool h : ∃ x, x ∈ [] ∧ p x = true ⊢ findIdx p [] < length [] simp_all case cons α : Type u_1 p : α → Bool x : α xs : List α ih : (∃ x, x ∈ xs ∧ p x = true) → findIdx p xs < length xs h : ∃ x_1, x_1 ∈ x :: xs ∧ p x_1 = true ⊢ findIdx p (x :: xs) < length (x :: xs) by_cases p x case pos α : Type u_1 p : α → Bool x : α xs : List α ih : (∃ x, x ∈ xs ∧ p x = true) → findIdx p xs < length xs h : ∃ x_1, x_1 ∈ x :: xs ∧ p x_1 = true h✝ : p x = true ⊢ findIdx p (x :: xs) < length (x :: xs) simp_all only [forall_exists_index, and_imp, mem_cons, exists_eq_or_imp, true_or, findIdx_cons, cond_true, length_cons] case pos α : Type u_1 p : α → Bool x : α xs : List α ih : ∀ (x : α), x ∈ xs → p x = true → findIdx p xs < length xs h✝ : p x = true ⊢ 0 < succ (length xs) apply Nat.succ_pos case neg α : Type u_1 p : α → Bool x : α xs : List α ih : (∃ x, x ∈ xs ∧ p x = true) → findIdx p xs < length xs h : ∃ x_1, x_1 ∈ x :: xs ∧ p x_1 = true h✝ : ¬p x = true ⊢ findIdx p (x :: xs) < length (x :: xs) simp_all [findIdx_cons] case neg α : Type u_1 p : α → Bool x : α xs : List α ih : ∀ (x : α), x ∈ xs → p x = true → findIdx p xs < length xs h : ∃ a, a ∈ xs ∧ p a = true h✝ : p x = false ⊢ findIdx p xs + 1 < succ (length xs) refine Nat.succ_lt_succ ?_ case neg α : Type u_1 p : α → Bool x : α xs : List α ih : ∀ (x : α), x ∈ xs → p x = true → findIdx p xs < length xs h : ∃ a, a ∈ xs ∧ p a = true h✝ : p x = false ⊢ findIdx p xs < length xs obtain ⟨x', m', h'⟩ := h case neg.intro.intro α : Type u_1 p : α → Bool x : α xs : List α ih : ∀ (x : α), x ∈ xs → p x = true → findIdx p xs < length xs h✝ : p x = false x' : α m' : x' ∈ xs h' : p x' = true ⊢ findIdx p xs < length xs exact ih x' m' h' ** Qed
List.pairwise_map α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop l : List α ⊢ Pairwise R (map f l) ↔ Pairwise (fun a b => R (f a) (f b)) l induction l case nil α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop ⊢ Pairwise R (map f []) ↔ Pairwise (fun a b => R (f a) (f b)) [] case cons α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop head✝ : α tail✝ : List α tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝ ⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝) . simp case cons α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop head✝ : α tail✝ : List α tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝ ⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝) . simp only [map, pairwise_cons, forall_mem_map_iff, ] * case nil α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop ⊢ Pairwise R (map f []) ↔ Pairwise (fun a b => R (f a) (f b)) [] simp case cons α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop head✝ : α tail✝ : List α tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝ ⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝) ** simp only [map, pairwise_cons, forall_mem_map_iff, ] * Qed
List.pairwise_append α : Type u_1 R : α → α → Prop l₁ l₂ : List α ⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₁ → ∀ (b : α), b ∈ l₂ → R a b induction l₁ <;> simp [, or_imp, forall_and, and_assoc, and_left_comm] * Qed
List.pairwise_reverse α : Type u_1 R : α → α → Prop l : List α ⊢ Pairwise R (reverse l) ↔ Pairwise (fun a b => R b a) l induction l <;> simp [, pairwise_append, and_comm] * Qed
List.replaceF_cons_of_some α : Type u_1 a' a : α l : List α p : α → Option α h : p a = some a' ⊢ replaceF p (a :: l) = a' :: l simp [replaceF_cons, h] ** Qed
List.replaceF_cons_of_none α : Type u_1 a : α l : List α p : α → Option α h : p a = none ⊢ replaceF p (a :: l) = a :: replaceF p l simp [replaceF_cons, h] ** Qed
List.replaceF_of_forall_none α : Type u_1 p : α → Option α l : List α h : ∀ (a : α), a ∈ l → p a = none ⊢ replaceF p l = l induction l with \| nil => rfl \| cons _ _ ih => simp [h _ (.head ..), ih (forall_mem_cons.1 h).2] case nil α : Type u_1 p : α → Option α h : ∀ (a : α), a ∈ [] → p a = none ⊢ replaceF p [] = [] rfl case cons α : Type u_1 p : α → Option α head✝ : α tail✝ : List α ih : (∀ (a : α), a ∈ tail✝ → p a = none) → replaceF p tail✝ = tail✝ h : ∀ (a : α), a ∈ head✝ :: tail✝ → p a = none ⊢ replaceF p (head✝ :: tail✝) = head✝ :: tail✝ simp [h _ (.head ..), ih (forall_mem_cons.1 h).2] ** Qed
List.exists_of_replaceF α : Type u_1 p : α → Option α b : α l : List α a a' : α al : a ∈ b :: l pa : p a = some a' b' : α pb : p b = some b' ⊢ b :: l = [] ++ b :: l ∧ replaceF p (b :: l) = [] ++ b' :: l simp [pb] α : Type u_1 p : α → Option α b✝ : α l : List α a a' : α al✝ : a ∈ b✝ :: l pa : p a = some a' b : α al : Mem a l pb : p b = none c c' : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → p b = none h₂ : p c = some c' h₃ : l = l₁ ++ c :: l₂ h₄ : replaceF p l = l₁ ++ c' :: l₂ ⊢ b :: l = b :: l₁ ++ c :: l₂ rw [h₃, cons_append] α : Type u_1 p : α → Option α b✝ : α l : List α a a' : α al✝ : a ∈ b✝ :: l pa : p a = some a' b : α al : Mem a l pb : p b = none c c' : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → p b = none h₂ : p c = some c' h₃ : l = l₁ ++ c :: l₂ h₄ : replaceF p l = l₁ ++ c' :: l₂ ⊢ replaceF p (b :: l) = b :: l₁ ++ c' :: l₂ simp [pb, h₄] ** Qed
List.length_replaceF α✝ : Type u_1 f : α✝ → Option α✝ l : List α✝ ⊢ length (replaceF f l) = length l induction l <;> simp [replaceF] case cons α✝ : Type u_1 f : α✝ → Option α✝ head✝ : α✝ tail✝ : List α✝ tail_ih✝ : length (replaceF f tail✝) = length tail✝ ⊢ length (match f head✝ with \| none => head✝ :: replaceF f tail✝ \| some a => a :: tail✝) = succ (length tail✝) split <;> simp [] * Qed
List.disjoint_left α✝ : Type u_1 l₁ l₂ : List α✝ ⊢ Disjoint l₁ l₂ ↔ ∀ ⦃a : α✝⦄, a ∈ l₁ → ¬a ∈ l₂ simp [Disjoint] ** Qed
List.disjoint_nil_right α : Type u_1 l : List α ⊢ Disjoint l [] rw [disjoint_comm] α : Type u_1 l : List α ⊢ Disjoint [] l exact disjoint_nil_left _ ** Qed
List.singleton_disjoint α✝ : Type u_1 a : α✝ l : List α✝ ⊢ Disjoint [a] l ↔ ¬a ∈ l simp [Disjoint] ** Qed
List.disjoint_singleton α✝ : Type u_1 l : List α✝ a : α✝ ⊢ Disjoint l [a] ↔ ¬a ∈ l rw [disjoint_comm, singleton_disjoint] ** Qed
List.disjoint_append_left α✝ : Type u_1 l₁ l₂ l : List α✝ ⊢ Disjoint (l₁ ++ l₂) l ↔ Disjoint l₁ l ∧ Disjoint l₂ l simp [Disjoint, or_imp, forall_and] ** Qed
List.disjoint_append_right α✝ : Type u_1 l l₁ l₂ : List α✝ ⊢ Disjoint (l₁ ++ l₂) l ↔ Disjoint l l₁ ∧ Disjoint l l₂ rw [disjoint_append_left] α✝ : Type u_1 l l₁ l₂ : List α✝ ⊢ Disjoint l₁ l ∧ Disjoint l₂ l ↔ Disjoint l l₁ ∧ Disjoint l l₂ simp [disjoint_comm] ** Qed
List.disjoint_cons_left α✝ : Type u_1 a : α✝ l₁ l₂ : List α✝ ⊢ Disjoint [a] l₂ ∧ Disjoint l₁ l₂ ↔ ¬a ∈ l₂ ∧ Disjoint l₁ l₂ simp [singleton_disjoint] ** Qed
List.disjoint_cons_right α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ ⊢ Disjoint (a :: l₂) l₁ ↔ ¬a ∈ l₁ ∧ Disjoint l₁ l₂ rw [disjoint_cons_left] α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ ⊢ ¬a ∈ l₁ ∧ Disjoint l₂ l₁ ↔ ¬a ∈ l₁ ∧ Disjoint l₁ l₂ simp [disjoint_comm] ** Qed
List.foldl_map β₁ : Type u_1 β₂ : Type u_2 α : Type u_3 f : β₁ → β₂ g : α → β₂ → α l : List β₁ init : α ⊢ foldl g init (map f l) = foldl (fun x y => g x (f y)) init l induction l generalizing init <;> simp [] * Qed
List.foldr_map α₁ : Type u_1 α₂ : Type u_2 β : Type u_3 f : α₁ → α₂ g : α₂ → β → β l : List α₁ init : β ⊢ foldr g init (map f l) = foldr (fun x y => g (f x) y) init l induction l generalizing init <;> simp [] * Qed
List.foldl_hom α₁ : Type u_1 α₂ : Type u_2 β : Type u_3 f : α₁ → α₂ g₁ : α₁ → β → α₁ g₂ : α₂ → β → α₂ l : List β init : α₁ H : ∀ (x : α₁) (y : β), g₂ (f x) y = f (g₁ x y) ⊢ foldl g₂ (f init) l = f (foldl g₁ init l) induction l generalizing init <;> simp [, H] * Qed
List.foldr_hom β₁ : Type u_1 β₂ : Type u_2 α : Type u_3 f : β₁ → β₂ g₁ : α → β₁ → β₁ g₂ : α → β₂ → β₂ l : List α init : β₁ H : ∀ (x : α) (y : β₁), g₂ x (f y) = f (g₁ x y) ⊢ foldr g₂ (f init) l = f (foldr g₁ init l) induction l <;> simp [, H] * Qed
List.nil_union α : Type u_1 inst✝ : DecidableEq α l : List α ⊢ [] ∪ l = l simp [List.union_def, foldr] ** Qed
List.cons_union α : Type u_1 inst✝ : DecidableEq α a : α l₁ l₂ : List α ⊢ a :: l₁ ∪ l₂ = List.insert a (l₁ ∪ l₂) simp [List.union_def, foldr] ** Qed
List.mem_union_iff α : Type u_1 inst✝¹ inst✝ : DecidableEq α x : α l₁ l₂ : List α ⊢ x ∈ l₁ ∪ l₂ ↔ x ∈ l₁ ∨ x ∈ l₂ induction l₁ <;> simp [, or_assoc] * Qed
List.pair_mem_product α : Type u_1 β : Type u_2 xs : List α ys : List β x : α y : β ⊢ (x, y) ∈ product xs ys ↔ x ∈ xs ∧ y ∈ ys simp only [product, and_imp, exists_prop, mem_map, Prod.mk.injEq, exists_eq_right_right, mem_bind, iff_self] ** Qed
List.leftpad_prefix α : Type u_1 n : Nat a : α l : List α ⊢ replicate (n - length l) a <+: leftpad n a l simp only [IsPrefix, leftpad] α : Type u_1 n : Nat a : α l : List α ⊢ ∃ t, replicate (n - length l) a ++ t = replicate (n - length l) a ++ l exact Exists.intro l rfl ** Qed
List.leftpad_suffix α : Type u_1 n : Nat a : α l : List α ⊢ l <:+ leftpad n a l simp only [IsSuffix, leftpad] α : Type u_1 n : Nat a : α l : List α ⊢ ∃ t, t ++ l = replicate (n - length l) a ++ l exact Exists.intro (replicate (n - length l) a) rfl ** Qed

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

formal stringlengths 41 427k	informal stringclasses 1 value
List.get?_set_eq_of_lt α : Type u_1 a : α n : Nat l : List α h : n < length l ⊢ get? (set l n a) n = some a rw [get?_set_eq, get?_eq_get h] α : Type u_1 a : α n : Nat l : List α h : n < length l ⊢ (fun x => a) <$> some (get l { val := n, isLt := h }) = some a rfl ** Qed
List.get?_set α : Type u_1 a : α m n : Nat l : List α ⊢ get? (set l m a) n = if m = n then (fun x => a) <$> get? l n else get? l n by_cases m = n <;> simp [, get?_set_eq, get?_set_ne] * Qed
List.get?_set_of_lt α : Type u_1 a : α m n : Nat l : List α h : n < length l ⊢ get? (set l m a) n = if m = n then some a else get? l n simp [get?_set, get?_eq_get h] ** Qed
List.get?_set_of_lt' α : Type u_1 a : α m n : Nat l : List α h : m < length l ⊢ get? (set l m a) n = if m = n then some a else get? l n simp [get?_set] α : Type u_1 a : α m n : Nat l : List α h : m < length l ⊢ (if m = n then Option.map (fun x => a) (get? l n) else get? l n) = if m = n then some a else get? l n split <;> subst_vars <;> simp [, get?_eq_get h] * Qed
List.set_comm α : Type u_1 a b : α x✝² x✝¹ : Nat x✝ : x✝² ≠ x✝¹ ⊢ set (set [] x✝² a) x✝¹ b = set (set [] x✝¹ b) x✝² a simp α : Type u_1 a b : α n : Nat head✝ : α tail✝ : List α x✝ : n + 1 ≠ 0 ⊢ set (set (head✝ :: tail✝) (n + 1) a) 0 b = set (set (head✝ :: tail✝) 0 b) (n + 1) a simp [set] α : Type u_1 a b : α m : Nat head✝ : α tail✝ : List α x✝ : 0 ≠ m + 1 ⊢ set (set (head✝ :: tail✝) 0 a) (m + 1) b = set (set (head✝ :: tail✝) (m + 1) b) 0 a simp [set] ** Qed
List.set_set α : Type u_1 a b : α x✝ : Nat ⊢ set (set [] x✝ a) x✝ b = set [] x✝ b simp α : Type u_1 a b head✝ : α tail✝ : List α ⊢ set (set (head✝ :: tail✝) 0 a) 0 b = set (head✝ :: tail✝) 0 b simp [set] α : Type u_1 a b head✝ : α tail✝ : List α n✝ : Nat ⊢ set (set (head✝ :: tail✝) (n✝ + 1) a) (n✝ + 1) b = set (head✝ :: tail✝) (n✝ + 1) b simp [set, set_set] ** Qed
List.get_set_eq α : Type u_1 l : List α i : Nat a : α h : i < length (set l i a) ⊢ get (set l i a) { val := i, isLt := h } = a rw [← Option.some_inj, ← get?_eq_get, get?_set_eq, get?_eq_get] <;> simp_all ** Qed
List.get_set_ne α : Type ?u.125696 l : List α i j : Nat h : i ≠ j a : α hj : j < length (set l i a) ⊢ j < length l simp at hj α : Type ?u.125696 l : List α i j : Nat h : i ≠ j a : α hj : j < length l ⊢ j < length l exact hj α : Type u_1 l : List α i j : Nat h : i ≠ j a : α hj : j < length (set l i a) ⊢ get (set l i a) { val := j, isLt := hj } = get l { val := j, isLt := (_ : j < length l) } rw [← Option.some_inj, ← get?_eq_get, get?_set_ne _ _ h, get?_eq_get] ** Qed
List.length_removeNth α : Type u_1 head✝ : α tail✝ : List α x✝ : 0 < length (head✝ :: tail✝) ⊢ length (removeNth (head✝ :: tail✝) 0) = length (head✝ :: tail✝) - 1 simp [removeNth] α : Type u_1 x : α xs : List α i : Nat h : i + 1 < length (x :: xs) ⊢ length (removeNth (x :: xs) (i + 1)) = length (x :: xs) - 1 have : i < length xs := Nat.lt_of_succ_lt_succ h α : Type u_1 x : α xs : List α i : Nat h : i + 1 < length (x :: xs) this : i < length xs ⊢ length (removeNth (x :: xs) (i + 1)) = length (x :: xs) - 1 simp [removeNth, ← Nat.add_one] α : Type u_1 x : α xs : List α i : Nat h : i + 1 < length (x :: xs) this : i < length xs ⊢ length (removeNth xs i) + 1 = length xs rw [length_removeNth this, Nat.sub_add_cancel (Nat.lt_of_le_of_lt (Nat.zero_le _) this)] ** Qed
List.length_tail α : Type u_1 l : List α ⊢ length (tail l) = length l - 1 cases l <;> rfl ** Qed
List.all_eq_true α : Type u_1 p : α → Bool l : List α ⊢ all l p = true ↔ ∀ (x : α), x ∈ l → p x = true induction l <;> simp [] * Qed
List.any_eq_true α : Type u_1 p : α → Bool l : List α ⊢ any l p = true ↔ ∃ x, x ∈ l ∧ p x = true induction l <;> simp [] * Qed
List.contains_cons α : Type u_1 a : α as : List α x : α inst✝ : BEq α ⊢ contains (a :: as) x = (x == a \|\| contains as x) simp only [contains, elem] α : Type u_1 a : α as : List α x : α inst✝ : BEq α ⊢ (match x == a with \| true => true \| false => elem x as) = (x == a \|\| elem x as) split <;> simp_all ** Qed
List.contains_eq_any_beq α : Type u_1 inst✝ : BEq α l : List α a : α ⊢ contains l a = any l fun x => a == x induction l with simp \| cons b l => cases a == b <;> simp [] * case cons α : Type u_1 inst✝ : BEq α a b : α l : List α tail_ih✝ : contains l a = any l fun x => a == x ⊢ (a == b \|\| contains l a) = (a == b \|\| any l fun x => a == x) ** cases a == b <;> simp [] * Qed
List.mem_reverseAux α : Type u_1 x a : α tail✝ x✝ : List α ⊢ x ∈ reverseAux (a :: tail✝) x✝ ↔ x ∈ a :: tail✝ ∨ x ∈ x✝ rw [reverseAux, mem_cons, or_assoc, or_left_comm, mem_reverseAux, mem_cons] ** Qed
List.mem_reverse α : Type u_1 x : α as : List α ⊢ x ∈ reverse as ↔ x ∈ as simp [reverse] ** Qed
List.insert_of_mem α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l ⊢ List.insert a l = l simp only [List.insert, if_pos h] ** Qed
List.insert_of_not_mem α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : ¬a ∈ l ⊢ List.insert a l = a :: l simp only [List.insert, if_neg h] ** Qed
List.mem_insert_iff α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l if h : b ∈ l then rw [insert_of_mem h] constructor; {apply Or.inr} intro \| Or.inl h' => rw [h']; exact h \| Or.inr h' => exact h' else rw [insert_of_not_mem h, mem_cons] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l rw [insert_of_mem h] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a ∈ l ↔ a = b ∨ a ∈ l constructor case mp α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a ∈ l → a = b ∨ a ∈ l case mpr α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a = b ∨ a ∈ l → a ∈ l {apply Or.inr} case mpr α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l ⊢ a = b ∨ a ∈ l → a ∈ l intro \| Or.inl h' => rw [h']; exact h \| Or.inr h' => exact h' α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l x✝ : a = b ∨ a ∈ l h' : a = b ⊢ a ∈ l rw [h'] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l x✝ : a = b ∨ a ∈ l h' : a = b ⊢ b ∈ l exact h α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ∈ l x✝ : a = b ∨ a ∈ l h' : a ∈ l ⊢ a ∈ l exact h' α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : ¬b ∈ l ⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l rw [insert_of_not_mem h, mem_cons] ** Qed
List.length_insert_of_mem α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l ⊢ length (List.insert a l) = length l rw [insert_of_mem h] ** Qed
List.length_insert_of_not_mem α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : ¬a ∈ l ⊢ length (List.insert a l) = length l + 1 rw [insert_of_not_mem h] α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : ¬a ∈ l ⊢ length (a :: l) = length l + 1 rfl ** Qed
List.eraseP_cons_of_pos α : Type u_1 a : α l : List α p : α → Bool h : p a = true ⊢ eraseP p (a :: l) = l simp [eraseP_cons, h] ** Qed
List.eraseP_cons_of_neg α : Type u_1 a : α l : List α p : α → Bool h : ¬p a = true ⊢ eraseP p (a :: l) = a :: eraseP p l simp [eraseP_cons, h] ** Qed
List.eraseP_of_forall_not α : Type u_1 p : α → Bool l : List α h : ∀ (a : α), a ∈ l → ¬p a = true ⊢ eraseP p l = l induction l with \| nil => rfl \| cons _ _ ih => simp [h _ (.head ..), ih (forall_mem_cons.1 h).2] case nil α : Type u_1 p : α → Bool h : ∀ (a : α), a ∈ [] → ¬p a = true ⊢ eraseP p [] = [] rfl case cons α : Type u_1 p : α → Bool head✝ : α tail✝ : List α ih : (∀ (a : α), a ∈ tail✝ → ¬p a = true) → eraseP p tail✝ = tail✝ h : ∀ (a : α), a ∈ head✝ :: tail✝ → ¬p a = true ⊢ eraseP p (head✝ :: tail✝) = head✝ :: tail✝ simp [h _ (.head ..), ih (forall_mem_cons.1 h).2] ** Qed
List.exists_of_eraseP α : Type u_1 p : α → Bool b : α l : List α a : α al : a ∈ b :: l pa : p a = true pb : p b = true ⊢ b :: l = [] ++ b :: l ∧ eraseP p (b :: l) = [] ++ l simp [pb] α : Type u_1 p : α → Bool b✝ : α l : List α a : α al✝ : a ∈ b✝ :: l pa : p a = true b : α al : Mem a l pb : ¬p b = true c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ b :: l = b :: l₁ ++ c :: l₂ rw [h₃, cons_append] α : Type u_1 p : α → Bool b✝ : α l : List α a : α al✝ : a ∈ b✝ :: l pa : p a = true b : α al : Mem a l pb : ¬p b = true c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ eraseP p (b :: l) = b :: l₁ ++ l₂ simp [pb, h₄] ** Qed
List.length_eraseP_of_mem α✝ : Type u_1 a : α✝ l : List α✝ p : α✝ → Bool al : a ∈ l pa : p a = true ⊢ length (eraseP p l) = pred (length l) let ⟨_, l₁, l₂, _, _, e₁, e₂⟩ := exists_of_eraseP al pa α✝ : Type u_1 a : α✝ l : List α✝ p : α✝ → Bool al : a ∈ l pa : p a = true w✝ : α✝ l₁ l₂ : List α✝ left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true left✝ : p w✝ = true e₁ : l = l₁ ++ w✝ :: l₂ e₂ : eraseP p l = l₁ ++ l₂ ⊢ length (eraseP p l) = pred (length l) rw [e₂] α✝ : Type u_1 a : α✝ l : List α✝ p : α✝ → Bool al : a ∈ l pa : p a = true w✝ : α✝ l₁ l₂ : List α✝ left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true left✝ : p w✝ = true e₁ : l = l₁ ++ w✝ :: l₂ e₂ : eraseP p l = l₁ ++ l₂ ⊢ length (l₁ ++ l₂) = pred (length l) simp [length_append, e₁] α✝ : Type u_1 a : α✝ l : List α✝ p : α✝ → Bool al : a ∈ l pa : p a = true w✝ : α✝ l₁ l₂ : List α✝ left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true left✝ : p w✝ = true e₁ : l = l₁ ++ w✝ :: l₂ e₂ : eraseP p l = l₁ ++ l₂ ⊢ length l₁ + length l₂ = pred (length l₁ + succ (length l₂)) rfl ** Qed
List.eraseP_append_left α : Type u_1 p : α → Bool a : α pa : p a = true x : α xs l₂ : List α h : a ∈ x :: xs ⊢ eraseP p (x :: xs ++ l₂) = eraseP p (x :: xs) ++ l₂ by_cases h' : p x <;> simp [h'] case neg α : Type u_1 p : α → Bool a : α pa : p a = true x : α xs l₂ : List α h : a ∈ x :: xs h' : ¬p x = true ⊢ eraseP p (xs ++ l₂) = eraseP p xs ++ l₂ rw [eraseP_append_left pa l₂ ((mem_cons.1 h).resolve_left (mt _ h'))] α : Type u_1 p : α → Bool a : α pa : p a = true x : α xs l₂ : List α h : a ∈ x :: xs h' : ¬p x = true ⊢ a = x → p x = true intro \| rfl => exact pa α : Type u_1 p : α → Bool a : α pa : p a = true x : α xs l₂ : List α x✝ : a = x h : a ∈ a :: xs h' : ¬p a = true ⊢ p a = true exact pa ** Qed
List.eraseP_append_right α : Type u_1 p : α → Bool x : α xs l₂ : List α h : ∀ (b : α), b ∈ x :: xs → ¬p b = true ⊢ eraseP p (x :: xs ++ l₂) = x :: xs ++ eraseP p l₂ simp [(forall_mem_cons.1 h).1, eraseP_append_right _ (forall_mem_cons.1 h).2] ** Qed
List.eraseP_sublist α : Type u_1 p : α → Bool l : List α ⊢ eraseP p l <+ l match exists_or_eq_self_of_eraseP p l with \| .inl h => rw [h]; apply Sublist.refl \| .inr ⟨c, l₁, l₂, _, _, h₃, h₄⟩ => rw [h₄, h₃]; simp α : Type u_1 p : α → Bool l : List α h : eraseP p l = l ⊢ eraseP p l <+ l rw [h] α : Type u_1 p : α → Bool l : List α h : eraseP p l = l ⊢ l <+ l apply Sublist.refl α : Type u_1 p : α → Bool l : List α c : α l₁ l₂ : List α left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true left✝ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ eraseP p l <+ l rw [h₄, h₃] α : Type u_1 p : α → Bool l : List α c : α l₁ l₂ : List α left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true left✝ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ l₁ ++ l₂ <+ l₁ ++ c :: l₂ simp ** Qed
List.Sublist.eraseP α✝ : Type u_1 l₁✝ l₂ : List α✝ p : α✝ → Bool l₁ l₂✝ : List α✝ a : α✝ s : l₁ <+ l₂✝ ⊢ List.eraseP p l₁ <+ List.eraseP p (a :: l₂✝) by_cases h : p a <;> simp [h] case pos α✝ : Type u_1 l₁✝ l₂ : List α✝ p : α✝ → Bool l₁ l₂✝ : List α✝ a : α✝ s : l₁ <+ l₂✝ h : p a = true ⊢ List.eraseP p l₁ <+ l₂✝ case neg α✝ : Type u_1 l₁✝ l₂ : List α✝ p : α✝ → Bool l₁ l₂✝ : List α✝ a : α✝ s : l₁ <+ l₂✝ h : ¬p a = true ⊢ List.eraseP p l₁ <+ a :: List.eraseP p l₂✝ exacts [s.eraseP.trans (eraseP_sublist _), s.eraseP.cons _] α✝ : Type u_1 l₁ l₂ : List α✝ p : α✝ → Bool l₁✝ l₂✝ : List α✝ a : α✝ s : l₁✝ <+ l₂✝ ⊢ List.eraseP p (a :: l₁✝) <+ List.eraseP p (a :: l₂✝) by_cases h : p a <;> simp [h] case pos α✝ : Type u_1 l₁ l₂ : List α✝ p : α✝ → Bool l₁✝ l₂✝ : List α✝ a : α✝ s : l₁✝ <+ l₂✝ h : p a = true ⊢ l₁✝ <+ l₂✝ case neg α✝ : Type u_1 l₁ l₂ : List α✝ p : α✝ → Bool l₁✝ l₂✝ : List α✝ a : α✝ s : l₁✝ <+ l₂✝ h : ¬p a = true ⊢ a :: List.eraseP p l₁✝ <+ a :: List.eraseP p l₂✝ exacts [s, s.eraseP.cons₂ _] ** Qed
List.mem_eraseP_of_neg α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true ⊢ a ∈ eraseP p l ↔ a ∈ l refine ⟨mem_of_mem_eraseP, fun al => ?_⟩ α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l ⊢ a ∈ eraseP p l match exists_or_eq_self_of_eraseP p l with \| .inl h => rw [h]; assumption \| .inr ⟨c, l₁, l₂, h₁, h₂, h₃, h₄⟩ => rw [h₄]; rw [h₃] at al have : a ≠ c := fun h => (h ▸ pa).elim h₂ simp [this] at al; simp [al] α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l h : eraseP p l = l ⊢ a ∈ eraseP p l rw [h] α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l h : eraseP p l = l ⊢ a ∈ l assumption α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ a ∈ eraseP p l rw [h₄] α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true al : a ∈ l c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ a ∈ l₁ ++ l₂ rw [h₃] at al α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true c : α l₁ l₂ : List α al : a ∈ l₁ ++ c :: l₂ h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ ⊢ a ∈ l₁ ++ l₂ have : a ≠ c := fun h => (h ▸ pa).elim h₂ α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true c : α l₁ l₂ : List α al : a ∈ l₁ ++ c :: l₂ h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ this : a ≠ c ⊢ a ∈ l₁ ++ l₂ simp [this] at al α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true c : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true h₂ : p c = true h₃ : l = l₁ ++ c :: l₂ h₄ : eraseP p l = l₁ ++ l₂ this : a ≠ c al : a ∈ l₁ ∨ a ∈ l₂ ⊢ a ∈ l₁ ++ l₂ simp [al] ** Qed
List.erase_cons_head α : Type u_1 inst✝ : DecidableEq α a : α l : List α ⊢ List.erase (a :: l) a = l simp [erase_cons] ** Qed
List.erase_cons_tail α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : b ≠ a ⊢ List.erase (b :: l) a = b :: List.erase l a simp only [erase_cons, if_neg h] ** Qed
List.erase_eq_eraseP α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l) if h : a = b then simp [h] else simp [h, Ne.symm h, erase_eq_eraseP a l] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : a = b ⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l) simp [h] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : ¬a = b ⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l) simp [h, Ne.symm h, erase_eq_eraseP a l] ** Qed
List.erase_of_not_mem α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : ¬a ∈ b :: l ⊢ List.erase (b :: l) a = b :: l rw [mem_cons, not_or] at h α : Type u_1 inst✝ : DecidableEq α a b : α l : List α h : ¬a = b ∧ ¬a ∈ l ⊢ List.erase (b :: l) a = b :: l rw [erase_cons, if_neg (Ne.symm h.1), erase_of_not_mem h.2] ** Qed
List.exists_erase_eq α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l ⊢ ∃ l₁ l₂, ¬a ∈ l₁ ∧ l = l₁ ++ a :: l₂ ∧ List.erase l a = l₁ ++ l₂ let ⟨_, l₁, l₂, h₁, e, h₂, h₃⟩ := exists_of_eraseP h (beq_self_eq_true _) α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l w✝ : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬(a == b) = true e : (a == w✝) = true h₂ : l = l₁ ++ w✝ :: l₂ h₃ : eraseP (BEq.beq a) l = l₁ ++ l₂ ⊢ ∃ l₁ l₂, ¬a ∈ l₁ ∧ l = l₁ ++ a :: l₂ ∧ List.erase l a = l₁ ++ l₂ rw [erase_eq_eraseP] α : Type u_1 inst✝ : DecidableEq α a : α l : List α h : a ∈ l w✝ : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → ¬(a == b) = true e : (a == w✝) = true h₂ : l = l₁ ++ w✝ :: l₂ h₃ : eraseP (BEq.beq a) l = l₁ ++ l₂ ⊢ ∃ l₁ l₂, ¬a ∈ l₁ ∧ l = l₁ ++ a :: l₂ ∧ eraseP (fun b => decide (a = b)) l = l₁ ++ l₂ exact ⟨l₁, l₂, fun h => h₁ _ h (beq_self_eq_true _), eq_of_beq e ▸ h₂, h₃⟩ ** Qed
List.sublist.erase α : Type u_1 inst✝ : DecidableEq α a : α l₁ l₂ : List α h : l₁ <+ l₂ ⊢ List.erase l₁ a <+ List.erase l₂ a simp only [erase_eq_eraseP] α : Type u_1 inst✝ : DecidableEq α a : α l₁ l₂ : List α h : l₁ <+ l₂ ⊢ eraseP (fun b => decide (a = b)) l₁ <+ eraseP (fun b => decide (a = b)) l₂ exact h.eraseP ** Qed
List.erase_comm α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a if ab : a = b then rw [ab] else ?_ α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a if ha : a ∈ l then ?_ else simp only [erase_of_not_mem ha, erase_of_not_mem (mt mem_of_mem_erase ha)] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ha : a ∈ l ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a if hb : b ∈ l then ?_ else simp only [erase_of_not_mem hb, erase_of_not_mem (mt mem_of_mem_erase hb)] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ha : a ∈ l hb : b ∈ l ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a match l, l.erase a, exists_erase_eq ha with \| _, _, ⟨l₁, l₂, ha', rfl, rfl⟩ => if h₁ : b ∈ l₁ then rw [erase_append_left _ h₁, erase_append_left _ h₁, erase_append_right _ (mt mem_of_mem_erase ha'), erase_cons_head] else rw [erase_append_right _ h₁, erase_append_right _ h₁, erase_append_right _ ha', erase_cons_tail _ ab, erase_cons_head] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : a = b ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a rw [ab] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ha : ¬a ∈ l ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a simp only [erase_of_not_mem ha, erase_of_not_mem (mt mem_of_mem_erase ha)] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b ha : a ∈ l hb : ¬b ∈ l ⊢ List.erase (List.erase l a) b = List.erase (List.erase l b) a simp only [erase_of_not_mem hb, erase_of_not_mem (mt mem_of_mem_erase hb)] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b l₁ l₂ : List α ha' : ¬a ∈ l₁ ha : a ∈ l₁ ++ a :: l₂ hb : b ∈ l₁ ++ a :: l₂ ⊢ List.erase (l₁ ++ l₂) b = List.erase (List.erase (l₁ ++ a :: l₂) b) a if h₁ : b ∈ l₁ then rw [erase_append_left _ h₁, erase_append_left _ h₁, erase_append_right _ (mt mem_of_mem_erase ha'), erase_cons_head] else rw [erase_append_right _ h₁, erase_append_right _ h₁, erase_append_right _ ha', erase_cons_tail _ ab, erase_cons_head] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b l₁ l₂ : List α ha' : ¬a ∈ l₁ ha : a ∈ l₁ ++ a :: l₂ hb : b ∈ l₁ ++ a :: l₂ h₁ : b ∈ l₁ ⊢ List.erase (l₁ ++ l₂) b = List.erase (List.erase (l₁ ++ a :: l₂) b) a rw [erase_append_left _ h₁, erase_append_left _ h₁, erase_append_right _ (mt mem_of_mem_erase ha'), erase_cons_head] α : Type u_1 inst✝ : DecidableEq α a b : α l : List α ab : ¬a = b l₁ l₂ : List α ha' : ¬a ∈ l₁ ha : a ∈ l₁ ++ a :: l₂ hb : b ∈ l₁ ++ a :: l₂ h₁ : ¬b ∈ l₁ ⊢ List.erase (l₁ ++ l₂) b = List.erase (List.erase (l₁ ++ a :: l₂) b) a rw [erase_append_right _ h₁, erase_append_right _ h₁, erase_append_right _ ha', erase_cons_tail _ ab, erase_cons_head] ** Qed
List.filter_cons_of_pos α : Type u_1 p : α → Bool a : α l : List α pa : p a = true ⊢ filter p (a :: l) = a :: filter p l rw [filter, pa] ** Qed
List.filter_cons_of_neg α : Type u_1 p : α → Bool a : α l : List α pa : ¬p a = true ⊢ filter p (a :: l) = filter p l rw [filter, eq_false_of_ne_true pa] ** Qed
List.filter_append α : Type u_1 p : α → Bool a : α l₁ l₂ : List α ⊢ filter p (a :: l₁ ++ l₂) = filter p (a :: l₁) ++ filter p l₂ simp [filter] α : Type u_1 p : α → Bool a : α l₁ l₂ : List α ⊢ (match p a with \| true => a :: filter p (l₁ ++ l₂) \| false => filter p (l₁ ++ l₂)) = (match p a with \| true => a :: filter p l₁ \| false => filter p l₁) ++ filter p l₂ split <;> simp [filter_append l₁] ** Qed
List.filter_sublist α : Type u_1 p : α → Bool a : α l : List α ⊢ filter p (a :: l) <+ a :: l rw [filter] α : Type u_1 p : α → Bool a : α l : List α ⊢ (match p a with \| true => a :: filter p l \| false => filter p l) <+ a :: l split <;> simp [Sublist.cons, Sublist.cons₂, filter_sublist l] ** Qed
List.mem_filter case nil α✝ : Type u_1 x : α✝ p : α✝ → Bool ⊢ x ∈ filter p [] ↔ x ∈ [] ∧ p x = true simp [filter] case cons α✝ : Type u_1 x : α✝ p : α✝ → Bool a : α✝ as : List α✝ ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true ⊢ x ∈ filter p (a :: as) ↔ x ∈ a :: as ∧ p x = true by_cases h : p a <;> simp [, or_and_right] * case pos α✝ : Type u_1 x : α✝ p : α✝ → Bool a : α✝ as : List α✝ ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true h : p a = true ⊢ x = a ∨ x ∈ as ∧ p x = true ↔ x = a ∧ p x = true ∨ x ∈ as ∧ p x = true exact or_congr_left (and_iff_left_of_imp fun \| rfl => h).symm case neg α✝ : Type u_1 x : α✝ p : α✝ → Bool a : α✝ as : List α✝ ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true h : ¬p a = true ⊢ x ∈ as ∧ p x = true ↔ x = a ∧ p x = true ∨ x ∈ as ∧ p x = true exact (or_iff_right fun ⟨rfl, h'⟩ => h h').symm Qed
List.partition_eq_filter_filter α : Type u_1 p : α → Bool l : List α ⊢ partition p l = (filter p l, filter (not ∘ p) l) simp [partition, aux] α : Type u_1 p : α → Bool l as✝ bs✝ : List α ⊢ partition.loop p [] (as✝, bs✝) = (reverse as✝ ++ filter p [], reverse bs✝ ++ filter (not ∘ p) []) simp [partition.loop, filter] α : Type u_1 p : α → Bool l✝ as✝ bs✝ : List α a : α l : List α ⊢ partition.loop p (a :: l) (as✝, bs✝) = (reverse as✝ ++ filter p (a :: l), reverse bs✝ ++ filter (not ∘ p) (a :: l)) cases pa : p a <;> simp [partition.loop, pa, aux, filter, append_assoc] ** Qed
List.filter_congr' α : Type u_1 p q : α → Bool a : α l : List α h : ∀ (x : α), x ∈ a :: l → (p x = true ↔ q x = true) ⊢ filter p (a :: l) = filter q (a :: l) rw [forall_mem_cons] at h α : Type u_1 p q : α → Bool a : α l : List α h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true) ⊢ filter p (a :: l) = filter q (a :: l) by_cases pa : p a case pos α : Type u_1 p q : α → Bool a : α l : List α h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true) pa : p a = true ⊢ filter p (a :: l) = filter q (a :: l) simp [pa, h.1.1 pa, filter_congr' h.2] case neg α : Type u_1 p q : α → Bool a : α l : List α h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true) pa : ¬p a = true ⊢ filter p (a :: l) = filter q (a :: l) simp [pa, mt h.1.2 pa, filter_congr' h.2] ** Qed
List.filterMap_cons_none α : Type u_1 β : Type u_2 f : α → Option β a : α l : List α h : f a = none ⊢ filterMap f (a :: l) = filterMap f l simp only [filterMap, h] ** Qed
List.filterMap_cons_some α : Type u_1 β : Type u_2 f : α → Option β a : α l : List α b : β h : f a = some b ⊢ filterMap f (a :: l) = b :: filterMap f l simp only [filterMap, h] ** Qed
List.filterMap_append α : Type u_1 β : Type u_2 l l' : List α f : α → Option β ⊢ filterMap f (l ++ l') = filterMap f l ++ filterMap f l' induction l <;> simp case cons α : Type u_1 β : Type u_2 l' : List α f : α → Option β head✝ : α tail✝ : List α tail_ih✝ : filterMap f (tail✝ ++ l') = filterMap f tail✝ ++ filterMap f l' ⊢ (match f head✝ with \| none => filterMap f (tail✝ ++ l') \| some b => b :: filterMap f (tail✝ ++ l')) = (match f head✝ with \| none => filterMap f tail✝ \| some b => b :: filterMap f tail✝) ++ filterMap f l' split <;> simp [] * Qed
List.filterMap_eq_map α : Type u_1 β : Type u_2 f : α → β ⊢ filterMap (some ∘ f) = map f funext l case h α : Type u_1 β : Type u_2 f : α → β l : List α ⊢ filterMap (some ∘ f) l = map f l induction l <;> simp [] * Qed
List.filterMap_eq_filter α : Type u_1 p : α → Bool ⊢ filterMap (Option.guard fun x => p x = true) = filter p funext l case h α : Type u_1 p : α → Bool l : List α ⊢ filterMap (Option.guard fun x => p x = true) l = filter p l induction l with \| nil => rfl \| cons a l IH => by_cases pa : p a <;> simp [Option.guard, pa, ← IH] case h.nil α : Type u_1 p : α → Bool ⊢ filterMap (Option.guard fun x => p x = true) [] = filter p [] rfl case h.cons α : Type u_1 p : α → Bool a : α l : List α IH : filterMap (Option.guard fun x => p x = true) l = filter p l ⊢ filterMap (Option.guard fun x => p x = true) (a :: l) = filter p (a :: l) by_cases pa : p a <;> simp [Option.guard, pa, ← IH] ** Qed
List.filterMap_filterMap α : Type u_1 β : Type u_2 γ : Type u_3 f : α → Option β g : β → Option γ l : List α ⊢ filterMap g (filterMap f l) = filterMap (fun x => Option.bind (f x) g) l induction l with \| nil => rfl \| cons a l IH => cases h : f a <;> simp [] * case nil α : Type u_1 β : Type u_2 γ : Type u_3 f : α → Option β g : β → Option γ ⊢ filterMap g (filterMap f []) = filterMap (fun x => Option.bind (f x) g) [] rfl case cons α : Type u_1 β : Type u_2 γ : Type u_3 f : α → Option β g : β → Option γ a : α l : List α IH : filterMap g (filterMap f l) = filterMap (fun x => Option.bind (f x) g) l ⊢ filterMap g (filterMap f (a :: l)) = filterMap (fun x => Option.bind (f x) g) (a :: l) ** cases h : f a <;> simp [] * Qed
List.map_filterMap α : Type u_1 β : Type u_2 γ : Type u_3 f : α → Option β g : β → γ l : List α ⊢ map g (filterMap f l) = filterMap (fun x => Option.map g (f x)) l simp only [← filterMap_eq_map, filterMap_filterMap, Option.map_eq_bind] ** Qed
List.filterMap_map α : Type u_1 β : Type u_2 γ : Type u_3 f : α → β g : β → Option γ l : List α ⊢ filterMap g (map f l) = filterMap (g ∘ f) l rw [← filterMap_eq_map, filterMap_filterMap] α : Type u_1 β : Type u_2 γ : Type u_3 f : α → β g : β → Option γ l : List α ⊢ filterMap (fun x => Option.bind ((some ∘ f) x) g) l = filterMap (g ∘ f) l rfl ** Qed
List.filter_filterMap α : Type u_1 β : Type u_2 f : α → Option β p : β → Bool l : List α ⊢ filter p (filterMap f l) = filterMap (fun x => Option.filter p (f x)) l rw [← filterMap_eq_filter, filterMap_filterMap] α : Type u_1 β : Type u_2 f : α → Option β p : β → Bool l : List α ⊢ filterMap (fun x => Option.bind (f x) (Option.guard fun x => p x = true)) l = filterMap (fun x => Option.filter p (f x)) l congr case e_f α : Type u_1 β : Type u_2 f : α → Option β p : β → Bool l : List α ⊢ (fun x => Option.bind (f x) (Option.guard fun x => p x = true)) = fun x => Option.filter p (f x) funext x case e_f.h α : Type u_1 β : Type u_2 f : α → Option β p : β → Bool l : List α x : α ⊢ Option.bind (f x) (Option.guard fun x => p x = true) = Option.filter p (f x) cases f x <;> simp [Option.filter, Option.guard] ** Qed
List.filterMap_filter α : Type u_1 β : Type u_2 p : α → Bool f : α → Option β l : List α ⊢ filterMap f (filter p l) = filterMap (fun x => if p x = true then f x else none) l rw [← filterMap_eq_filter, filterMap_filterMap] α : Type u_1 β : Type u_2 p : α → Bool f : α → Option β l : List α ⊢ filterMap (fun x => Option.bind (Option.guard (fun x => p x = true) x) f) l = filterMap (fun x => if p x = true then f x else none) l congr case e_f α : Type u_1 β : Type u_2 p : α → Bool f : α → Option β l : List α ⊢ (fun x => Option.bind (Option.guard (fun x => p x = true) x) f) = fun x => if p x = true then f x else none funext x case e_f.h α : Type u_1 β : Type u_2 p : α → Bool f : α → Option β l : List α x : α ⊢ Option.bind (Option.guard (fun x => p x = true) x) f = if p x = true then f x else none by_cases h : p x <;> simp [Option.guard, h] ** Qed
List.filterMap_some α : Type u_1 l : List α ⊢ filterMap some l = l erw [filterMap_eq_map, map_id] ** Qed
List.map_filterMap_some_eq_filter_map_is_some α : Type u_1 β : Type u_2 f : α → Option β l : List α ⊢ map some (filterMap f l) = filter (fun b => Option.isSome b) (map f l) induction l <;> simp case cons α : Type u_1 β : Type u_2 f : α → Option β head✝ : α tail✝ : List α tail_ih✝ : map some (filterMap f tail✝) = filter (fun b => Option.isSome b) (map f tail✝) ⊢ map some (match f head✝ with \| none => filterMap f tail✝ \| some b => b :: filterMap f tail✝) = filter (fun b => Option.isSome b) (f head✝ :: map f tail✝) split <;> simp [] * Qed
List.mem_filterMap α : Type u_1 β : Type u_2 f : α → Option β l : List α b : β ⊢ b ∈ filterMap f l ↔ ∃ a, a ∈ l ∧ f a = some b induction l <;> simp case cons α : Type u_1 β : Type u_2 f : α → Option β b : β head✝ : α tail✝ : List α tail_ih✝ : b ∈ filterMap f tail✝ ↔ ∃ a, a ∈ tail✝ ∧ f a = some b ⊢ (b ∈ match f head✝ with \| none => filterMap f tail✝ \| some b => b :: filterMap f tail✝) ↔ f head✝ = some b ∨ ∃ a, a ∈ tail✝ ∧ f a = some b split <;> simp [, eq_comm] * Qed
List.filterMap_join α : Type u_1 β : Type u_2 f : α → Option β L : List (List α) ⊢ filterMap f (join L) = join (map (filterMap f) L) induction L <;> simp [, filterMap_append] * Qed
List.map_filterMap_of_inv α : Type u_1 β : Type u_2 f : α → Option β g : β → α H : ∀ (x : α), Option.map g (f x) = some x l : List α ⊢ map g (filterMap f l) = l simp only [map_filterMap, H, filterMap_some] ** Qed
List.Sublist.filterMap α : Type u_1 β : Type u_2 l₁ l₂ : List α f : α → Option β s : l₁ <+ l₂ ⊢ List.filterMap f l₁ <+ List.filterMap f l₂ induction s <;> simp <;> split <;> simp [, cons, cons₂] * Qed
List.Sublist.filter α : Type u_1 p : α → Bool l₁ l₂ : List α s : l₁ <+ l₂ ⊢ List.filter p l₁ <+ List.filter p l₂ rw [← filterMap_eq_filter] α : Type u_1 p : α → Bool l₁ l₂ : List α s : l₁ <+ l₂ ⊢ List.filterMap (Option.guard fun x => p x = true) l₁ <+ List.filterMap (Option.guard fun x => p x = true) l₂ apply s.filterMap ** Qed
List.map_filter β : Type u_1 α : Type u_2 p : α → Bool f : β → α l : List β ⊢ filter p (map f l) = map f (filter (p ∘ f) l) rw [← filterMap_eq_map, filter_filterMap, filterMap_filter] β : Type u_1 α : Type u_2 p : α → Bool f : β → α l : List β ⊢ filterMap (fun x => Option.filter p ((some ∘ f) x)) l = filterMap (fun x => if (p ∘ f) x = true then (some ∘ f) x else none) l rfl ** Qed
List.filter_filter α✝ : Type u_1 p q : α✝ → Bool a : α✝ l : List α✝ ⊢ filter p (filter q (a :: l)) = filter (fun a => decide (p a = true ∧ q a = true)) (a :: l) by_cases hp : p a <;> by_cases hq : q a <;> simp [hp, hq, filter_filter _ l] ** Qed
List.filter_eq_nil α✝ : Type u_1 p : α✝ → Bool l : List α✝ ⊢ filter p l = [] ↔ ∀ (a : α✝), a ∈ l → ¬p a = true simp only [eq_nil_iff_forall_not_mem, mem_filter, not_and] ** Qed
List.filter_eq_self α✝ : Type u_1 p : α✝ → Bool l : List α✝ ⊢ filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true induction l with simp \| cons a l ih => cases h : p a <;> simp [] intro h; exact Nat.lt_irrefl _ (h ▸ length_filter_le p l) * case cons α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true ⊢ filter p (a :: l) = a :: l ↔ p a = true ∧ ∀ (a : α✝), a ∈ l → p a = true ** cases h : p a <;> simp [] * case cons.false α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true h : p a = false ⊢ ¬filter p l = a :: l intro h case cons.false α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ ih : filter p l = l ↔ ∀ (a : α✝), a ∈ l → p a = true h✝ : p a = false h : filter p l = a :: l ⊢ False exact Nat.lt_irrefl _ (h ▸ length_filter_le p l) Qed
List.find?_cons_of_pos α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ h : p a = true ⊢ find? p (a :: l) = some a simp [find?, h] ** Qed
List.find?_cons_of_neg α✝ : Type u_1 p : α✝ → Bool a : α✝ l : List α✝ h : ¬p a = true ⊢ find? p (a :: l) = find? p l simp [find?, h] ** Qed
List.find?_eq_none α✝ : Type u_1 p : α✝ → Bool l : List α✝ ⊢ find? p l = none ↔ ∀ (x : α✝), x ∈ l → ¬p x = true induction l <;> simp [find?_cons] case cons α✝ : Type u_1 p : α✝ → Bool head✝ : α✝ tail✝ : List α✝ tail_ih✝ : find? p tail✝ = none ↔ ∀ (x : α✝), x ∈ tail✝ → ¬p x = true ⊢ (match p head✝ with \| true => some head✝ \| false => find? p tail✝) = none ↔ p head✝ = false ∧ ∀ (a : α✝), a ∈ tail✝ → p a = false split <;> simp [] * Qed
List.find?_some α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ H : find? p (b :: l) = some a ⊢ p a = true by_cases h : p b <;> simp [find?, h] at H case pos α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ h : p b = true H : b = a ⊢ p a = true exact H ▸ h case neg α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ h : ¬p b = true H : find? p l = some a ⊢ p a = true exact find?_some H ** Qed
List.mem_of_find?_eq_some α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ H : find? p (b :: l) = some a ⊢ a ∈ b :: l by_cases h : p b <;> simp [find?, h] at H case pos α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ h : p b = true H : b = a ⊢ a ∈ b :: l exact H ▸ .head _ case neg α✝ : Type u_1 p : α✝ → Bool a b : α✝ l : List α✝ h : ¬p b = true H : find? p l = some a ⊢ a ∈ b :: l exact .tail _ (mem_of_find?_eq_some H) ** Qed
List.findIdx_cons α : Type u_1 p : α → Bool b : α l : List α ⊢ findIdx p (b :: l) = bif p b then 0 else findIdx p l + 1 cases H : p b with \| true => simp [H, findIdx, findIdx.go] \| false => simp [H, findIdx, findIdx.go, findIdx_go_succ] case true α : Type u_1 p : α → Bool b : α l : List α H : p b = true ⊢ findIdx p (b :: l) = bif true then 0 else findIdx p l + 1 simp [H, findIdx, findIdx.go] case false α : Type u_1 p : α → Bool b : α l : List α H : p b = false ⊢ findIdx p (b :: l) = bif false then 0 else findIdx p l + 1 simp [H, findIdx, findIdx.go, findIdx_go_succ] α : Type u_1 p✝ : α → Bool b : α l✝ : List α p : α → Bool l : List α n : Nat ⊢ findIdx.go p l (n + 1) = findIdx.go p l n + 1 cases l with \| nil => unfold findIdx.go; exact Nat.succ_eq_add_one n \| cons head tail => unfold findIdx.go cases p head <;> simp only [cond_false, cond_true] exact findIdx_go_succ p tail (n + 1) case nil α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat ⊢ findIdx.go p [] (n + 1) = findIdx.go p [] n + 1 unfold findIdx.go case nil α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat ⊢ n + 1 = n + 1 exact Nat.succ_eq_add_one n case cons α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat head : α tail : List α ⊢ findIdx.go p (head :: tail) (n + 1) = findIdx.go p (head :: tail) n + 1 unfold findIdx.go case cons α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat head : α tail : List α ⊢ (bif p head then n + 1 else findIdx.go p tail (n + 1 + 1)) = (bif p head then n else findIdx.go p tail (n + 1)) + 1 cases p head <;> simp only [cond_false, cond_true] case cons.false α : Type u_1 p✝ : α → Bool b : α l : List α p : α → Bool n : Nat head : α tail : List α ⊢ findIdx.go p tail (n + 1 + 1) = findIdx.go p tail (n + 1) + 1 exact findIdx_go_succ p tail (n + 1) ** Qed
List.findIdx_of_get?_eq_some α : Type u_1 p : α → Bool y : α xs : List α w : get? xs (findIdx p xs) = some y ⊢ p y = true induction xs with \| nil => simp_all \| cons x xs ih => by_cases h : p x <;> simp_all [findIdx_cons] case nil α : Type u_1 p : α → Bool y : α w : get? [] (findIdx p []) = some y ⊢ p y = true simp_all case cons α : Type u_1 p : α → Bool y x : α xs : List α ih : get? xs (findIdx p xs) = some y → p y = true w : get? (x :: xs) (findIdx p (x :: xs)) = some y ⊢ p y = true by_cases h : p x <;> simp_all [findIdx_cons] ** Qed
List.findIdx_lt_length_of_exists case nil α : Type u_1 p : α → Bool h : ∃ x, x ∈ [] ∧ p x = true ⊢ findIdx p [] < length [] simp_all case cons α : Type u_1 p : α → Bool x : α xs : List α ih : (∃ x, x ∈ xs ∧ p x = true) → findIdx p xs < length xs h : ∃ x_1, x_1 ∈ x :: xs ∧ p x_1 = true ⊢ findIdx p (x :: xs) < length (x :: xs) by_cases p x case pos α : Type u_1 p : α → Bool x : α xs : List α ih : (∃ x, x ∈ xs ∧ p x = true) → findIdx p xs < length xs h : ∃ x_1, x_1 ∈ x :: xs ∧ p x_1 = true h✝ : p x = true ⊢ findIdx p (x :: xs) < length (x :: xs) simp_all only [forall_exists_index, and_imp, mem_cons, exists_eq_or_imp, true_or, findIdx_cons, cond_true, length_cons] case pos α : Type u_1 p : α → Bool x : α xs : List α ih : ∀ (x : α), x ∈ xs → p x = true → findIdx p xs < length xs h✝ : p x = true ⊢ 0 < succ (length xs) apply Nat.succ_pos case neg α : Type u_1 p : α → Bool x : α xs : List α ih : (∃ x, x ∈ xs ∧ p x = true) → findIdx p xs < length xs h : ∃ x_1, x_1 ∈ x :: xs ∧ p x_1 = true h✝ : ¬p x = true ⊢ findIdx p (x :: xs) < length (x :: xs) simp_all [findIdx_cons] case neg α : Type u_1 p : α → Bool x : α xs : List α ih : ∀ (x : α), x ∈ xs → p x = true → findIdx p xs < length xs h : ∃ a, a ∈ xs ∧ p a = true h✝ : p x = false ⊢ findIdx p xs + 1 < succ (length xs) refine Nat.succ_lt_succ ?_ case neg α : Type u_1 p : α → Bool x : α xs : List α ih : ∀ (x : α), x ∈ xs → p x = true → findIdx p xs < length xs h : ∃ a, a ∈ xs ∧ p a = true h✝ : p x = false ⊢ findIdx p xs < length xs obtain ⟨x', m', h'⟩ := h case neg.intro.intro α : Type u_1 p : α → Bool x : α xs : List α ih : ∀ (x : α), x ∈ xs → p x = true → findIdx p xs < length xs h✝ : p x = false x' : α m' : x' ∈ xs h' : p x' = true ⊢ findIdx p xs < length xs exact ih x' m' h' ** Qed
List.pairwise_map α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop l : List α ⊢ Pairwise R (map f l) ↔ Pairwise (fun a b => R (f a) (f b)) l induction l case nil α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop ⊢ Pairwise R (map f []) ↔ Pairwise (fun a b => R (f a) (f b)) [] case cons α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop head✝ : α tail✝ : List α tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝ ⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝) . simp case cons α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop head✝ : α tail✝ : List α tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝ ⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝) . simp only [map, pairwise_cons, forall_mem_map_iff, ] * case nil α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop ⊢ Pairwise R (map f []) ↔ Pairwise (fun a b => R (f a) (f b)) [] simp case cons α : Type u_1 α✝ : Type u_2 f : α → α✝ R : α✝ → α✝ → Prop head✝ : α tail✝ : List α tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝ ⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝) ** simp only [map, pairwise_cons, forall_mem_map_iff, ] * Qed
List.pairwise_append α : Type u_1 R : α → α → Prop l₁ l₂ : List α ⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₁ → ∀ (b : α), b ∈ l₂ → R a b induction l₁ <;> simp [, or_imp, forall_and, and_assoc, and_left_comm] * Qed
List.pairwise_reverse α : Type u_1 R : α → α → Prop l : List α ⊢ Pairwise R (reverse l) ↔ Pairwise (fun a b => R b a) l induction l <;> simp [, pairwise_append, and_comm] * Qed
List.replaceF_cons_of_some α : Type u_1 a' a : α l : List α p : α → Option α h : p a = some a' ⊢ replaceF p (a :: l) = a' :: l simp [replaceF_cons, h] ** Qed
List.replaceF_cons_of_none α : Type u_1 a : α l : List α p : α → Option α h : p a = none ⊢ replaceF p (a :: l) = a :: replaceF p l simp [replaceF_cons, h] ** Qed
List.replaceF_of_forall_none α : Type u_1 p : α → Option α l : List α h : ∀ (a : α), a ∈ l → p a = none ⊢ replaceF p l = l induction l with \| nil => rfl \| cons _ _ ih => simp [h _ (.head ..), ih (forall_mem_cons.1 h).2] case nil α : Type u_1 p : α → Option α h : ∀ (a : α), a ∈ [] → p a = none ⊢ replaceF p [] = [] rfl case cons α : Type u_1 p : α → Option α head✝ : α tail✝ : List α ih : (∀ (a : α), a ∈ tail✝ → p a = none) → replaceF p tail✝ = tail✝ h : ∀ (a : α), a ∈ head✝ :: tail✝ → p a = none ⊢ replaceF p (head✝ :: tail✝) = head✝ :: tail✝ simp [h _ (.head ..), ih (forall_mem_cons.1 h).2] ** Qed
List.exists_of_replaceF α : Type u_1 p : α → Option α b : α l : List α a a' : α al : a ∈ b :: l pa : p a = some a' b' : α pb : p b = some b' ⊢ b :: l = [] ++ b :: l ∧ replaceF p (b :: l) = [] ++ b' :: l simp [pb] α : Type u_1 p : α → Option α b✝ : α l : List α a a' : α al✝ : a ∈ b✝ :: l pa : p a = some a' b : α al : Mem a l pb : p b = none c c' : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → p b = none h₂ : p c = some c' h₃ : l = l₁ ++ c :: l₂ h₄ : replaceF p l = l₁ ++ c' :: l₂ ⊢ b :: l = b :: l₁ ++ c :: l₂ rw [h₃, cons_append] α : Type u_1 p : α → Option α b✝ : α l : List α a a' : α al✝ : a ∈ b✝ :: l pa : p a = some a' b : α al : Mem a l pb : p b = none c c' : α l₁ l₂ : List α h₁ : ∀ (b : α), b ∈ l₁ → p b = none h₂ : p c = some c' h₃ : l = l₁ ++ c :: l₂ h₄ : replaceF p l = l₁ ++ c' :: l₂ ⊢ replaceF p (b :: l) = b :: l₁ ++ c' :: l₂ simp [pb, h₄] ** Qed
List.length_replaceF α✝ : Type u_1 f : α✝ → Option α✝ l : List α✝ ⊢ length (replaceF f l) = length l induction l <;> simp [replaceF] case cons α✝ : Type u_1 f : α✝ → Option α✝ head✝ : α✝ tail✝ : List α✝ tail_ih✝ : length (replaceF f tail✝) = length tail✝ ⊢ length (match f head✝ with \| none => head✝ :: replaceF f tail✝ \| some a => a :: tail✝) = succ (length tail✝) split <;> simp [] * Qed
List.disjoint_left α✝ : Type u_1 l₁ l₂ : List α✝ ⊢ Disjoint l₁ l₂ ↔ ∀ ⦃a : α✝⦄, a ∈ l₁ → ¬a ∈ l₂ simp [Disjoint] ** Qed
List.disjoint_nil_right α : Type u_1 l : List α ⊢ Disjoint l [] rw [disjoint_comm] α : Type u_1 l : List α ⊢ Disjoint [] l exact disjoint_nil_left _ ** Qed
List.singleton_disjoint α✝ : Type u_1 a : α✝ l : List α✝ ⊢ Disjoint [a] l ↔ ¬a ∈ l simp [Disjoint] ** Qed
List.disjoint_singleton α✝ : Type u_1 l : List α✝ a : α✝ ⊢ Disjoint l [a] ↔ ¬a ∈ l rw [disjoint_comm, singleton_disjoint] ** Qed
List.disjoint_append_left α✝ : Type u_1 l₁ l₂ l : List α✝ ⊢ Disjoint (l₁ ++ l₂) l ↔ Disjoint l₁ l ∧ Disjoint l₂ l simp [Disjoint, or_imp, forall_and] ** Qed
List.disjoint_append_right α✝ : Type u_1 l l₁ l₂ : List α✝ ⊢ Disjoint (l₁ ++ l₂) l ↔ Disjoint l l₁ ∧ Disjoint l l₂ rw [disjoint_append_left] α✝ : Type u_1 l l₁ l₂ : List α✝ ⊢ Disjoint l₁ l ∧ Disjoint l₂ l ↔ Disjoint l l₁ ∧ Disjoint l l₂ simp [disjoint_comm] ** Qed
List.disjoint_cons_left α✝ : Type u_1 a : α✝ l₁ l₂ : List α✝ ⊢ Disjoint [a] l₂ ∧ Disjoint l₁ l₂ ↔ ¬a ∈ l₂ ∧ Disjoint l₁ l₂ simp [singleton_disjoint] ** Qed
List.disjoint_cons_right α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ ⊢ Disjoint (a :: l₂) l₁ ↔ ¬a ∈ l₁ ∧ Disjoint l₁ l₂ rw [disjoint_cons_left] α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ ⊢ ¬a ∈ l₁ ∧ Disjoint l₂ l₁ ↔ ¬a ∈ l₁ ∧ Disjoint l₁ l₂ simp [disjoint_comm] ** Qed
List.foldl_map β₁ : Type u_1 β₂ : Type u_2 α : Type u_3 f : β₁ → β₂ g : α → β₂ → α l : List β₁ init : α ⊢ foldl g init (map f l) = foldl (fun x y => g x (f y)) init l induction l generalizing init <;> simp [] * Qed
List.foldr_map α₁ : Type u_1 α₂ : Type u_2 β : Type u_3 f : α₁ → α₂ g : α₂ → β → β l : List α₁ init : β ⊢ foldr g init (map f l) = foldr (fun x y => g (f x) y) init l induction l generalizing init <;> simp [] * Qed
List.foldl_hom α₁ : Type u_1 α₂ : Type u_2 β : Type u_3 f : α₁ → α₂ g₁ : α₁ → β → α₁ g₂ : α₂ → β → α₂ l : List β init : α₁ H : ∀ (x : α₁) (y : β), g₂ (f x) y = f (g₁ x y) ⊢ foldl g₂ (f init) l = f (foldl g₁ init l) induction l generalizing init <;> simp [, H] * Qed
List.foldr_hom β₁ : Type u_1 β₂ : Type u_2 α : Type u_3 f : β₁ → β₂ g₁ : α → β₁ → β₁ g₂ : α → β₂ → β₂ l : List α init : β₁ H : ∀ (x : α) (y : β₁), g₂ x (f y) = f (g₁ x y) ⊢ foldr g₂ (f init) l = f (foldr g₁ init l) induction l <;> simp [, H] * Qed
List.nil_union α : Type u_1 inst✝ : DecidableEq α l : List α ⊢ [] ∪ l = l simp [List.union_def, foldr] ** Qed
List.cons_union α : Type u_1 inst✝ : DecidableEq α a : α l₁ l₂ : List α ⊢ a :: l₁ ∪ l₂ = List.insert a (l₁ ∪ l₂) simp [List.union_def, foldr] ** Qed
List.mem_union_iff α : Type u_1 inst✝¹ inst✝ : DecidableEq α x : α l₁ l₂ : List α ⊢ x ∈ l₁ ∪ l₂ ↔ x ∈ l₁ ∨ x ∈ l₂ induction l₁ <;> simp [, or_assoc] * Qed
List.pair_mem_product α : Type u_1 β : Type u_2 xs : List α ys : List β x : α y : β ⊢ (x, y) ∈ product xs ys ↔ x ∈ xs ∧ y ∈ ys simp only [product, and_imp, exists_prop, mem_map, Prod.mk.injEq, exists_eq_right_right, mem_bind, iff_self] ** Qed
List.leftpad_prefix α : Type u_1 n : Nat a : α l : List α ⊢ replicate (n - length l) a <+: leftpad n a l simp only [IsPrefix, leftpad] α : Type u_1 n : Nat a : α l : List α ⊢ ∃ t, replicate (n - length l) a ++ t = replicate (n - length l) a ++ l exact Exists.intro l rfl ** Qed
List.leftpad_suffix α : Type u_1 n : Nat a : α l : List α ⊢ l <:+ leftpad n a l simp only [IsSuffix, leftpad] α : Type u_1 n : Nat a : α l : List α ⊢ ∃ t, t ++ l = replicate (n - length l) a ++ l exact Exists.intro (replicate (n - length l) a) rfl ** Qed