formal
stringlengths 41
427k
| informal
stringclasses 1
value |
|---|---|
List.forIn_eq_bindList ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → β → m (ForInStep β) l : List α init : β ⊢ forIn l init f = ForInStep.run <$> ForInStep.bindList f l (ForInStep.yield init) ** induction l generalizing init <;> simp [*, map_eq_pure_bind] ** case cons m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → β → m (ForInStep β) head✝ : α tail✝ : List α tail_ih✝ : ∀ (init : β), forIn tail✝ init f = ForInStep.run <$> ForInStep.bindList f tail✝ (ForInStep.yield init) init : β ⊢ (do let x ← f head✝ init match x with | ForInStep.done b => pure b | ForInStep.yield b => do let a ← ForInStep.bindList f tail✝ (ForInStep.yield b) pure (ForInStep.run a)) = do let x ← f head✝ init let a ← ForInStep.bindList f tail✝ x pure (ForInStep.run a) ** congr ** case cons.e_a m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → β → m (ForInStep β) head✝ : α tail✝ : List α tail_ih✝ : ∀ (init : β), forIn tail✝ init f = ForInStep.run <$> ForInStep.bindList f tail✝ (ForInStep.yield init) init : β ⊢ (fun x => match x with | ForInStep.done b => pure b | ForInStep.yield b => do let a ← ForInStep.bindList f tail✝ (ForInStep.yield b) pure (ForInStep.run a)) = fun x => do let a ← ForInStep.bindList f tail✝ x pure (ForInStep.run a) ** ext (b | b) <;> simp ** Qed
| |
List.forM_append ** m : Type u_1 → Type u_2 α : Type u_3 inst✝¹ : Monad m inst✝ : LawfulMonad m l₁ l₂ : List α f : α → m PUnit ⊢ List.forM (l₁ ++ l₂) f = do List.forM l₁ f List.forM l₂ f ** induction l₁ <;> simp [*] ** Qed
| |
List.diff_cons ** α : Type u_1 inst✝ : DecidableEq α l₁ l₂ : List α a : α ⊢ List.diff l₁ (a :: l₂) = List.diff (List.erase l₁ a) l₂ ** simp [List.diff] ** α : Type u_1 inst✝ : DecidableEq α l₁ l₂ : List α a : α ⊢ (if a ∈ l₁ then List.diff (List.erase l₁ a) l₂ else List.diff l₁ l₂) = List.diff (List.erase l₁ a) l₂ ** split <;> simp [*, erase_of_not_mem] ** Qed
| |
List.diff_cons_right ** α : Type u_1 inst✝ : DecidableEq α l₁ l₂ : List α a : α ⊢ List.diff l₁ (a :: l₂) = List.erase (List.diff l₁ l₂) a ** apply Eq.symm ** case h α : Type u_1 inst✝ : DecidableEq α l₁ l₂ : List α a : α ⊢ List.erase (List.diff l₁ l₂) a = List.diff l₁ (a :: l₂) ** induction l₂ generalizing l₁ <;> simp [erase_comm, *] ** Qed
| |
List.nil_diff ** α : Type u_1 inst✝ : DecidableEq α l : List α ⊢ List.diff [] l = [] ** induction l <;> simp [*, erase_of_not_mem] ** Qed
| |
List.cons_diff ** α : Type u_1 inst✝ : DecidableEq α a : α l₁ l₂ : List α ⊢ List.diff (a :: l₁) l₂ = if a ∈ l₂ then List.diff l₁ (List.erase l₂ a) else a :: List.diff l₁ l₂ ** induction l₂ generalizing l₁ with
| nil => rfl
| cons b l₂ ih => by_cases h : a = b <;> simp [*, eq_comm] ** case nil α : Type u_1 inst✝ : DecidableEq α a : α l₁ : List α ⊢ List.diff (a :: l₁) [] = if a ∈ [] then List.diff l₁ (List.erase [] a) else a :: List.diff l₁ [] ** rfl ** case cons α : Type u_1 inst✝ : DecidableEq α a b : α l₂ : List α ih : ∀ (l₁ : List α), List.diff (a :: l₁) l₂ = if a ∈ l₂ then List.diff l₁ (List.erase l₂ a) else a :: List.diff l₁ l₂ l₁ : List α ⊢ List.diff (a :: l₁) (b :: l₂) = if a ∈ b :: l₂ then List.diff l₁ (List.erase (b :: l₂) a) else a :: List.diff l₁ (b :: l₂) ** by_cases h : a = b <;> simp [*, eq_comm] ** Qed
| |
List.cons_diff_of_mem ** α : Type u_1 inst✝ : DecidableEq α a : α l₂ : List α h : a ∈ l₂ l₁ : List α ⊢ List.diff (a :: l₁) l₂ = List.diff l₁ (List.erase l₂ a) ** rw [cons_diff, if_pos h] ** Qed
| |
List.cons_diff_of_not_mem ** α : Type u_1 inst✝ : DecidableEq α a : α l₂ : List α h : ¬a ∈ l₂ l₁ : List α ⊢ List.diff (a :: l₁) l₂ = a :: List.diff l₁ l₂ ** rw [cons_diff, if_neg h] ** Qed
| |
List.diff_append ** α : Type u_1 inst✝ : DecidableEq α l₁ l₂ l₃ : List α ⊢ List.diff l₁ (l₂ ++ l₃) = List.diff (List.diff l₁ l₂) l₃ ** simp only [diff_eq_foldl, foldl_append] ** Qed
| |
List.mem_diff_of_mem ** α : Type u_1 inst✝ : DecidableEq α a : α l₁ : List α b : α l₂ : List α h₁ : a ∈ l₁ h₂ : ¬a ∈ b :: l₂ ⊢ a ∈ List.diff l₁ (b :: l₂) ** rw [diff_cons] ** α : Type u_1 inst✝ : DecidableEq α a : α l₁ : List α b : α l₂ : List α h₁ : a ∈ l₁ h₂ : ¬a ∈ b :: l₂ ⊢ a ∈ List.diff (List.erase l₁ b) l₂ ** exact mem_diff_of_mem ((mem_erase_of_ne <| ne_of_not_mem_cons h₂).2 h₁) (mt (.tail _) h₂) ** Qed
| |
List.Sublist.diff_right ** α : Type u_1 inst✝ : DecidableEq α l₁ l₂ : List α a : α l₃ : List α h : l₁ <+ l₂ ⊢ List.diff l₁ (a :: l₃) <+ List.diff l₂ (a :: l₃) ** simp only [diff_cons, (h.erase _).diff_right] ** Qed
| |
List.Sublist.erase_diff_erase_sublist ** α : Type u_1 inst✝ : DecidableEq α a b : α l₁ l₂ : List α h : b :: l₁ <+ l₂ ⊢ List.diff (List.erase l₂ a) (List.erase (b :: l₁) a) <+ List.diff l₂ (b :: l₁) ** if heq : b = a then
simp [heq]
else
simp [heq, erase_comm a]
exact (erase_cons_head b _ ▸ h.erase b).erase_diff_erase_sublist ** α : Type u_1 inst✝ : DecidableEq α a b : α l₁ l₂ : List α h : b :: l₁ <+ l₂ heq : b = a ⊢ List.diff (List.erase l₂ a) (List.erase (b :: l₁) a) <+ List.diff l₂ (b :: l₁) ** simp [heq] ** α : Type u_1 inst✝ : DecidableEq α a b : α l₁ l₂ : List α h : b :: l₁ <+ l₂ heq : ¬b = a ⊢ List.diff (List.erase l₂ a) (List.erase (b :: l₁) a) <+ List.diff l₂ (b :: l₁) ** simp [heq, erase_comm a] ** α : Type u_1 inst✝ : DecidableEq α a b : α l₁ l₂ : List α h : b :: l₁ <+ l₂ heq : ¬b = a ⊢ List.diff (List.erase (List.erase l₂ b) a) (List.erase l₁ a) <+ List.diff (List.erase l₂ b) l₁ ** exact (erase_cons_head b _ ▸ h.erase b).erase_diff_erase_sublist ** Qed
| |
List.infix_append' ** α : Type u_1 l₁ l₂ l₃ : List α ⊢ l₂ <:+: l₁ ++ (l₂ ++ l₃) ** rw [← List.append_assoc] ** α : Type u_1 l₁ l₂ l₃ : List α ⊢ l₂ <:+: l₁ ++ l₂ ++ l₃ ** apply infix_append ** Qed
| |
List.IsSuffix.isInfix ** α✝ : Type u_1 l₁ l₂ : List α✝ x✝ : l₁ <:+ l₂ t : List α✝ h : t ++ l₁ = l₂ ⊢ t ++ l₁ ++ [] = l₂ ** rw [h, append_nil] ** Qed
| |
List.infix_concat ** α✝ : Type u_1 l₁ l₂ : List α✝ a : α✝ x✝ : l₁ <:+: l₂ L₁ L₂ : List α✝ h : L₁ ++ l₁ ++ L₂ = l₂ ⊢ L₁ ++ l₁ ++ concat L₂ a = concat l₂ a ** simp [← h, concat_eq_append, append_assoc] ** Qed
| |
List.IsInfix.trans ** α : Type u_1 l l₁ r₁ l₂ r₂ : List α ⊢ l₂ ++ l₁ ++ l ++ (r₁ ++ r₂) = l₂ ++ (l₁ ++ l ++ r₁) ++ r₂ ** simp only [append_assoc] ** Qed
| |
List.reverse_suffix ** α✝ : Type u_1 l₁ l₂ : List α✝ x✝ : reverse l₁ <:+ reverse l₂ r : List α✝ e : r ++ reverse l₁ = reverse l₂ ⊢ l₁ ++ reverse r = l₂ ** rw [← reverse_reverse l₁, ← reverse_append, e, reverse_reverse] ** α✝ : Type u_1 l₁ l₂ : List α✝ x✝ : l₁ <+: l₂ r : List α✝ e : l₁ ++ r = l₂ ⊢ reverse r ++ reverse l₁ = reverse l₂ ** rw [← reverse_append, e] ** Qed
| |
List.reverse_prefix ** α✝ : Type u_1 l₁ l₂ : List α✝ ⊢ reverse l₁ <+: reverse l₂ ↔ l₁ <:+ l₂ ** rw [← reverse_suffix] ** α✝ : Type u_1 l₁ l₂ : List α✝ ⊢ reverse (reverse l₁) <:+ reverse (reverse l₂) ↔ l₁ <:+ l₂ ** simp only [reverse_reverse] ** Qed
| |
List.reverse_infix ** α✝ : Type u_1 l₁ l₂ : List α✝ ⊢ reverse l₁ <:+: reverse l₂ ↔ l₁ <:+: l₂ ** refine ⟨fun ⟨s, t, e⟩ => ⟨reverse t, reverse s, ?_⟩, fun ⟨s, t, e⟩ => ⟨reverse t, reverse s, ?_⟩⟩ ** case refine_1 α✝ : Type u_1 l₁ l₂ : List α✝ x✝ : reverse l₁ <:+: reverse l₂ s t : List α✝ e : s ++ reverse l₁ ++ t = reverse l₂ ⊢ reverse t ++ l₁ ++ reverse s = l₂ ** rw [← reverse_reverse l₁, append_assoc, ← reverse_append, ← reverse_append, e,
reverse_reverse] ** case refine_2 α✝ : Type u_1 l₁ l₂ : List α✝ x✝ : l₁ <:+: l₂ s t : List α✝ e : s ++ l₁ ++ t = l₂ ⊢ reverse t ++ reverse l₁ ++ reverse s = reverse l₂ ** rw [append_assoc, ← reverse_append, ← reverse_append, e] ** Qed
| |
List.prefix_of_prefix_length_le ** α : Type u_1 a : α l₁ : List α b : α l₂ r₁ r₂ : List α e : b :: l₂ ++ r₂ = a :: l₁ ++ r₁ ll : length (a :: l₁) ≤ length (b :: l₂) ⊢ a :: l₁ <+: b :: l₂ ** injection e with _ e' ** α : Type u_1 a : α l₁ : List α b : α l₂ r₁ r₂ : List α ll : length (a :: l₁) ≤ length (b :: l₂) head_eq✝ : b = a e' : List.append l₂ r₂ = List.append l₁ r₁ ⊢ a :: l₁ <+: b :: l₂ ** subst b ** α : Type u_1 a : α l₁ l₂ r₁ r₂ : List α e' : List.append l₂ r₂ = List.append l₁ r₁ ll : length (a :: l₁) ≤ length (a :: l₂) ⊢ a :: l₁ <+: a :: l₂ ** rcases prefix_of_prefix_length_le ⟨_, rfl⟩ ⟨_, e'⟩ (le_of_succ_le_succ ll) with ⟨r₃, rfl⟩ ** case intro α : Type u_1 a : α l₁ r₁ r₂ r₃ : List α e' : List.append (l₁ ++ r₃) r₂ = List.append l₁ r₁ ll : length (a :: l₁) ≤ length (a :: (l₁ ++ r₃)) ⊢ a :: l₁ <+: a :: (l₁ ++ r₃) ** exact ⟨r₃, rfl⟩ ** Qed
| |
List.suffix_of_suffix_length_le ** α✝ : Type u_1 l₁ l₃ l₂ : List α✝ h₁ : l₁ <:+ l₃ h₂ : l₂ <:+ l₃ ll : length l₁ ≤ length l₂ ⊢ length (reverse l₁) ≤ length (reverse l₂) ** simp [ll] ** Qed
| |
List.suffix_cons_iff ** α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ ⊢ l₁ <:+ a :: l₂ ↔ l₁ = a :: l₂ ∨ l₁ <:+ l₂ ** constructor ** case mp α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ ⊢ l₁ <:+ a :: l₂ → l₁ = a :: l₂ ∨ l₁ <:+ l₂ ** rintro ⟨⟨hd, tl⟩, hl₃⟩ ** case mp.intro.nil α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ hl₃ : [] ++ l₁ = a :: l₂ ⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂ ** exact Or.inl hl₃ ** case mp.intro.cons α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ head✝ : α✝ tail✝ : List α✝ hl₃ : head✝ :: tail✝ ++ l₁ = a :: l₂ ⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂ ** simp only [cons_append] at hl₃ ** case mp.intro.cons α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ head✝ : α✝ tail✝ : List α✝ hl₃ : head✝ :: (tail✝ ++ l₁) = a :: l₂ ⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂ ** injection hl₃ with _ hl₄ ** case mp.intro.cons α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ head✝ : α✝ tail✝ : List α✝ head_eq✝ : head✝ = a hl₄ : tail✝ ++ l₁ = l₂ ⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂ ** exact Or.inr ⟨_, hl₄⟩ ** case mpr α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ ⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂ → l₁ <:+ a :: l₂ ** rintro (rfl | hl₁) ** case mpr.inl α✝ : Type u_1 a : α✝ l₂ : List α✝ ⊢ a :: l₂ <:+ a :: l₂ ** exact (a :: l₂).suffix_refl ** case mpr.inr α✝ : Type u_1 l₁ : List α✝ a : α✝ l₂ : List α✝ hl₁ : l₁ <:+ l₂ ⊢ l₁ <:+ a :: l₂ ** exact hl₁.trans (l₂.suffix_cons _) ** Qed
| |
List.prefix_append_right_inj ** α✝ : Type u_1 l₁ l₂ l r : List α✝ ⊢ l ++ l₁ ++ r = l ++ l₂ ↔ l₁ ++ r = l₂ ** rw [append_assoc, append_right_inj] ** Qed
| |
List.IsSuffix.filter ** α : Type u_1 p : α → Bool l₁ l₂ : List α h : l₁ <:+ l₂ ⊢ List.filter p l₁ <:+ List.filter p l₂ ** obtain ⟨xs, rfl⟩ := h ** case intro α : Type u_1 p : α → Bool l₁ xs : List α ⊢ List.filter p l₁ <:+ List.filter p (xs ++ l₁) ** rw [filter_append] ** case intro α : Type u_1 p : α → Bool l₁ xs : List α ⊢ List.filter p l₁ <:+ List.filter p xs ++ List.filter p l₁ ** apply suffix_append ** Qed
| |
List.IsInfix.filter ** α : Type u_1 p : α → Bool l₁ l₂ : List α h : l₁ <:+: l₂ ⊢ List.filter p l₁ <:+: List.filter p l₂ ** obtain ⟨xs, ys, rfl⟩ := h ** case intro.intro α : Type u_1 p : α → Bool l₁ xs ys : List α ⊢ List.filter p l₁ <:+: List.filter p (xs ++ l₁ ++ ys) ** rw [filter_append, filter_append] ** case intro.intro α : Type u_1 p : α → Bool l₁ xs ys : List α ⊢ List.filter p l₁ <:+: List.filter p xs ++ List.filter p l₁ ++ List.filter p ys ** apply infix_append _ ** Qed
| |
List.takeWhile_append_dropWhile ** α : Type u_1 p : α → Bool x : α xs : List α ⊢ takeWhile p (x :: xs) ++ dropWhile p (x :: xs) = x :: xs ** simp [takeWhile, dropWhile] ** α : Type u_1 p : α → Bool x : α xs : List α ⊢ ((match p x with | true => x :: takeWhile p xs | false => []) ++ match p x with | true => dropWhile p xs | false => x :: xs) = x :: xs ** cases p x <;> simp [takeWhile_append_dropWhile p xs] ** Qed
| |
List.chain_cons ** α : Type u_1 R : α → α → Prop a b : α l : List α p : Chain R a (b :: l) ⊢ R a b ∧ Chain R b l ** cases p with | cons n p => exact ⟨n, p⟩ ** case cons α : Type u_1 R : α → α → Prop a b : α l : List α n : R a b p : Chain R b l ⊢ R a b ∧ Chain R b l ** exact ⟨n, p⟩ ** Qed
| |
List.Chain.imp' ** case nil α : Type u_1 R S : α → α → Prop HRS : ∀ ⦃a b : α⦄, R a b → S a b a : α l : List α a✝ b : α Hab : ∀ ⦃c : α⦄, R a✝ c → S b c ⊢ Chain S b [] ** constructor ** case cons α : Type u_1 R S : α → α → Prop HRS : ∀ ⦃a b : α⦄, R a b → S a b a : α l : List α a✝¹ b✝ : α l✝ : List α r : R a✝¹ b✝ a✝ : Chain R b✝ l✝ ih : ∀ {b : α}, (∀ ⦃c : α⦄, R b✝ c → S b c) → Chain S b l✝ b : α Hab : ∀ ⦃c : α⦄, R a✝¹ c → S b c ⊢ Chain S b (b✝ :: l✝) ** constructor ** case cons.a α : Type u_1 R S : α → α → Prop HRS : ∀ ⦃a b : α⦄, R a b → S a b a : α l : List α a✝¹ b✝ : α l✝ : List α r : R a✝¹ b✝ a✝ : Chain R b✝ l✝ ih : ∀ {b : α}, (∀ ⦃c : α⦄, R b✝ c → S b c) → Chain S b l✝ b : α Hab : ∀ ⦃c : α⦄, R a✝¹ c → S b c ⊢ S b b✝ ** exact Hab r ** case cons.a α : Type u_1 R S : α → α → Prop HRS : ∀ ⦃a b : α⦄, R a b → S a b a : α l : List α a✝¹ b✝ : α l✝ : List α r : R a✝¹ b✝ a✝ : Chain R b✝ l✝ ih : ∀ {b : α}, (∀ ⦃c : α⦄, R b✝ c → S b c) → Chain S b l✝ b : α Hab : ∀ ⦃c : α⦄, R a✝¹ c → S b c ⊢ Chain S b✝ l✝ ** exact ih (@HRS _) ** Qed
| |
List.Pairwise.chain ** α✝ : Type u_1 R : α✝ → α✝ → Prop a : α✝ l : List α✝ p : Pairwise R (a :: l) ⊢ Chain R a l ** let ⟨r, p'⟩ := pairwise_cons.1 p ** α✝ : Type u_1 R : α✝ → α✝ → Prop a : α✝ l : List α✝ p : Pairwise R (a :: l) r : ∀ (a' : α✝), a' ∈ l → R a a' p' : Pairwise R l ⊢ Chain R a l ** clear p ** α✝ : Type u_1 R : α✝ → α✝ → Prop a : α✝ l : List α✝ r : ∀ (a' : α✝), a' ∈ l → R a a' p' : Pairwise R l ⊢ Chain R a l ** induction p' generalizing a with
| nil => exact Chain.nil
| @cons b l r' _ IH =>
simp only [chain_cons, forall_mem_cons] at r
exact chain_cons.2 ⟨r.1, IH r'⟩ ** case nil α✝ : Type u_1 R : α✝ → α✝ → Prop l : List α✝ a : α✝ r : ∀ (a' : α✝), a' ∈ [] → R a a' ⊢ Chain R a [] ** exact Chain.nil ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop l✝ : List α✝ b : α✝ l : List α✝ r' : ∀ (a' : α✝), a' ∈ l → R b a' a✝ : Pairwise R l IH : ∀ {a : α✝}, (∀ (a' : α✝), a' ∈ l → R a a') → Chain R a l a : α✝ r : ∀ (a' : α✝), a' ∈ b :: l → R a a' ⊢ Chain R a (b :: l) ** simp only [chain_cons, forall_mem_cons] at r ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop l✝ : List α✝ b : α✝ l : List α✝ r' : ∀ (a' : α✝), a' ∈ l → R b a' a✝ : Pairwise R l IH : ∀ {a : α✝}, (∀ (a' : α✝), a' ∈ l → R a a') → Chain R a l a : α✝ r : R a b ∧ ∀ (x : α✝), x ∈ l → R a x ⊢ Chain R a (b :: l) ** exact chain_cons.2 ⟨r.1, IH r'⟩ ** Qed
| |
List.range'_eq_nil ** s n step : Nat ⊢ range' s n step = [] ↔ n = 0 ** rw [← length_eq_zero, length_range'] ** Qed
| |
List.mem_range' ** m s step : Nat ⊢ m ∈ range' s 0 step ↔ ∃ i, i < 0 ∧ m = s + step * i ** simp [range', Nat.not_lt_zero] ** m s step n : Nat ⊢ m ∈ range' s (n + 1) step ↔ ∃ i, i < n + 1 ∧ m = s + step * i ** have h (i) : i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n := by cases i <;> simp [Nat.succ_le] ** m s step n : Nat h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n ⊢ m ∈ range' s (n + 1) step ↔ ∃ i, i < n + 1 ∧ m = s + step * i ** simp [range', mem_range', Nat.lt_succ, h] ** m s step n : Nat h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n ⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a, (∃ j, a = succ j ∧ j < n) ∧ m = s + step * a ** simp only [← exists_and_right, and_assoc] ** m s step n : Nat h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n ⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a x, a = succ x ∧ x < n ∧ m = s + step * a ** rw [exists_comm] ** m s step n : Nat h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n ⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ b a, a = succ b ∧ b < n ∧ m = s + step * a ** simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm] ** m s step n i : Nat ⊢ i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n ** cases i <;> simp [Nat.succ_le] ** Qed
| |
List.mem_range'_1 ** m s n : Nat ⊢ m ∈ range' s n ↔ s ≤ m ∧ m < s + n ** simp [mem_range'] ** m s n : Nat ⊢ (∃ i, i < n ∧ m = s + i) ↔ s ≤ m ∧ m < s + n ** exact ⟨
fun ⟨i, h, e⟩ => e ▸ ⟨Nat.le_add_right .., Nat.add_lt_add_left h _⟩,
fun ⟨h₁, h₂⟩ => ⟨m - s, Nat.sub_lt_left_of_lt_add h₁ h₂, (Nat.add_sub_cancel' h₁).symm⟩⟩ ** Qed
| |
List.map_add_range' ** a s n step : Nat ⊢ map (fun x => a + x) (range' s (n + 1) step) = range' (a + s) (n + 1) step ** simp [range', map_add_range' _ (s + step) n step, Nat.add_assoc] ** Qed
| |
List.map_sub_range' ** step a s n : Nat h : a ≤ s ⊢ map (fun x => x - a) (range' s n step) = range' (s - a) n step ** conv => lhs; rw [← Nat.add_sub_cancel' h] ** step a s n : Nat h : a ≤ s ⊢ map (fun x => x - a) (range' (a + (s - a)) n step) = range' (s - a) n step ** rw [← map_add_range', map_map, (?_ : _∘_ = _), map_id] ** step a s n : Nat h : a ≤ s ⊢ ((fun x => x - a) ∘ fun x => a + x) = id ** funext x ** case h step a s n : Nat h : a ≤ s x : Nat ⊢ ((fun x => x - a) ∘ fun x => a + x) x = id x ** apply Nat.add_sub_cancel_left ** Qed
| |
List.range'_append ** s m n step : Nat ⊢ range' s (m + 1) step ++ range' (s + step * (m + 1)) n step = range' s (n + (m + 1)) step ** simpa [range', Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
using range'_append (s + step) m n step ** Qed
| |
List.range'_append_1 ** s m n : Nat ⊢ range' s m ++ range' (s + m) n = range' s (n + m) ** simpa using range'_append s m n 1 ** Qed
| |
List.range'_sublist_right ** step s m n : Nat h : range' s m step <+ range' s n step ⊢ m ≤ n ** simpa only [length_range'] using h.length_le ** step s m n : Nat h : m ≤ n ⊢ range' s m step <+ range' s n step ** rw [← Nat.sub_add_cancel h, ← range'_append] ** step s m n : Nat h : m ≤ n ⊢ range' s m step <+ range' s m step ++ range' (s + step * m) (n - m) step ** apply sublist_append_left ** Qed
| |
List.range'_subset_right ** step s m n : Nat step0 : 0 < step ⊢ range' s m step ⊆ range' s n step ↔ m ≤ n ** refine ⟨fun h => Nat.le_of_not_lt fun hn => ?_, fun h => (range'_sublist_right.2 h).subset⟩ ** step s m n : Nat step0 : 0 < step h : range' s m step ⊆ range' s n step hn : n < m ⊢ False ** have ⟨i, h', e⟩ := mem_range'.1 <| h <| mem_range'.2 ⟨_, hn, rfl⟩ ** step s m n : Nat step0 : 0 < step h : range' s m step ⊆ range' s n step hn : n < m i : Nat h' : i < n e : s + step * n = s + step * i ⊢ False ** exact Nat.ne_of_gt h' (Nat.eq_of_mul_eq_mul_left step0 (Nat.add_left_cancel e)) ** Qed
| |
List.range'_subset_right_1 ** s m n : Nat ⊢ 0 < 1 ** decide ** Qed
| |
List.get?_range' ** s step m n : Nat h : m + 1 < n + 1 ⊢ some (s + step + step * m) = some (s + step * (m + 1)) ** simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm] ** Qed
| |
List.get_range' ** n m step i : Nat H : i < length (range' n m step) ⊢ i < m ** simpa using H ** Qed
| |
List.range'_concat ** step s n : Nat ⊢ range' s (n + 1) step = range' s n step ++ [s + step * n] ** rw [Nat.add_comm n 1] ** step s n : Nat ⊢ range' s (1 + n) step = range' s n step ++ [s + step * n] ** exact (range'_append s n 1 step).symm ** Qed
| |
List.range'_1_concat ** s n : Nat ⊢ range' s (n + 1) = range' s n ++ [s + n] ** simp [range'_concat] ** Qed
| |
List.range_succ_eq_map ** n : Nat ⊢ range (n + 1) = 0 :: map succ (range n) ** rw [range_eq_range', range_eq_range', range', Nat.add_comm, ← map_add_range'] ** n : Nat ⊢ 0 :: map (fun x => 1 + x) (range' 0 n) = 0 :: map succ (range' 0 n) ** congr ** case e_tail.e_f n : Nat ⊢ (fun x => 1 + x) = succ ** exact funext one_add ** Qed
| |
List.range'_eq_map_range ** s n : Nat ⊢ range' s n = map (fun x => s + x) (range n) ** rw [range_eq_range', map_add_range'] ** s n : Nat ⊢ range' s n = range' (s + 0) n ** rfl ** Qed
| |
List.length_range ** n : Nat ⊢ length (range n) = n ** simp only [range_eq_range', length_range'] ** Qed
| |
List.range_eq_nil ** n : Nat ⊢ range n = [] ↔ n = 0 ** rw [← length_eq_zero, length_range] ** Qed
| |
List.range_sublist ** m n : Nat ⊢ range m <+ range n ↔ m ≤ n ** simp only [range_eq_range', range'_sublist_right] ** Qed
| |
List.range_subset ** m n : Nat ⊢ range m ⊆ range n ↔ m ≤ n ** simp only [range_eq_range', range'_subset_right] ** Qed
| |
List.not_mem_range_self ** n : Nat ⊢ ¬n ∈ range n ** simp ** Qed
| |
List.self_mem_range_succ ** n : Nat ⊢ n ∈ range (n + 1) ** simp ** Qed
| |
List.get?_range ** m n : Nat h : m < n ⊢ get? (range n) m = some m ** simp [range_eq_range', get?_range' _ _ h] ** Qed
| |
List.range_succ ** n : Nat ⊢ range (succ n) = range n ++ [n] ** simp only [range_eq_range', range'_1_concat, Nat.zero_add] ** Qed
| |
List.iota_eq_reverse_range' ** n : Nat ⊢ iota (n + 1) = reverse (range' 1 (n + 1)) ** simp [iota, range'_concat, iota_eq_reverse_range' n, reverse_append, Nat.add_comm] ** Qed
| |
List.length_iota ** n : Nat ⊢ length (iota n) = n ** simp [iota_eq_reverse_range'] ** Qed
| |
List.mem_iota ** m n : Nat ⊢ m ∈ iota n ↔ 1 ≤ m ∧ m ≤ n ** simp [iota_eq_reverse_range', Nat.add_comm, Nat.lt_succ] ** Qed
| |
List.reverse_range' ** s n : Nat ⊢ reverse (range' s (n + 1)) = map (fun x => s + (n + 1) - 1 - x) (range (n + 1)) ** rw [range'_1_concat, reverse_append, range_succ_eq_map,
show s + (n + 1) - 1 = s + n from rfl, map, map_map] ** s n : Nat ⊢ reverse [s + n] ++ reverse (range' s n) = (s + n - 0) :: map ((fun x => s + n - x) ∘ succ) (range n) ** simp [reverse_range', Nat.sub_right_comm] ** s n : Nat ⊢ map (fun x => s + n - x - 1) (range n) = map ((fun x => s + n - x) ∘ succ) (range n) ** rfl ** Qed
| |
List.get_range ** n i : Nat H : i < length (range n) ⊢ some (get (range n) { val := i, isLt := H }) = some i ** rw [← get?_eq_get _, get?_range (by simpa using H)] ** n i : Nat H : i < length (range n) ⊢ i < n ** simpa using H ** Qed
| |
List.enum_map_fst ** α : Type u_1 l : List α ⊢ map Prod.fst (enum l) = range (length l) ** simp only [enum, enumFrom_map_fst, range_eq_range'] ** Qed
| |
LawfulMonad.mk' ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ α β : Type u g : α → β x : α ⊢ g <$> pure x = pure (g x) ** rw [← bind_pure_comp] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ α β : Type u g : α → β x : α ⊢ (do let y ← pure x pure (g y)) = pure (g x) ** simp [pure_bind] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) ⊢ ∀ {α β γ : Type u} (g : α → β) (h : β → γ) (x : m α), (h ∘ g) <$> x = h <$> g <$> x ** simp [← bind_pure_comp, bind_assoc, pure_bind] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) ⊢ ∀ {α β : Type u} (g : α → β) (x : m α), (Seq.seq (pure g) fun x_1 => x) = g <$> x ** intros ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) α✝ β✝ : Type u g✝ : α✝ → β✝ x✝ : m α✝ ⊢ (Seq.seq (pure g✝) fun x => x✝) = g✝ <$> x✝ ** rw [← bind_map] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) α✝ β✝ : Type u g✝ : α✝ → β✝ x✝ : m α✝ ⊢ (do let x ← pure g✝ x <$> x✝) = g✝ <$> x✝ ** simp [pure_bind] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) ⊢ ∀ {α β : Type u} (g : m (α → β)) (x : α), (Seq.seq g fun x_1 => pure x) = (fun h => h x) <$> g ** intros ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) α✝ β✝ : Type u g✝ : m (α✝ → β✝) x✝ : α✝ ⊢ (Seq.seq g✝ fun x => pure x✝) = (fun h => h x✝) <$> g✝ ** rw [← bind_map] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) α✝ β✝ : Type u g✝ : m (α✝ → β✝) x✝ : α✝ ⊢ (do let x ← g✝ x <$> pure x✝) = (fun h => h x✝) <$> g✝ ** simp [map_pure, bind_pure_comp] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) ⊢ ∀ {α β γ : Type u} (x : m α) (g : m (α → β)) (h : m (β → γ)), (Seq.seq h fun x_1 => Seq.seq g fun x_2 => x) = Seq.seq (Seq.seq (Function.comp <$> h) fun x => g) fun x_1 => x ** simp [← bind_pure_comp, ← bind_map, bind_assoc, pure_bind] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) ⊢ ∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = Seq.seq (Function.const β <$> x) fun x => y ** simp [seqLeft_eq, ← bind_map, ← bind_pure_comp, pure_bind, bind_assoc] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) α✝ β✝ : Type u x : m α✝ y : m β✝ ⊢ (SeqRight.seqRight x fun x => y) = Seq.seq (Function.const α✝ id <$> x) fun x => y ** rw [seqRight_eq, ← bind_map, ← bind_pure_comp, bind_assoc] ** m : Type u → Type v inst✝ : Monad m id_map : ∀ {α : Type u} (x : m α), id <$> x = x pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g map_const : autoParam (∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y) _auto✝ seqLeft_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqLeft.seqLeft x fun x => y) = do let a ← x let _ ← y pure a) _auto✝ seqRight_eq : autoParam (∀ {α β : Type u} (x : m α) (y : m β), (SeqRight.seqRight x fun x => y) = do let _ ← x y) _auto✝ bind_pure_comp : autoParam (∀ {α β : Type u} (f : α → β) (x : m α), (do let y ← x pure (f y)) = f <$> x) _auto✝ bind_map : autoParam (∀ {α β : Type u} (f : m (α → β)) (x : m α), (do let x_1 ← f x_1 <$> x) = Seq.seq f fun x_1 => x) _auto✝ map_pure : ∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x) α✝ β✝ : Type u x : m α✝ y : m β✝ ⊢ (do let _ ← x y) = do let x ← x let x ← pure (Function.const α✝ id x) x <$> y ** simp [pure_bind, id_map] ** Qed
| |
SatisfiesM.of_true ** m : Type u_1 → Type u_2 α : Type u_1 p : α → Prop inst✝¹ : Applicative m inst✝ : LawfulApplicative m x : m α h : ∀ (a : α), p a ⊢ Subtype.val <$> (fun a => { val := a, property := (_ : p a) }) <$> x = x ** simp [← comp_map, Function.comp] ** Qed
| |
SatisfiesM.imp ** m : Type u_1 → Type u_2 α : Type u_1 p q : α → Prop inst✝¹ : Functor m inst✝ : LawfulFunctor m x✝ : m α h✝ : SatisfiesM p x✝ H : ∀ {a : α}, p a → q a x : m { a // p a } h : Subtype.val <$> x = x✝ ⊢ Subtype.val <$> (fun x => match x with | { val := a, property := h } => { val := a, property := (_ : q a) }) <$> x = x✝ ** rw [← h, ← comp_map] ** m : Type u_1 → Type u_2 α : Type u_1 p q : α → Prop inst✝¹ : Functor m inst✝ : LawfulFunctor m x✝ : m α h✝ : SatisfiesM p x✝ H : ∀ {a : α}, p a → q a x : m { a // p a } h : Subtype.val <$> x = x✝ ⊢ (Subtype.val ∘ fun x => match x with | { val := a, property := h } => { val := a, property := (_ : q a) }) <$> x = Subtype.val <$> x ** rfl ** Qed
| |
SatisfiesM.map ** m : Type u_1 → Type u_2 α : Type u_1 p : α → Prop α✝ : Type u_1 q : α✝ → Prop f : α → α✝ inst✝¹ : Functor m inst✝ : LawfulFunctor m x : m α hx : SatisfiesM p x hf : ∀ {a : α}, p a → q (f a) ⊢ SatisfiesM q (f <$> x) ** let ⟨x', hx⟩ := hx ** m : Type u_1 → Type u_2 α : Type u_1 p : α → Prop α✝ : Type u_1 q : α✝ → Prop f : α → α✝ inst✝¹ : Functor m inst✝ : LawfulFunctor m x : m α hx✝ : SatisfiesM p x hf : ∀ {a : α}, p a → q (f a) x' : m { a // p a } hx : Subtype.val <$> x' = x ⊢ SatisfiesM q (f <$> x) ** refine ⟨(fun ⟨a, h⟩ => ⟨f a, hf h⟩) <$> x', ?_⟩ ** m : Type u_1 → Type u_2 α : Type u_1 p : α → Prop α✝ : Type u_1 q : α✝ → Prop f : α → α✝ inst✝¹ : Functor m inst✝ : LawfulFunctor m x : m α hx✝ : SatisfiesM p x hf : ∀ {a : α}, p a → q (f a) x' : m { a // p a } hx : Subtype.val <$> x' = x ⊢ Subtype.val <$> (fun x => match x with | { val := a, property := h } => { val := f a, property := (_ : q (f a)) }) <$> x' = f <$> x ** rw [← hx] ** m : Type u_1 → Type u_2 α : Type u_1 p : α → Prop α✝ : Type u_1 q : α✝ → Prop f : α → α✝ inst✝¹ : Functor m inst✝ : LawfulFunctor m x : m α hx✝ : SatisfiesM p x hf : ∀ {a : α}, p a → q (f a) x' : m { a // p a } hx : Subtype.val <$> x' = x ⊢ Subtype.val <$> (fun x => match x with | { val := a, property := h } => { val := f a, property := (_ : q (f a)) }) <$> x' = f <$> Subtype.val <$> x' ** simp [← comp_map, Function.comp] ** Qed
| |
SatisfiesM.pure ** m : Type u_1 → Type u_2 α✝ : Type u_1 p : α✝ → Prop a : α✝ inst✝¹ : Applicative m inst✝ : LawfulApplicative m h : p a ⊢ Subtype.val <$> pure { val := a, property := h } = pure a ** simp ** Qed
| |
SatisfiesM.seq ** m : Type u_1 → Type u_2 α α✝ : Type u_1 p₁ : (α → α✝) → Prop f : m (α → α✝) p₂ : α → Prop q : α✝ → Prop inst✝¹ : Applicative m inst✝ : LawfulApplicative m x : m α hf : SatisfiesM p₁ f hx : SatisfiesM p₂ x H : ∀ {f : α → α✝} {a : α}, p₁ f → p₂ a → q (f a) ⊢ SatisfiesM q (Seq.seq f fun x_1 => x) ** match f, x, hf, hx with | _, _, ⟨f, rfl⟩, ⟨x, rfl⟩ => ?_ ** m : Type u_1 → Type u_2 α α✝ : Type u_1 p₁ : (α → α✝) → Prop f✝ : m (α → α✝) p₂ : α → Prop q : α✝ → Prop inst✝¹ : Applicative m inst✝ : LawfulApplicative m x✝ : m α hf : SatisfiesM p₁ f✝ hx : SatisfiesM p₂ x✝ H : ∀ {f : α → α✝} {a : α}, p₁ f → p₂ a → q (f a) f : m { a // p₁ a } x : m { a // p₂ a } ⊢ SatisfiesM q (Seq.seq (Subtype.val <$> f) fun x_1 => Subtype.val <$> x) ** refine ⟨(fun ⟨a, h₁⟩ ⟨b, h₂⟩ => ⟨a b, H h₁ h₂⟩) <$> f <*> x, ?_⟩ ** m : Type u_1 → Type u_2 α α✝ : Type u_1 p₁ : (α → α✝) → Prop f✝ : m (α → α✝) p₂ : α → Prop q : α✝ → Prop inst✝¹ : Applicative m inst✝ : LawfulApplicative m x✝ : m α hf : SatisfiesM p₁ f✝ hx : SatisfiesM p₂ x✝ H : ∀ {f : α → α✝} {a : α}, p₁ f → p₂ a → q (f a) f : m { a // p₁ a } x : m { a // p₂ a } ⊢ (Subtype.val <$> Seq.seq ((fun x x_1 => match x with | { val := a, property := h₁ } => match x_1 with | { val := b, property := h₂ } => { val := a b, property := (_ : q (a b)) }) <$> f) fun x_1 => x) = Seq.seq (Subtype.val <$> f) fun x_1 => Subtype.val <$> x ** simp only [← pure_seq] ** m : Type u_1 → Type u_2 α α✝ : Type u_1 p₁ : (α → α✝) → Prop f✝ : m (α → α✝) p₂ : α → Prop q : α✝ → Prop inst✝¹ : Applicative m inst✝ : LawfulApplicative m x✝ : m α hf : SatisfiesM p₁ f✝ hx : SatisfiesM p₂ x✝ H : ∀ {f : α → α✝} {a : α}, p₁ f → p₂ a → q (f a) f : m { a // p₁ a } x : m { a // p₂ a } ⊢ (Seq.seq (pure Subtype.val) fun x_1 => Seq.seq (Seq.seq (pure fun x x_2 => { val := Subtype.val x x_2.val, property := (_ : q (Subtype.val x x_2.val)) }) fun x => f) fun x_2 => x) = Seq.seq (Seq.seq (pure Subtype.val) fun x => f) fun x_1 => Seq.seq (pure Subtype.val) fun x_2 => x ** simp [SatisfiesM, seq_assoc] ** m : Type u_1 → Type u_2 α α✝ : Type u_1 p₁ : (α → α✝) → Prop f✝ : m (α → α✝) p₂ : α → Prop q : α✝ → Prop inst✝¹ : Applicative m inst✝ : LawfulApplicative m x✝ : m α hf : SatisfiesM p₁ f✝ hx : SatisfiesM p₂ x✝ H : ∀ {f : α → α✝} {a : α}, p₁ f → p₂ a → q (f a) f : m { a // p₁ a } x : m { a // p₂ a } ⊢ (Seq.seq (Seq.seq (pure (Function.comp Subtype.val ∘ fun x x_1 => { val := Subtype.val x x_1.val, property := (_ : q (Subtype.val x x_1.val)) })) fun x => f) fun x_1 => x) = Seq.seq ((fun h => h Subtype.val) <$> Function.comp <$> Seq.seq (pure Subtype.val) fun x => f) fun x_1 => x ** simp only [← pure_seq] ** m : Type u_1 → Type u_2 α α✝ : Type u_1 p₁ : (α → α✝) → Prop f✝ : m (α → α✝) p₂ : α → Prop q : α✝ → Prop inst✝¹ : Applicative m inst✝ : LawfulApplicative m x✝ : m α hf : SatisfiesM p₁ f✝ hx : SatisfiesM p₂ x✝ H : ∀ {f : α → α✝} {a : α}, p₁ f → p₂ a → q (f a) f : m { a // p₁ a } x : m { a // p₂ a } ⊢ (Seq.seq (Seq.seq (pure (Function.comp Subtype.val ∘ fun x x_1 => { val := Subtype.val x x_1.val, property := (_ : q (Subtype.val x x_1.val)) })) fun x => f) fun x_1 => x) = Seq.seq (Seq.seq (pure fun h => h Subtype.val) fun x => Seq.seq (pure Function.comp) fun x => Seq.seq (pure Subtype.val) fun x => f) fun x_1 => x ** simp [seq_assoc, Function.comp] ** Qed
| |
SatisfiesM.bind ** m : Type u_1 → Type u_2 α β : Type u_1 p : α → Prop x : m α q : β → Prop inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β hx : SatisfiesM p x hf : ∀ (a : α), p a → SatisfiesM q (f a) ⊢ SatisfiesM q (x >>= f) ** match x, hx with | _, ⟨x, rfl⟩ => ?_ ** m : Type u_1 → Type u_2 α β : Type u_1 p : α → Prop x✝ : m α q : β → Prop inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β hx : SatisfiesM p x✝ hf : ∀ (a : α), p a → SatisfiesM q (f a) x : m { a // p a } ⊢ SatisfiesM q (Subtype.val <$> x >>= f) ** have g a ha := Classical.indefiniteDescription _ (hf a ha) ** m : Type u_1 → Type u_2 α β : Type u_1 p : α → Prop x✝ : m α q : β → Prop inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β hx : SatisfiesM p x✝ hf : ∀ (a : α), p a → SatisfiesM q (f a) x : m { a // p a } g : (a : α) → p a → { x // Subtype.val <$> x = f a } ⊢ SatisfiesM q (Subtype.val <$> x >>= f) ** refine ⟨x >>= fun ⟨a, h⟩ => g a h, ?_⟩ ** m : Type u_1 → Type u_2 α β : Type u_1 p : α → Prop x✝ : m α q : β → Prop inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β hx : SatisfiesM p x✝ hf : ∀ (a : α), p a → SatisfiesM q (f a) x : m { a // p a } g : (a : α) → p a → { x // Subtype.val <$> x = f a } ⊢ (Subtype.val <$> do let x ← x match x with | { val := a, property := h } => (g a h).val) = Subtype.val <$> x >>= f ** simp [← bind_pure_comp] ** m : Type u_1 → Type u_2 α β : Type u_1 p : α → Prop x✝ : m α q : β → Prop inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β hx : SatisfiesM p x✝ hf : ∀ (a : α), p a → SatisfiesM q (f a) x : m { a // p a } g : (a : α) → p a → { x // Subtype.val <$> x = f a } ⊢ (do let x ← x let a ← (g x.val (_ : p x.val)).val pure a.val) = do let x ← x f x.val ** congr ** case e_a m : Type u_1 → Type u_2 α β : Type u_1 p : α → Prop x✝ : m α q : β → Prop inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β hx : SatisfiesM p x✝ hf : ∀ (a : α), p a → SatisfiesM q (f a) x : m { a // p a } g : (a : α) → p a → { x // Subtype.val <$> x = f a } ⊢ (fun x => do let a ← (g x.val (_ : p x.val)).val pure a.val) = fun x => f x.val ** funext ⟨a, h⟩ ** case e_a.h m : Type u_1 → Type u_2 α β : Type u_1 p : α → Prop x✝ : m α q : β → Prop inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β hx : SatisfiesM p x✝ hf : ∀ (a : α), p a → SatisfiesM q (f a) x : m { a // p a } g : (a : α) → p a → { x // Subtype.val <$> x = f a } a : α h : p a ⊢ (do let a ← (g { val := a, property := h }.val (_ : p { val := a, property := h }.val)).val pure a.val) = f { val := a, property := h }.val ** simp [← (g a h).2, ← bind_pure_comp] ** Qed
| |
SatisfiesM_Option_eq ** α✝ : Type u_1 p : α✝ → Prop x : Option α✝ ⊢ SatisfiesM p x → ∀ (a : α✝), x = some a → p a ** revert x ** α✝ : Type u_1 p : α✝ → Prop ⊢ ∀ {x : Option α✝}, SatisfiesM p x → ∀ (a : α✝), x = some a → p a ** intro | some _, ⟨some ⟨_, h⟩, rfl⟩, _, rfl => exact h ** α✝ : Type u_1 p : α✝ → Prop x✝³ : Option α✝ x✝² : SatisfiesM p x✝³ x✝¹ : α✝ x✝ : x✝³ = some x✝¹ val✝ : α✝ h : p val✝ ⊢ p { val := val✝, property := h }.val ** exact h ** Qed
| |
SatisfiesM_Except_eq ** ε : Type u_1 α✝ : Type u_2 p : α✝ → Prop x : Except ε α✝ ⊢ SatisfiesM p x → ∀ (a : α✝), x = Except.ok a → p a ** revert x ** ε : Type u_1 α✝ : Type u_2 p : α✝ → Prop ⊢ ∀ {x : Except ε α✝}, SatisfiesM p x → ∀ (a : α✝), x = Except.ok a → p a ** intro | .ok _, ⟨.ok ⟨_, h⟩, rfl⟩, _, rfl => exact h ** ε : Type u_1 α✝ : Type u_2 p : α✝ → Prop x✝³ : Except ε α✝ x✝² : SatisfiesM p x✝³ x✝¹ : α✝ x✝ : x✝³ = Except.ok x✝¹ val✝ : α✝ h : p val✝ ⊢ p { val := val✝, property := h }.val ** exact h ** Qed
| |
SatisfiesM_StateT_eq ** m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : StateT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m ⊢ SatisfiesM p x ↔ ∀ (s : ρ), SatisfiesM (fun x => p x.fst) (x s) ** refine .trans ⟨fun ⟨f, eq⟩ => eq ▸ ?_, fun ⟨f, h⟩ => ?_⟩ Classical.skolem.symm ** case refine_1 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : StateT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : StateT ρ m { a // p a } eq : Subtype.val <$> f = x ⊢ ∃ f_1, ∀ (x : ρ), Subtype.val <$> f_1 x = (Subtype.val <$> f) x ** refine ⟨fun s => (fun ⟨⟨a, h⟩, s'⟩ => ⟨⟨a, s'⟩, h⟩) <$> f s, fun s => ?_⟩ ** case refine_1 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : StateT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : StateT ρ m { a // p a } eq : Subtype.val <$> f = x s : ρ ⊢ Subtype.val <$> (fun s => (fun x => match x with | ({ val := a, property := h }, s') => { val := (a, s'), property := h }) <$> f s) s = (Subtype.val <$> f) s ** rw [← comp_map, map_eq_pure_bind] ** case refine_1 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : StateT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : StateT ρ m { a // p a } eq : Subtype.val <$> f = x s : ρ ⊢ (do let a ← f s pure ((Subtype.val ∘ fun x => match x with | ({ val := a, property := h }, s') => { val := (a, s'), property := h }) a)) = (Subtype.val <$> f) s ** rfl ** case refine_2 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : StateT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : ∃ f, ∀ (x_1 : ρ), Subtype.val <$> f x_1 = x x_1 f : ρ → m { a // (fun x => p x.fst) a } h : ∀ (x_1 : ρ), Subtype.val <$> f x_1 = x x_1 ⊢ SatisfiesM p x ** refine ⟨fun s => (fun ⟨⟨a, s'⟩, h⟩ => ⟨⟨a, h⟩, s'⟩) <$> f s, funext fun s => ?_⟩ ** case refine_2 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : StateT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : ∃ f, ∀ (x_1 : ρ), Subtype.val <$> f x_1 = x x_1 f : ρ → m { a // (fun x => p x.fst) a } h : ∀ (x_1 : ρ), Subtype.val <$> f x_1 = x x_1 s : ρ ⊢ (Subtype.val <$> fun s => (fun x => match x with | { val := (a, s'), property := h } => ({ val := a, property := h }, s')) <$> f s) s = x s ** show _ >>= _ = _ ** case refine_2 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : StateT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : ∃ f, ∀ (x_1 : ρ), Subtype.val <$> f x_1 = x x_1 f : ρ → m { a // (fun x => p x.fst) a } h : ∀ (x_1 : ρ), Subtype.val <$> f x_1 = x x_1 s : ρ ⊢ (do let __discr ← (fun s => (fun x => match x with | { val := (a, s'), property := h } => ({ val := a, property := h }, s')) <$> f s) s match __discr with | (a, s) => pure (a.val, s)) = x s ** simp [map_eq_pure_bind, ← h] ** Qed
| |
SatisfiesM_ExceptT_eq ** m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m ⊢ SatisfiesM p x ↔ SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) x ** refine ⟨fun ⟨f, eq⟩ => eq ▸ ?_, fun ⟨f, eq⟩ => eq ▸ ?_⟩ ** case refine_1 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : ExceptT ρ m { a // p a } eq : Subtype.val <$> f = x ⊢ SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) (Subtype.val <$> f) ** exists (fun | .ok ⟨a, h⟩ => ⟨.ok a, fun | _, rfl => h⟩ | .error e => ⟨.error e, fun.⟩) <$> f ** case refine_1 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : ExceptT ρ m { a // p a } eq : Subtype.val <$> f = x ⊢ Subtype.val <$> (fun x => match x with | Except.ok { val := a, property := h } => { val := Except.ok a, property := (_ : ∀ (x : α), Except.ok a = Except.ok x → p x) } | Except.error e => { val := Except.error e, property := (_ : ∀ (a : α), Except.error e = Except.ok a → p a) }) <$> f = Subtype.val <$> f ** show _ = _ >>= _ ** case refine_1 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : ExceptT ρ m { a // p a } eq : Subtype.val <$> f = x ⊢ Subtype.val <$> (fun x => match x with | Except.ok { val := a, property := h } => { val := Except.ok a, property := (_ : ∀ (x : α), Except.ok a = Except.ok x → p x) } | Except.error e => { val := Except.error e, property := (_ : ∀ (a : α), Except.error e = Except.ok a → p a) }) <$> f = do let a ← f match a with | Except.ok a => pure (Except.ok a.val) | Except.error e => pure (Except.error e) ** rw [← comp_map, map_eq_pure_bind] ** case refine_1 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : ExceptT ρ m { a // p a } eq : Subtype.val <$> f = x ⊢ (do let a ← f pure ((Subtype.val ∘ fun x => match x with | Except.ok { val := a, property := h } => { val := Except.ok a, property := (_ : ∀ (x : α), Except.ok a = Except.ok x → p x) } | Except.error e => { val := Except.error e, property := (_ : ∀ (a : α), Except.error e = Except.ok a → p a) }) a)) = do let a ← f match a with | Except.ok a => pure (Except.ok a.val) | Except.error e => pure (Except.error e) ** congr ** case refine_1.e_a m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : ExceptT ρ m { a // p a } eq : Subtype.val <$> f = x ⊢ (fun a => pure ((Subtype.val ∘ fun x => match x with | Except.ok { val := a, property := h } => { val := Except.ok a, property := (_ : ∀ (x : α), Except.ok a = Except.ok x → p x) } | Except.error e => { val := Except.error e, property := (_ : ∀ (a : α), Except.error e = Except.ok a → p a) }) a)) = fun a => match a with | Except.ok a => pure (Except.ok a.val) | Except.error e => pure (Except.error e) ** funext a ** case refine_1.e_a.h m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM p x f : ExceptT ρ m { a // p a } eq : Subtype.val <$> f = x a : Except ρ { a // p a } ⊢ pure ((Subtype.val ∘ fun x => match x with | Except.ok { val := a, property := h } => { val := Except.ok a, property := (_ : ∀ (x : α), Except.ok a = Except.ok x → p x) } | Except.error e => { val := Except.error e, property := (_ : ∀ (a : α), Except.error e = Except.ok a → p a) }) a) = match a with | Except.ok a => pure (Except.ok a.val) | Except.error e => pure (Except.error e) ** cases a <;> rfl ** case refine_2 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) x f : m { a // (fun x => ∀ (a : α), x = Except.ok a → p a) a } eq : Subtype.val <$> f = x ⊢ SatisfiesM p (Subtype.val <$> f) ** exists ((fun | ⟨.ok a, h⟩ => .ok ⟨a, h _ rfl⟩ | ⟨.error e, _⟩ => .error e) <$> f : m _) ** case refine_2 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) x f : m { a // (fun x => ∀ (a : α), x = Except.ok a → p a) a } eq : Subtype.val <$> f = x ⊢ Subtype.val <$> (fun x => match x with | { val := Except.ok a, property := h } => Except.ok { val := a, property := (_ : p a) } | { val := Except.error e, property := property } => Except.error e) <$> f = Subtype.val <$> f ** show _ >>= _ = _ ** case refine_2 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) x f : m { a // (fun x => ∀ (a : α), x = Except.ok a → p a) a } eq : Subtype.val <$> f = x ⊢ (do let a ← (fun x => match x with | { val := Except.ok a, property := h } => Except.ok { val := a, property := (_ : p a) } | { val := Except.error e, property := property } => Except.error e) <$> f match a with | Except.ok a => pure (Except.ok a.val) | Except.error e => pure (Except.error e)) = Subtype.val <$> f ** simp [← comp_map, map_eq_pure_bind] ** case refine_2 m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) x f : m { a // (fun x => ∀ (a : α), x = Except.ok a → p a) a } eq : Subtype.val <$> f = x ⊢ (do let x ← f match match x with | { val := Except.ok a, property := h } => Except.ok { val := a, property := (_ : p a) } | { val := Except.error e, property := property } => Except.error e with | Except.ok a => pure (Except.ok a.val) | Except.error e => pure (Except.error e)) = do let a ← f pure a.val ** congr ** case refine_2.e_a m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) x f : m { a // (fun x => ∀ (a : α), x = Except.ok a → p a) a } eq : Subtype.val <$> f = x ⊢ (fun x => match match x with | { val := Except.ok a, property := h } => Except.ok { val := a, property := (_ : p a) } | { val := Except.error e, property := property } => Except.error e with | Except.ok a => pure (Except.ok a.val) | Except.error e => pure (Except.error e)) = fun a => pure a.val ** funext ⟨a, h⟩ ** case refine_2.e_a.h m : Type u_1 → Type u_2 α ρ : Type u_1 p : α → Prop x : ExceptT ρ m α inst✝¹ : Monad m inst✝ : LawfulMonad m x✝ : SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) x f : m { a // (fun x => ∀ (a : α), x = Except.ok a → p a) a } eq : Subtype.val <$> f = x a : Except ρ α h : ∀ (a_1 : α), a = Except.ok a_1 → p a_1 ⊢ (match match { val := a, property := h } with | { val := Except.ok a, property := h } => Except.ok { val := a, property := (_ : p a) } | { val := Except.error e, property := property } => Except.error e with | Except.ok a => pure (Except.ok a.val) | Except.error e => pure (Except.error e)) = pure { val := a, property := h }.val ** cases a <;> rfl ** Qed
| |
ForInStep.done_bindList ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝ : Monad m f : α → β → m (ForInStep β) a : β l : List α ⊢ bindList f l (done a) = pure (done a) ** cases l <;> simp ** Qed
| |
ForInStep.bind_yield_bindList ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝ : Monad m f : α → β → m (ForInStep β) s : ForInStep β l : List α ⊢ (ForInStep.bind s fun a => bindList f l (yield a)) = bindList f l s ** cases s <;> simp ** Qed
| |
ForInStep.bind_bindList_assoc ** m : Type u_1 → Type u_2 β : Type u_1 α : Type u_3 inst✝¹ : Monad m inst✝ : LawfulMonad m f : β → m (ForInStep β) g : α → β → m (ForInStep β) s : ForInStep β l : List α ⊢ (do let x ← ForInStep.bind s f bindList g l x) = ForInStep.bind s fun b => do let x ← f b bindList g l x ** cases s <;> simp ** Qed
| |
ForInStep.bindList_cons' ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → β → m (ForInStep β) s : ForInStep β a : α l : List α ⊢ bindList f (a :: l) s = do let x ← ForInStep.bind s (f a) bindList f l x ** simp ** Qed
| |
ForInStep.bindList_append ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → β → m (ForInStep β) s : ForInStep β l₁ l₂ : List α ⊢ bindList f (l₁ ++ l₂) s = do let x ← bindList f l₁ s bindList f l₂ x ** induction l₁ generalizing s <;> simp [*] ** Qed
| |
List.Pairwise.imp_of_mem ** case nil α : Type u_1 l : List α R S : α → α → Prop H : ∀ {a b : α}, a ∈ [] → b ∈ [] → R a b → S a b ⊢ Pairwise S [] ** constructor ** case cons α : Type u_1 l✝ : List α R S : α → α → Prop a : α l : List α r : ∀ (a' : α), a' ∈ l → R a a' a✝ : Pairwise R l ih : (∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → Pairwise S l H : ∀ {a_1 b : α}, a_1 ∈ a :: l → b ∈ a :: l → R a_1 b → S a_1 b ⊢ Pairwise S (a :: l) ** constructor ** case cons.a α : Type u_1 l✝ : List α R S : α → α → Prop a : α l : List α r : ∀ (a' : α), a' ∈ l → R a a' a✝ : Pairwise R l ih : (∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → Pairwise S l H : ∀ {a_1 b : α}, a_1 ∈ a :: l → b ∈ a :: l → R a_1 b → S a_1 b ⊢ ∀ (a' : α), a' ∈ l → S a a' ** exact fun x h => H (mem_cons_self ..) (mem_cons_of_mem _ h) <| r x h ** case cons.a α : Type u_1 l✝ : List α R S : α → α → Prop a : α l : List α r : ∀ (a' : α), a' ∈ l → R a a' a✝ : Pairwise R l ih : (∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → Pairwise S l H : ∀ {a_1 b : α}, a_1 ∈ a :: l → b ∈ a :: l → R a_1 b → S a_1 b ⊢ Pairwise S l ** exact ih fun m m' => H (mem_cons_of_mem _ m) (mem_cons_of_mem _ m') ** Qed
| |
List.Pairwise.and ** α✝ : Type u_1 R : α✝ → α✝ → Prop l : List α✝ S : α✝ → α✝ → Prop hR : Pairwise R l hS : Pairwise S l ⊢ Pairwise (fun a b => R a b ∧ S a b) l ** induction hR with
| nil => simp only [Pairwise.nil]
| cons R1 _ IH =>
simp only [Pairwise.nil, pairwise_cons] at hS ⊢
exact ⟨fun b bl => ⟨R1 b bl, hS.1 b bl⟩, IH hS.2⟩ ** case nil α✝ : Type u_1 R : α✝ → α✝ → Prop l : List α✝ S : α✝ → α✝ → Prop hS : Pairwise S [] ⊢ Pairwise (fun a b => R a b ∧ S a b) [] ** simp only [Pairwise.nil] ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop l : List α✝ S : α✝ → α✝ → Prop a✝¹ : α✝ l✝ : List α✝ R1 : ∀ (a' : α✝), a' ∈ l✝ → R a✝¹ a' a✝ : Pairwise R l✝ IH : Pairwise S l✝ → Pairwise (fun a b => R a b ∧ S a b) l✝ hS : Pairwise S (a✝¹ :: l✝) ⊢ Pairwise (fun a b => R a b ∧ S a b) (a✝¹ :: l✝) ** simp only [Pairwise.nil, pairwise_cons] at hS ⊢ ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop l : List α✝ S : α✝ → α✝ → Prop a✝¹ : α✝ l✝ : List α✝ R1 : ∀ (a' : α✝), a' ∈ l✝ → R a✝¹ a' a✝ : Pairwise R l✝ IH : Pairwise S l✝ → Pairwise (fun a b => R a b ∧ S a b) l✝ hS : (∀ (a' : α✝), a' ∈ l✝ → S a✝¹ a') ∧ Pairwise S l✝ ⊢ (∀ (a' : α✝), a' ∈ l✝ → R a✝¹ a' ∧ S a✝¹ a') ∧ Pairwise (fun a b => R a b ∧ S a b) l✝ ** exact ⟨fun b bl => ⟨R1 b bl, hS.1 b bl⟩, IH hS.2⟩ ** Qed
| |
List.pairwise_of_forall ** α : Type u_1 R : α → α → Prop l : List α H : ∀ (x y : α), R x y ⊢ Pairwise R l ** induction l <;> simp [*] ** Qed
| |
List.Pairwise.and_mem ** α : Type u_1 R : α → α → Prop l : List α ⊢ ∀ {a b : α}, a ∈ l → b ∈ l → (R a b ↔ a ∈ l ∧ b ∈ l ∧ R a b) ** simp (config := { contextual := true }) ** Qed
| |
List.Pairwise.imp_mem ** α : Type u_1 R : α → α → Prop l : List α ⊢ ∀ {a b : α}, a ∈ l → b ∈ l → (R a b ↔ a ∈ l → b ∈ l → R a b) ** simp (config := { contextual := true }) ** Qed
| |
List.Pairwise.forall_of_forall_of_flip ** case nil α✝ : Type u_1 R : α✝ → α✝ → Prop h₁ : ∀ (x : α✝), x ∈ [] → R x x h₂ : Pairwise R [] h₃ : Pairwise (flip R) [] ⊢ ∀ ⦃x : α✝⦄, x ∈ [] → ∀ ⦃y : α✝⦄, y ∈ [] → R x y ** exact forall_mem_nil _ ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop a : α✝ l : List α✝ ih : (∀ (x : α✝), x ∈ l → R x x) → Pairwise R l → Pairwise (flip R) l → ∀ ⦃x : α✝⦄, x ∈ l → ∀ ⦃y : α✝⦄, y ∈ l → R x y h₁ : ∀ (x : α✝), x ∈ a :: l → R x x h₂ : Pairwise R (a :: l) h₃ : Pairwise (flip R) (a :: l) ⊢ ∀ ⦃x : α✝⦄, x ∈ a :: l → ∀ ⦃y : α✝⦄, y ∈ a :: l → R x y ** rw [pairwise_cons] at h₂ h₃ ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop a : α✝ l : List α✝ ih : (∀ (x : α✝), x ∈ l → R x x) → Pairwise R l → Pairwise (flip R) l → ∀ ⦃x : α✝⦄, x ∈ l → ∀ ⦃y : α✝⦄, y ∈ l → R x y h₁ : ∀ (x : α✝), x ∈ a :: l → R x x h₂ : (∀ (a' : α✝), a' ∈ l → R a a') ∧ Pairwise R l h₃ : (∀ (a' : α✝), a' ∈ l → flip R a a') ∧ Pairwise (flip R) l ⊢ ∀ ⦃x : α✝⦄, x ∈ a :: l → ∀ ⦃y : α✝⦄, y ∈ a :: l → R x y ** simp only [mem_cons] ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop a : α✝ l : List α✝ ih : (∀ (x : α✝), x ∈ l → R x x) → Pairwise R l → Pairwise (flip R) l → ∀ ⦃x : α✝⦄, x ∈ l → ∀ ⦃y : α✝⦄, y ∈ l → R x y h₁ : ∀ (x : α✝), x ∈ a :: l → R x x h₂ : (∀ (a' : α✝), a' ∈ l → R a a') ∧ Pairwise R l h₃ : (∀ (a' : α✝), a' ∈ l → flip R a a') ∧ Pairwise (flip R) l ⊢ ∀ ⦃x : α✝⦄, x = a ∨ x ∈ l → ∀ ⦃y : α✝⦄, y = a ∨ y ∈ l → R x y ** rintro x (rfl | hx) y (rfl | hy) ** case cons.inl.inl α✝ : Type u_1 R : α✝ → α✝ → Prop l : List α✝ ih : (∀ (x : α✝), x ∈ l → R x x) → Pairwise R l → Pairwise (flip R) l → ∀ ⦃x : α✝⦄, x ∈ l → ∀ ⦃y : α✝⦄, y ∈ l → R x y y : α✝ h₁ : ∀ (x : α✝), x ∈ y :: l → R x x h₂ : (∀ (a' : α✝), a' ∈ l → R y a') ∧ Pairwise R l h₃ : (∀ (a' : α✝), a' ∈ l → flip R y a') ∧ Pairwise (flip R) l ⊢ R y y ** exact h₁ _ (l.mem_cons_self _) ** case cons.inl.inr α✝ : Type u_1 R : α✝ → α✝ → Prop l : List α✝ ih : (∀ (x : α✝), x ∈ l → R x x) → Pairwise R l → Pairwise (flip R) l → ∀ ⦃x : α✝⦄, x ∈ l → ∀ ⦃y : α✝⦄, y ∈ l → R x y x : α✝ h₁ : ∀ (x_1 : α✝), x_1 ∈ x :: l → R x_1 x_1 h₂ : (∀ (a' : α✝), a' ∈ l → R x a') ∧ Pairwise R l h₃ : (∀ (a' : α✝), a' ∈ l → flip R x a') ∧ Pairwise (flip R) l y : α✝ hy : y ∈ l ⊢ R x y ** exact h₂.1 _ hy ** case cons.inr.inl α✝ : Type u_1 R : α✝ → α✝ → Prop l : List α✝ ih : (∀ (x : α✝), x ∈ l → R x x) → Pairwise R l → Pairwise (flip R) l → ∀ ⦃x : α✝⦄, x ∈ l → ∀ ⦃y : α✝⦄, y ∈ l → R x y x : α✝ hx : x ∈ l y : α✝ h₁ : ∀ (x : α✝), x ∈ y :: l → R x x h₂ : (∀ (a' : α✝), a' ∈ l → R y a') ∧ Pairwise R l h₃ : (∀ (a' : α✝), a' ∈ l → flip R y a') ∧ Pairwise (flip R) l ⊢ R x y ** exact h₃.1 _ hx ** case cons.inr.inr α✝ : Type u_1 R : α✝ → α✝ → Prop a : α✝ l : List α✝ ih : (∀ (x : α✝), x ∈ l → R x x) → Pairwise R l → Pairwise (flip R) l → ∀ ⦃x : α✝⦄, x ∈ l → ∀ ⦃y : α✝⦄, y ∈ l → R x y h₁ : ∀ (x : α✝), x ∈ a :: l → R x x h₂ : (∀ (a' : α✝), a' ∈ l → R a a') ∧ Pairwise R l h₃ : (∀ (a' : α✝), a' ∈ l → flip R a a') ∧ Pairwise (flip R) l x : α✝ hx : x ∈ l y : α✝ hy : y ∈ l ⊢ R x y ** exact ih (fun x hx => h₁ _ <| mem_cons_of_mem _ hx) h₂.2 h₃.2 hx hy ** Qed
| |
List.pairwise_singleton ** α : Type u_1 R : α → α → Prop a : α ⊢ Pairwise R [a] ** simp ** Qed
| |
List.pairwise_pair ** α : Type u_1 R : α → α → Prop a b : α ⊢ Pairwise R [a, b] ↔ R a b ** simp ** Qed
| |
List.pairwise_append_comm ** α : Type u_1 R : α → α → Prop s : ∀ {x y : α}, R x y → R y x l₁ l₂ : List α ⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁) ** have (l₁ l₂ : List α) (H : ∀ x : α, x ∈ l₁ → ∀ y : α, y ∈ l₂ → R x y)
(x : α) (xm : x ∈ l₂) (y : α) (ym : y ∈ l₁) : R x y := s (H y ym x xm) ** α : Type u_1 R : α → α → Prop s : ∀ {x y : α}, R x y → R y x l₁ l₂ : List α this : ∀ (l₁ l₂ : List α), (∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) → ∀ (x : α), x ∈ l₂ → ∀ (y : α), y ∈ l₁ → R x y ⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁) ** simp only [pairwise_append, and_left_comm] ** α : Type u_1 R : α → α → Prop s : ∀ {x y : α}, R x y → R y x l₁ l₂ : List α this : ∀ (l₁ l₂ : List α), (∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) → ∀ (x : α), x ∈ l₂ → ∀ (y : α), y ∈ l₁ → R x y ⊢ (Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₁ → ∀ (b : α), b ∈ l₂ → R a b) ↔ Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₂ → ∀ (b : α), b ∈ l₁ → R a b ** rw [Iff.intro (this l₁ l₂) (this l₂ l₁)] ** Qed
| |
List.pairwise_filter ** α : Type u_1 R : α → α → Prop p : α → Prop inst✝ : DecidablePred p l : List α ⊢ Pairwise R (filter (fun b => decide (p b)) l) ↔ Pairwise (fun x y => p x → p y → R x y) l ** simp [← filterMap_eq_filter, pairwise_filterMap] ** Qed
| |
List.pairwise_join ** α : Type u_1 R : α → α → Prop L : List (List α) ⊢ Pairwise R (join L) ↔ (∀ (l : List α), l ∈ L → Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L ** induction L with
| nil => simp
| cons l L IH =>
simp only [join, pairwise_append, IH, mem_join, exists_imp, and_imp, forall_mem_cons,
pairwise_cons, and_assoc, and_congr_right_iff]
rw [and_comm, and_congr_left_iff]
intros; exact ⟨fun h a b c d e => h c d e a b, fun h c d e a b => h a b c d e⟩ ** case nil α : Type u_1 R : α → α → Prop ⊢ Pairwise R (join []) ↔ (∀ (l : List α), l ∈ [] → Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) [] ** simp ** case cons α : Type u_1 R : α → α → Prop l : List α L : List (List α) IH : Pairwise R (join L) ↔ (∀ (l : List α), l ∈ L → Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L ⊢ Pairwise R (join (l :: L)) ↔ (∀ (l_1 : List α), l_1 ∈ l :: L → Pairwise R l_1) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) (l :: L) ** simp only [join, pairwise_append, IH, mem_join, exists_imp, and_imp, forall_mem_cons,
pairwise_cons, and_assoc, and_congr_right_iff] ** case cons α : Type u_1 R : α → α → Prop l : List α L : List (List α) IH : Pairwise R (join L) ↔ (∀ (l : List α), l ∈ L → Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L ⊢ Pairwise R l → (∀ (l : List α), l ∈ L → Pairwise R l) → ((Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L ∧ ∀ (a : α), a ∈ l → ∀ (b : α) (x : List α), x ∈ L → b ∈ x → R a b) ↔ (∀ (a' : List α), a' ∈ L → ∀ (x : α), x ∈ l → ∀ (y : α), y ∈ a' → R x y) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L) ** rw [and_comm, and_congr_left_iff] ** case cons α : Type u_1 R : α → α → Prop l : List α L : List (List α) IH : Pairwise R (join L) ↔ (∀ (l : List α), l ∈ L → Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L ⊢ Pairwise R l → (∀ (l : List α), l ∈ L → Pairwise R l) → Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L → ((∀ (a : α), a ∈ l → ∀ (b : α) (x : List α), x ∈ L → b ∈ x → R a b) ↔ ∀ (a' : List α), a' ∈ L → ∀ (x : α), x ∈ l → ∀ (y : α), y ∈ a' → R x y) ** intros ** case cons α : Type u_1 R : α → α → Prop l : List α L : List (List α) IH : Pairwise R (join L) ↔ (∀ (l : List α), l ∈ L → Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L a✝² : Pairwise R l a✝¹ : ∀ (l : List α), l ∈ L → Pairwise R l a✝ : Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L ⊢ (∀ (a : α), a ∈ l → ∀ (b : α) (x : List α), x ∈ L → b ∈ x → R a b) ↔ ∀ (a' : List α), a' ∈ L → ∀ (x : α), x ∈ l → ∀ (y : α), y ∈ a' → R x y ** exact ⟨fun h a b c d e => h c d e a b, fun h c d e a b => h a b c d e⟩ ** Qed
| |
List.pairwise_bind ** β : Type u_1 α : Type u_2 R : β → β → Prop l : List α f : α → List β ⊢ Pairwise R (List.bind l f) ↔ (∀ (a : α), a ∈ l → Pairwise R (f a)) ∧ Pairwise (fun a₁ a₂ => ∀ (x : β), x ∈ f a₁ → ∀ (y : β), y ∈ f a₂ → R x y) l ** simp [List.bind, pairwise_join, pairwise_map] ** Qed
| |
List.pairwise_iff_forall_sublist ** case nil α✝ : Type u_1 R : α✝ → α✝ → Prop ⊢ Pairwise R [] ↔ ∀ {a b : α✝}, [a, b] <+ [] → R a b ** simp ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b ⊢ Pairwise R (hd :: tl) ↔ ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b ** rw [List.pairwise_cons] ** case cons α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b ⊢ (∀ (a' : α✝), a' ∈ tl → R hd a') ∧ Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b ** constructor <;> intro h ** case cons.mp α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : (∀ (a' : α✝), a' ∈ tl → R hd a') ∧ Pairwise R tl ⊢ ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b ** intro
| a, b, .cons _ hab => exact IH.mp h.2 hab
| _, b, .cons₂ _ hab => refine h.1 _ (hab.subset ?_); simp ** α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : (∀ (a' : α✝), a' ∈ tl → R hd a') ∧ Pairwise R tl x✝² x✝¹ : α✝ x✝ : [x✝², x✝¹] <+ hd :: tl a b : α✝ hab : [a, b] <+ tl ⊢ R a b ** exact IH.mp h.2 hab ** α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : (∀ (a' : α✝), a' ∈ tl → R hd a') ∧ Pairwise R tl x✝² x✝¹ : α✝ x✝ : [x✝², x✝¹] <+ hd :: tl b : α✝ hab : [b] <+ tl ⊢ R hd b ** refine h.1 _ (hab.subset ?_) ** α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : (∀ (a' : α✝), a' ∈ tl → R hd a') ∧ Pairwise R tl x✝² x✝¹ : α✝ x✝ : [x✝², x✝¹] <+ hd :: tl b : α✝ hab : [b] <+ tl ⊢ b ∈ [b] ** simp ** case cons.mpr α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b ⊢ (∀ (a' : α✝), a' ∈ tl → R hd a') ∧ Pairwise R tl ** constructor ** case cons.mpr.left α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b ⊢ ∀ (a' : α✝), a' ∈ tl → R hd a' ** intro x hx ** case cons.mpr.left α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b x : α✝ hx : x ∈ tl ⊢ R hd x ** apply h ** case cons.mpr.left.a α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b x : α✝ hx : x ∈ tl ⊢ [hd, x] <+ hd :: tl ** rw [List.cons_sublist_cons, List.singleton_sublist] ** case cons.mpr.left.a α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b x : α✝ hx : x ∈ tl ⊢ x ∈ tl ** exact hx ** case cons.mpr.right α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b ⊢ Pairwise R tl ** apply IH.mpr ** case cons.mpr.right α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b ⊢ ∀ {a b : α✝}, [a, b] <+ tl → R a b ** intro a b hab ** case cons.mpr.right α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b a b : α✝ hab : [a, b] <+ tl ⊢ R a b ** apply h ** case cons.mpr.right.a α✝ : Type u_1 R : α✝ → α✝ → Prop hd : α✝ tl : List α✝ IH : Pairwise R tl ↔ ∀ {a b : α✝}, [a, b] <+ tl → R a b h : ∀ {a b : α✝}, [a, b] <+ hd :: tl → R a b a b : α✝ hab : [a, b] <+ tl ⊢ [a, b] <+ hd :: tl ** exact hab.cons _ ** Qed
| |
List.pairwise_of_reflexive_on_dupl_of_forall_ne ** α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b ⊢ Pairwise r l ** apply pairwise_iff_forall_sublist.mpr ** α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b ⊢ ∀ {a b : α}, [a, b] <+ l → r a b ** intro a b hab ** α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a b : α hab : [a, b] <+ l ⊢ r a b ** if heq : a = b then
cases heq; apply hr
rwa [show [a,a] = replicate 2 a from rfl, ← le_count_iff_replicate_sublist] at hab
else
apply h <;> try (apply hab.subset; simp)
exact heq ** α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a b : α hab : [a, b] <+ l heq : a = b ⊢ r a b ** cases heq ** case refl α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a : α hab : [a, a] <+ l ⊢ r a a ** apply hr ** case refl.a α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a : α hab : [a, a] <+ l ⊢ 1 < count a l ** rwa [show [a,a] = replicate 2 a from rfl, ← le_count_iff_replicate_sublist] at hab ** α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a b : α hab : [a, b] <+ l heq : ¬a = b ⊢ r a b ** apply h <;> try (apply hab.subset; simp) ** case a α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a b : α hab : [a, b] <+ l heq : ¬a = b ⊢ a ≠ b ** exact heq ** case a α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a b : α hab : [a, b] <+ l heq : ¬a = b ⊢ b ∈ l ** (apply hab.subset; simp) ** case a α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a b : α hab : [a, b] <+ l heq : ¬a = b ⊢ b ∈ l ** apply hab.subset ** case a.a α : Type u_1 inst✝ : DecidableEq α l : List α r : α → α → Prop hr : ∀ (a : α), 1 < count a l → r a a h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b a b : α hab : [a, b] <+ l heq : ¬a = b ⊢ b ∈ [a, b] ** simp ** Qed
| |
List.sublist_eq_map_get ** case slnil α✝ : Type u_1 l' l : List α✝ ⊢ ∃ is, [] = map (get []) is ∧ Pairwise (fun x x_1 => x < x_1) is ** exact ⟨[], by simp⟩ ** α✝ : Type u_1 l' l : List α✝ ⊢ [] = map (get []) [] ∧ Pairwise (fun x x_1 => x < x_1) [] ** simp ** case cons α✝ : Type u_1 l' l l₁✝ l₂✝ : List α✝ a✝¹ : α✝ a✝ : l₁✝ <+ l₂✝ IH : ∃ is, l₁✝ = map (get l₂✝) is ∧ Pairwise (fun x x_1 => x < x_1) is ⊢ ∃ is, l₁✝ = map (get (a✝¹ :: l₂✝)) is ∧ Pairwise (fun x x_1 => x < x_1) is ** let ⟨is, IH⟩ := IH ** case cons α✝ : Type u_1 l' l l₁✝ l₂✝ : List α✝ a✝¹ : α✝ a✝ : l₁✝ <+ l₂✝ IH✝ : ∃ is, l₁✝ = map (get l₂✝) is ∧ Pairwise (fun x x_1 => x < x_1) is is : List (Fin (length l₂✝)) IH : l₁✝ = map (get l₂✝) is ∧ Pairwise (fun x x_1 => x < x_1) is ⊢ l₁✝ = map (get (a✝¹ :: l₂✝)) (map (fun x => Fin.succ x) is) ∧ Pairwise (fun x x_1 => x < x_1) (map (fun x => Fin.succ x) is) ** simp [comp, pairwise_map] ** case cons α✝ : Type u_1 l' l l₁✝ l₂✝ : List α✝ a✝¹ : α✝ a✝ : l₁✝ <+ l₂✝ IH✝ : ∃ is, l₁✝ = map (get l₂✝) is ∧ Pairwise (fun x x_1 => x < x_1) is is : List (Fin (length l₂✝)) IH : l₁✝ = map (get l₂✝) is ∧ Pairwise (fun x x_1 => x < x_1) is ⊢ l₁✝ = map (fun x => get l₂✝ x) is ∧ Pairwise (fun a b => a < b) is ** exact IH ** case cons₂ α✝ : Type u_1 l' l l₁✝ l₂✝ : List α✝ a✝¹ : α✝ a✝ : l₁✝ <+ l₂✝ IH : ∃ is, l₁✝ = map (get l₂✝) is ∧ Pairwise (fun x x_1 => x < x_1) is ⊢ ∃ is, a✝¹ :: l₁✝ = map (get (a✝¹ :: l₂✝)) is ∧ Pairwise (fun x x_1 => x < x_1) is ** rcases IH with ⟨is,IH⟩ ** case cons₂.intro α✝ : Type u_1 l' l l₁✝ l₂✝ : List α✝ a✝¹ : α✝ a✝ : l₁✝ <+ l₂✝ is : List (Fin (length l₂✝)) IH : l₁✝ = map (get l₂✝) is ∧ Pairwise (fun x x_1 => x < x_1) is ⊢ a✝¹ :: l₁✝ = map (get (a✝¹ :: l₂✝)) ({ val := 0, isLt := (_ : 0 < succ (length l₂✝)) } :: map (fun x => Fin.succ x) is) ∧ Pairwise (fun x x_1 => x < x_1) ({ val := 0, isLt := (_ : 0 < succ (length l₂✝)) } :: map (fun x => Fin.succ x) is) ** simp [comp, pairwise_map, IH] ** α✝ : Type u_1 l' l l₁✝ l₂✝ : List α✝ a✝¹ : α✝ a✝ : l₁✝ <+ l₂✝ is : List (Fin (length l₂✝)) IH : l₁✝ = map (get l₂✝) is ∧ Pairwise (fun x x_1 => x < x_1) is ⊢ 0 < length (a✝¹ :: l₂✝) ** simp [Nat.zero_lt_succ] ** Qed
| |
List.pairwise_replicate ** α : Type u_1 r : α → α → Prop x : α hx : r x x ⊢ Pairwise r (replicate 0 x) ** simp ** α : Type u_1 r : α → α → Prop x : α hx : r x x n : Nat ⊢ Pairwise r (replicate (n + 1) x) ** simp [mem_replicate, hx, pairwise_replicate hx n] ** Qed
| |
List.pwFilter_map ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β ⊢ pwFilter R (map f (x :: xs)) = map f (pwFilter (fun x y => R (f x) (f y)) (x :: xs)) ** if h : ∀ b ∈ pwFilter R (map f xs), R (f x) b then
have h' : ∀ b : β, b ∈ pwFilter (fun x y : β => R (f x) (f y)) xs → R (f x) (f b) :=
fun b hb => h _ (by rw [pwFilter_map f xs]; apply mem_map_of_mem _ hb)
rw [map, pwFilter_cons_of_pos h, pwFilter_cons_of_pos h', pwFilter_map f xs, map]
else
rw [map, pwFilter_cons_of_neg h, pwFilter_cons_of_neg ?_, pwFilter_map f xs]
refine fun hh => h fun a ha => ?_
rw [pwFilter_map f xs, mem_map] at ha
let ⟨b, hb₀, hb₁⟩ := ha; exact hb₁ ▸ hh _ hb₀ ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b ⊢ pwFilter R (map f (x :: xs)) = map f (pwFilter (fun x y => R (f x) (f y)) (x :: xs)) ** have h' : ∀ b : β, b ∈ pwFilter (fun x y : β => R (f x) (f y)) xs → R (f x) (f b) :=
fun b hb => h _ (by rw [pwFilter_map f xs]; apply mem_map_of_mem _ hb) ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b h' : ∀ (b : β), b ∈ pwFilter (fun x y => R (f x) (f y)) xs → R (f x) (f b) ⊢ pwFilter R (map f (x :: xs)) = map f (pwFilter (fun x y => R (f x) (f y)) (x :: xs)) ** rw [map, pwFilter_cons_of_pos h, pwFilter_cons_of_pos h', pwFilter_map f xs, map] ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b b : β hb : b ∈ pwFilter (fun x y => R (f x) (f y)) xs ⊢ f b ∈ pwFilter R (map f xs) ** rw [pwFilter_map f xs] ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b b : β hb : b ∈ pwFilter (fun x y => R (f x) (f y)) xs ⊢ f b ∈ map f (pwFilter (fun x y => R (f x) (f y)) xs) ** apply mem_map_of_mem _ hb ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ¬∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b ⊢ pwFilter R (map f (x :: xs)) = map f (pwFilter (fun x y => R (f x) (f y)) (x :: xs)) ** rw [map, pwFilter_cons_of_neg h, pwFilter_cons_of_neg ?_, pwFilter_map f xs] ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ¬∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b ⊢ ¬∀ (b : β), b ∈ pwFilter (fun x y => R (f x) (f y)) xs → R (f x) (f b) ** refine fun hh => h fun a ha => ?_ ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ¬∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b hh : ∀ (b : β), b ∈ pwFilter (fun x y => R (f x) (f y)) xs → R (f x) (f b) a : α ha : a ∈ pwFilter R (map f xs) ⊢ R (f x) a ** rw [pwFilter_map f xs, mem_map] at ha ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ¬∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b hh : ∀ (b : β), b ∈ pwFilter (fun x y => R (f x) (f y)) xs → R (f x) (f b) a : α ha : ∃ a_1, a_1 ∈ pwFilter (fun x y => R (f x) (f y)) xs ∧ f a_1 = a ⊢ R (f x) a ** let ⟨b, hb₀, hb₁⟩ := ha ** α : Type u_1 R : α → α → Prop β : Type u_2 inst✝ : DecidableRel R f : β → α x : β xs : List β h : ¬∀ (b : α), b ∈ pwFilter R (map f xs) → R (f x) b hh : ∀ (b : β), b ∈ pwFilter (fun x y => R (f x) (f y)) xs → R (f x) (f b) a : α ha : ∃ a_1, a_1 ∈ pwFilter (fun x y => R (f x) (f y)) xs ∧ f a_1 = a b : β hb₀ : b ∈ pwFilter (fun x y => R (f x) (f y)) xs hb₁ : f b = a ⊢ R (f x) a ** exact hb₁ ▸ hh _ hb₀ ** Qed
| |
List.pwFilter_eq_self ** α : Type u_1 R : α → α → Prop inst✝ : DecidableRel R l : List α ⊢ pwFilter R l = l ↔ Pairwise R l ** refine ⟨fun e => e ▸ pairwise_pwFilter l, fun p => ?_⟩ ** α : Type u_1 R : α → α → Prop inst✝ : DecidableRel R l : List α p : Pairwise R l ⊢ pwFilter R l = l ** induction l with
| nil => rfl
| cons x l IH =>
let ⟨al, p⟩ := pairwise_cons.1 p
rw [pwFilter_cons_of_pos fun b hb => ?_, IH p]
rw [IH p] at hb
exact al _ hb ** case nil α : Type u_1 R : α → α → Prop inst✝ : DecidableRel R p : Pairwise R [] ⊢ pwFilter R [] = [] ** rfl ** case cons α : Type u_1 R : α → α → Prop inst✝ : DecidableRel R x : α l : List α IH : Pairwise R l → pwFilter R l = l p : Pairwise R (x :: l) ⊢ pwFilter R (x :: l) = x :: l ** let ⟨al, p⟩ := pairwise_cons.1 p ** case cons α : Type u_1 R : α → α → Prop inst✝ : DecidableRel R x : α l : List α IH : Pairwise R l → pwFilter R l = l p✝ : Pairwise R (x :: l) al : ∀ (a' : α), a' ∈ l → R x a' p : Pairwise R l ⊢ pwFilter R (x :: l) = x :: l ** rw [pwFilter_cons_of_pos fun b hb => ?_, IH p] ** α : Type u_1 R : α → α → Prop inst✝ : DecidableRel R x : α l : List α IH : Pairwise R l → pwFilter R l = l p✝ : Pairwise R (x :: l) al : ∀ (a' : α), a' ∈ l → R x a' p : Pairwise R l b : α hb : b ∈ pwFilter R l ⊢ R x b ** rw [IH p] at hb ** α : Type u_1 R : α → α → Prop inst✝ : DecidableRel R x : α l : List α IH : Pairwise R l → pwFilter R l = l p✝ : Pairwise R (x :: l) al : ∀ (a' : α), a' ∈ l → R x a' p : Pairwise R l b : α hb : b ∈ l ⊢ R x b ** exact al _ hb ** Qed
| |
beq_eq_false_iff_ne ** α : Type u_1 inst✝¹ : BEq α inst✝ : LawfulBEq α a b : α ⊢ (a == b) = false ↔ a ≠ b ** rw [ne_eq, ← beq_iff_eq a b] ** α : Type u_1 inst✝¹ : BEq α inst✝ : LawfulBEq α a b : α ⊢ (a == b) = false ↔ ¬(a == b) = true ** cases a == b <;> decide ** Qed
| |
List.set_eq_setTR ** ⊢ @set = @setTR ** funext α l n a ** case h.h.h.h α : Type u_1 l : List α n : Nat a : α ⊢ set l n a = setTR l n a ** simp [setTR] ** case h.h.h.h α : Type u_1 l : List α n : Nat a : α ⊢ set l n a = setTR.go l a l n #[] ** exact (go #[] _ _ rfl).symm ** α : Type u_1 l : List α n : Nat a : α acc : Array α x✝ : Nat h : l = acc.data ++ [] ⊢ setTR.go l a [] x✝ acc = acc.data ++ set [] x✝ a ** simp [setTR.go, set, h] ** α : Type u_1 l : List α n : Nat a : α acc : Array α x : α xs : List α ⊢ l = acc.data ++ x :: xs → setTR.go l a (x :: xs) 0 acc = acc.data ++ set (x :: xs) 0 a ** simp [setTR.go, set] ** α : Type u_1 l : List α n✝ : Nat a : α acc : Array α x : α xs : List α n : Nat h : l = acc.data ++ x :: xs ⊢ setTR.go l a (x :: xs) (n + 1) acc = acc.data ++ set (x :: xs) (n + 1) a ** simp [setTR.go, set] ** α : Type u_1 l : List α n✝ : Nat a : α acc : Array α x : α xs : List α n : Nat h : l = acc.data ++ x :: xs ⊢ setTR.go l a xs n (Array.push acc x) = acc.data ++ x :: set xs n a ** rw [go _ xs] ** α : Type u_1 l : List α n✝ : Nat a : α acc : Array α x : α xs : List α n : Nat h : l = acc.data ++ x :: xs ⊢ (Array.push acc x).data ++ set xs n a = acc.data ++ x :: set xs n a case a α : Type u_1 l : List α n✝ : Nat a : α acc : Array α x : α xs : List α n : Nat h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** {simp} ** case a α : Type u_1 l : List α n✝ : Nat a : α acc : Array α x : α xs : List α n : Nat h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp [h] ** Qed
| |
List.erase_eq_eraseTR ** ⊢ @List.erase = @eraseTR ** funext α _ l a ** case h.h.h.h α : Type u_1 x✝ : BEq α l : List α a : α ⊢ List.erase l a = eraseTR l a ** simp [eraseTR] ** case h.h.h.h α : Type u_1 x✝ : BEq α l : List α a : α ⊢ List.erase l a = eraseTR.go l a l #[] ** suffices ∀ xs acc, l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ xs.erase a from
(this l #[] (by simp)).symm ** case h.h.h.h α : Type u_1 x✝ : BEq α l : List α a : α ⊢ ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a ** intro xs ** α : Type u_1 x✝ : BEq α l : List α a : α this : ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a ⊢ l = #[].data ++ l ** simp ** case h.h.h.h.nil α : Type u_1 x✝ : BEq α l : List α a : α acc : Array α h : l = acc.data ++ [] ⊢ eraseTR.go l a [] acc = acc.data ++ List.erase [] a ** simp [List.erase, eraseTR.go, h] ** case h.h.h.h.cons α : Type u_1 x✝ : BEq α l : List α a x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a acc : Array α h : l = acc.data ++ x :: xs ⊢ eraseTR.go l a (x :: xs) acc = acc.data ++ List.erase (x :: xs) a ** simp [List.erase, eraseTR.go] ** case h.h.h.h.cons α : Type u_1 x✝ : BEq α l : List α a x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a acc : Array α h : l = acc.data ++ x :: xs ⊢ (bif x == a then acc.data ++ xs else eraseTR.go l a xs (Array.push acc x)) = acc.data ++ match x == a with | true => xs | false => x :: List.erase xs a ** cases x == a <;> simp ** case h.h.h.h.cons.false α : Type u_1 x✝ : BEq α l : List α a x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a acc : Array α h : l = acc.data ++ x :: xs ⊢ eraseTR.go l a xs (Array.push acc x) = acc.data ++ x :: List.erase xs a ** rw [IH] ** case h.h.h.h.cons.false α : Type u_1 x✝ : BEq α l : List α a x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a acc : Array α h : l = acc.data ++ x :: xs ⊢ (Array.push acc x).data ++ List.erase xs a = acc.data ++ x :: List.erase xs a case h.h.h.h.cons.false.a α : Type u_1 x✝ : BEq α l : List α a x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a acc : Array α h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp ** case h.h.h.h.cons.false.a α : Type u_1 x✝ : BEq α l : List α a x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a acc : Array α h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp ** case h.h.h.h.cons.false.a α : Type u_1 x✝ : BEq α l : List α a x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ List.erase xs a acc : Array α h : l = acc.data ++ x :: xs ⊢ l = acc.data ++ x :: xs ** exact h ** Qed
| |
List.eraseIdx_eq_eraseIdxTR ** ⊢ @eraseIdx = @eraseIdxTR ** funext α l n ** case h.h.h α : Type u_1 l : List α n : Nat ⊢ eraseIdx l n = eraseIdxTR l n ** simp [eraseIdxTR] ** case h.h.h α : Type u_1 l : List α n : Nat ⊢ eraseIdx l n = eraseIdxTR.go l l n #[] ** suffices ∀ xs acc, l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ xs.eraseIdx n from
(this l #[] (by simp)).symm ** case h.h.h α : Type u_1 l : List α n : Nat ⊢ ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n ** intro xs ** case h.h.h α : Type u_1 l : List α n : Nat xs : List α ⊢ ∀ (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n ** induction xs generalizing n with intro acc h
| nil => simp [eraseIdx, eraseIdxTR.go, h]
| cons x xs IH =>
match n with
| 0 => simp [eraseIdx, eraseIdxTR.go]
| n+1 =>
simp [eraseIdx, eraseIdxTR.go]
rw [IH]; simp; simp; exact h ** α : Type u_1 l : List α n : Nat this : ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n ⊢ l = #[].data ++ l ** simp ** case h.h.h.nil α : Type u_1 l : List α n : Nat acc : Array α h : l = acc.data ++ [] ⊢ eraseIdxTR.go l [] n acc = acc.data ++ eraseIdx [] n ** simp [eraseIdx, eraseIdxTR.go, h] ** case h.h.h.cons α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n n : Nat acc : Array α h : l = acc.data ++ x :: xs ⊢ eraseIdxTR.go l (x :: xs) n acc = acc.data ++ eraseIdx (x :: xs) n ** match n with
| 0 => simp [eraseIdx, eraseIdxTR.go]
| n+1 =>
simp [eraseIdx, eraseIdxTR.go]
rw [IH]; simp; simp; exact h ** α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n n : Nat acc : Array α h : l = acc.data ++ x :: xs ⊢ eraseIdxTR.go l (x :: xs) 0 acc = acc.data ++ eraseIdx (x :: xs) 0 ** simp [eraseIdx, eraseIdxTR.go] ** α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n n✝ : Nat acc : Array α h : l = acc.data ++ x :: xs n : Nat ⊢ eraseIdxTR.go l (x :: xs) (n + 1) acc = acc.data ++ eraseIdx (x :: xs) (n + 1) ** simp [eraseIdx, eraseIdxTR.go] ** α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n n✝ : Nat acc : Array α h : l = acc.data ++ x :: xs n : Nat ⊢ eraseIdxTR.go l xs n (Array.push acc x) = acc.data ++ x :: eraseIdx xs n ** rw [IH] ** α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n n✝ : Nat acc : Array α h : l = acc.data ++ x :: xs n : Nat ⊢ (Array.push acc x).data ++ eraseIdx xs n = acc.data ++ x :: eraseIdx xs n case a α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n n✝ : Nat acc : Array α h : l = acc.data ++ x :: xs n : Nat ⊢ l = (Array.push acc x).data ++ xs ** simp ** case a α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n n✝ : Nat acc : Array α h : l = acc.data ++ x :: xs n : Nat ⊢ l = (Array.push acc x).data ++ xs ** simp ** case a α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ eraseIdx xs n n✝ : Nat acc : Array α h : l = acc.data ++ x :: xs n : Nat ⊢ l = acc.data ++ x :: xs ** exact h ** Qed
| |
List.replace_eq_replaceTR ** ⊢ @replace = @replaceTR ** funext α _ l b c ** case h.h.h.h.h α : Type u_1 x✝ : BEq α l : List α b c : α ⊢ replace l b c = replaceTR l b c ** simp [replaceTR] ** case h.h.h.h.h α : Type u_1 x✝ : BEq α l : List α b c : α ⊢ replace l b c = replaceTR.go l b c l #[] ** suffices ∀ xs acc, l = acc.data ++ xs →
replaceTR.go l b c xs acc = acc.data ++ xs.replace b c from
(this l #[] (by simp)).symm ** case h.h.h.h.h α : Type u_1 x✝ : BEq α l : List α b c : α ⊢ ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c ** intro xs ** α : Type u_1 x✝ : BEq α l : List α b c : α this : ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c ⊢ l = #[].data ++ l ** simp ** case h.h.h.h.h.nil α : Type u_1 x✝ : BEq α l : List α b c : α acc : Array α ⊢ l = acc.data ++ [] → replaceTR.go l b c [] acc = acc.data ++ replace [] b c ** simp [replace, replaceTR.go] ** case h.h.h.h.h.cons α : Type u_1 x✝ : BEq α l : List α b c x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c acc : Array α ⊢ l = acc.data ++ x :: xs → replaceTR.go l b c (x :: xs) acc = acc.data ++ replace (x :: xs) b c ** simp [replace, replaceTR.go] ** case h.h.h.h.h.cons α : Type u_1 x✝ : BEq α l : List α b c x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c acc : Array α ⊢ l = acc.data ++ x :: xs → (bif x == b then acc.data ++ c :: xs else replaceTR.go l b c xs (Array.push acc x)) = acc.data ++ match x == b with | true => c :: xs | false => x :: replace xs b c ** split <;> simp [*] ** case h.h.h.h.h.cons.h_2 α : Type u_1 x✝¹ : BEq α l : List α b c x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c acc : Array α x✝ : Bool heq✝ : (x == b) = false ⊢ l = acc.data ++ x :: xs → replaceTR.go l b c xs (Array.push acc x) = acc.data ++ x :: replace xs b c ** intro h ** case h.h.h.h.h.cons.h_2 α : Type u_1 x✝¹ : BEq α l : List α b c x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c acc : Array α x✝ : Bool heq✝ : (x == b) = false h : l = acc.data ++ x :: xs ⊢ replaceTR.go l b c xs (Array.push acc x) = acc.data ++ x :: replace xs b c ** rw [IH] ** case h.h.h.h.h.cons.h_2 α : Type u_1 x✝¹ : BEq α l : List α b c x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c acc : Array α x✝ : Bool heq✝ : (x == b) = false h : l = acc.data ++ x :: xs ⊢ (Array.push acc x).data ++ replace xs b c = acc.data ++ x :: replace xs b c case h.h.h.h.h.cons.h_2.a α : Type u_1 x✝¹ : BEq α l : List α b c x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c acc : Array α x✝ : Bool heq✝ : (x == b) = false h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp ** case h.h.h.h.h.cons.h_2.a α : Type u_1 x✝¹ : BEq α l : List α b c x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c acc : Array α x✝ : Bool heq✝ : (x == b) = false h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp ** case h.h.h.h.h.cons.h_2.a α : Type u_1 x✝¹ : BEq α l : List α b c x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → replaceTR.go l b c xs acc = acc.data ++ replace xs b c acc : Array α x✝ : Bool heq✝ : (x == b) = false h : l = acc.data ++ x :: xs ⊢ l = acc.data ++ x :: xs ** exact h ** Qed
| |
List.take_eq_takeTR ** ⊢ @take = @takeTR ** funext α n l ** case h.h.h α : Type u_1 n : Nat l : List α ⊢ take n l = takeTR n l ** simp [takeTR] ** case h.h.h α : Type u_1 n : Nat l : List α ⊢ take n l = takeTR.go l l n #[] ** suffices ∀ xs acc, l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ xs.take n from
(this l #[] (by simp)).symm ** case h.h.h α : Type u_1 n : Nat l : List α ⊢ ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs ** intro xs ** case h.h.h α : Type u_1 n : Nat l xs : List α ⊢ ∀ (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs ** induction xs generalizing n with intro acc
| nil => cases n <;> simp [take, takeTR.go]
| cons x xs IH =>
cases n with simp [take, takeTR.go]
| succ n => intro h; rw [IH]; simp; simp; exact h ** α : Type u_1 n : Nat l : List α this : ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs ⊢ l = #[].data ++ l ** simp ** case h.h.h.nil α : Type u_1 l : List α n : Nat acc : Array α ⊢ l = acc.data ++ [] → takeTR.go l [] n acc = acc.data ++ take n [] ** cases n <;> simp [take, takeTR.go] ** case h.h.h.cons α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs n : Nat acc : Array α ⊢ l = acc.data ++ x :: xs → takeTR.go l (x :: xs) n acc = acc.data ++ take n (x :: xs) ** cases n with simp [take, takeTR.go]
| succ n => intro h; rw [IH]; simp; simp; exact h ** case h.h.h.cons.succ α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs acc : Array α n : Nat ⊢ l = acc.data ++ x :: xs → takeTR.go l xs n (Array.push acc x) = acc.data ++ x :: take n xs ** intro h ** case h.h.h.cons.succ α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs acc : Array α n : Nat h : l = acc.data ++ x :: xs ⊢ takeTR.go l xs n (Array.push acc x) = acc.data ++ x :: take n xs ** rw [IH] ** case h.h.h.cons.succ α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs acc : Array α n : Nat h : l = acc.data ++ x :: xs ⊢ (Array.push acc x).data ++ take n xs = acc.data ++ x :: take n xs case h.h.h.cons.succ.a α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs acc : Array α n : Nat h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp ** case h.h.h.cons.succ.a α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs acc : Array α n : Nat h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp ** case h.h.h.cons.succ.a α : Type u_1 l : List α x : α xs : List α IH : ∀ (n : Nat) (acc : Array α), l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ take n xs acc : Array α n : Nat h : l = acc.data ++ x :: xs ⊢ l = acc.data ++ x :: xs ** exact h ** Qed
| |
List.takeWhile_eq_takeWhileTR ** ⊢ @takeWhile = @takeWhileTR ** funext α p l ** case h.h.h α : Type u_1 p : α → Bool l : List α ⊢ takeWhile p l = takeWhileTR p l ** simp [takeWhileTR] ** case h.h.h α : Type u_1 p : α → Bool l : List α ⊢ takeWhile p l = takeWhileTR.go p l l #[] ** suffices ∀ xs acc, l = acc.data ++ xs →
takeWhileTR.go p l xs acc = acc.data ++ xs.takeWhile p from
(this l #[] (by simp)).symm ** case h.h.h α : Type u_1 p : α → Bool l : List α ⊢ ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs ** intro xs ** α : Type u_1 p : α → Bool l : List α this : ∀ (xs : List α) (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs ⊢ l = #[].data ++ l ** simp ** case h.h.h.nil α : Type u_1 p : α → Bool l : List α acc : Array α ⊢ l = acc.data ++ [] → takeWhileTR.go p l [] acc = acc.data ++ takeWhile p [] ** simp [takeWhile, takeWhileTR.go] ** case h.h.h.cons α : Type u_1 p : α → Bool l : List α x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs acc : Array α ⊢ l = acc.data ++ x :: xs → takeWhileTR.go p l (x :: xs) acc = acc.data ++ takeWhile p (x :: xs) ** simp [takeWhile, takeWhileTR.go] ** case h.h.h.cons α : Type u_1 p : α → Bool l : List α x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs acc : Array α ⊢ l = acc.data ++ x :: xs → (bif p x then takeWhileTR.go p l xs (Array.push acc x) else acc.data) = acc.data ++ match p x with | true => x :: takeWhile p xs | false => [] ** split <;> simp [*] ** case h.h.h.cons.h_1 α : Type u_1 p : α → Bool l : List α x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs acc : Array α x✝ : Bool heq✝ : p x = true ⊢ l = acc.data ++ x :: xs → takeWhileTR.go p l xs (Array.push acc x) = acc.data ++ x :: takeWhile p xs ** intro h ** case h.h.h.cons.h_1 α : Type u_1 p : α → Bool l : List α x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs acc : Array α x✝ : Bool heq✝ : p x = true h : l = acc.data ++ x :: xs ⊢ takeWhileTR.go p l xs (Array.push acc x) = acc.data ++ x :: takeWhile p xs ** rw [IH] ** case h.h.h.cons.h_1 α : Type u_1 p : α → Bool l : List α x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs acc : Array α x✝ : Bool heq✝ : p x = true h : l = acc.data ++ x :: xs ⊢ (Array.push acc x).data ++ takeWhile p xs = acc.data ++ x :: takeWhile p xs case h.h.h.cons.h_1.a α : Type u_1 p : α → Bool l : List α x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs acc : Array α x✝ : Bool heq✝ : p x = true h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp ** case h.h.h.cons.h_1.a α : Type u_1 p : α → Bool l : List α x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs acc : Array α x✝ : Bool heq✝ : p x = true h : l = acc.data ++ x :: xs ⊢ l = (Array.push acc x).data ++ xs ** simp ** case h.h.h.cons.h_1.a α : Type u_1 p : α → Bool l : List α x : α xs : List α IH : ∀ (acc : Array α), l = acc.data ++ xs → takeWhileTR.go p l xs acc = acc.data ++ takeWhile p xs acc : Array α x✝ : Bool heq✝ : p x = true h : l = acc.data ++ x :: xs ⊢ l = acc.data ++ x :: xs ** exact h ** Qed
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.