Datasets:

akjadhav
/

leandojo-lean4-formal-informal-strings-split

Dataset card Data Studio Files Files and versions Community

Split (3)

train · 47.4k rows

formal stringlengths 41 427k	informal stringclasses 1 value
Std.RBNode.forM_eq_forM_toList m : Type u_1 → Type u_2 α : Type u_3 f : α → m PUnit inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ forM f t = List.forM (toList t) f induction t <;> simp [] * Qed
Std.RBNode.foldlM_eq_foldlM_toList m : Type u_1 → Type u_2 α : Type u_3 a✝ : Type u_1 f : a✝ → α → m a✝ init : a✝ inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ foldlM f init t = List.foldlM f init (toList t) induction t generalizing init <;> simp [] * Qed
Std.RBNode.forIn_visit_eq_bindList m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 f : α → α✝ → m (ForInStep α✝) init : α✝ inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ forIn.visit f t init = ForInStep.bindList f (toList t) (ForInStep.yield init) induction t generalizing init <;> simp [, forIn.visit] * Qed
Std.RBNode.forIn_eq_forIn_toList m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 init : α✝ f : α → α✝ → m (ForInStep α✝) inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ forIn t init f = forIn (toList t) init f simp [forIn, RBNode.forIn] m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 init : α✝ f : α → α✝ → m (ForInStep α✝) inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ ForInStep.run <$> forIn.visit f t init = forIn (toList t) init f rw [List.forIn_eq_bindList, forIn_visit_eq_bindList] ** Qed
Std.RBNode.Stream.foldr_cons α : Type u_1 t : RBNode.Stream α l : List α ⊢ foldr (fun x x_1 => x :: x_1) t l = toList t ++ l unfold toList α : Type u_1 t : RBNode.Stream α l : List α ⊢ foldr (fun x x_1 => x :: x_1) t l = foldr (fun x x_1 => x :: x_1) t [] ++ l apply Eq.symm case h α : Type u_1 t : RBNode.Stream α l : List α ⊢ foldr (fun x x_1 => x :: x_1) t [] ++ l = foldr (fun x x_1 => x :: x_1) t l induction t <;> simp [, foldr, RBNode.foldr_cons] * Qed
Std.RBNode.Stream.toList_cons α : Type u_1 x : α r : RBNode α s : RBNode.Stream α ⊢ toList (cons x r s) = x :: RBNode.toList r ++ toList s rw [toList, toList, foldr, RBNode.foldr_cons] α : Type u_1 x : α r : RBNode α s : RBNode.Stream α ⊢ x :: (RBNode.toList r ++ foldr (fun x x_1 => x :: x_1) s []) = x :: RBNode.toList r ++ foldr (fun x x_1 => x :: x_1) s [] rfl ** Qed
Std.RBNode.Stream.foldr_eq_foldr_toList α : Type u_1 α✝ : Type u_2 f : α → α✝ → α✝ init : α✝ s : RBNode.Stream α ⊢ foldr f s init = List.foldr f init (toList s) induction s <;> simp [, RBNode.foldr_eq_foldr_toList] * Qed
Std.RBNode.Stream.foldl_eq_foldl_toList α : Type u_1 α✝ : Type u_2 f : α✝ → α → α✝ init : α✝ t : RBNode.Stream α ⊢ foldl f init t = List.foldl f init (toList t) induction t generalizing init <;> simp [, RBNode.foldl_eq_foldl_toList] * Qed
Std.RBNode.Stream.forIn_eq_forIn_toList m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 init : α✝ f : α → α✝ → m (ForInStep α✝) inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ forIn t init f = forIn (RBNode.toList t) init f simp [forIn, RBNode.forIn] m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 init : α✝ f : α → α✝ → m (ForInStep α✝) inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ ForInStep.run <$> forIn.visit f t init = forIn (RBNode.toList t) init f rw [List.forIn_eq_bindList, forIn_visit_eq_bindList] ** Qed
Std.RBNode.toStream_toList' α : Type u_1 t : RBNode α s : RBNode.Stream α ⊢ Stream.toList (toStream t s) = toList t ++ Stream.toList s induction t generalizing s <;> simp [, toStream] * Qed
Std.RBNode.toStream_toList α : Type u_1 t : RBNode α ⊢ Stream.toList (toStream t Stream.nil) = toList t simp [toStream_toList'] ** Qed
Std.RBNode.ordered_iff α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp t ↔ List.Pairwise (cmpLT cmp) (toList t) induction t with \| nil => simp \| node c l v r ihl ihr => simp [, List.pairwise_append, Ordered, All_def, and_assoc, and_left_comm, and_comm, imp_and, forall_and] exact fun _ _ hl hr a ha b hb => (hl _ ha).trans (hr _ hb) * case nil α : Type u_1 cmp : α → α → Ordering ⊢ Ordered cmp nil ↔ List.Pairwise (cmpLT cmp) (toList nil) simp case node α : Type u_1 cmp : α → α → Ordering c : RBColor l : RBNode α v : α r : RBNode α ihl : Ordered cmp l ↔ List.Pairwise (cmpLT cmp) (toList l) ihr : Ordered cmp r ↔ List.Pairwise (cmpLT cmp) (toList r) ⊢ Ordered cmp (node c l v r) ↔ List.Pairwise (cmpLT cmp) (toList (node c l v r)) ** simp [, List.pairwise_append, Ordered, All_def, and_assoc, and_left_comm, and_comm, imp_and, forall_and] * case node α : Type u_1 cmp : α → α → Ordering c : RBColor l : RBNode α v : α r : RBNode α ihl : Ordered cmp l ↔ List.Pairwise (cmpLT cmp) (toList l) ihr : Ordered cmp r ↔ List.Pairwise (cmpLT cmp) (toList r) ⊢ List.Pairwise (cmpLT cmp) (toList l) → List.Pairwise (cmpLT cmp) (toList r) → (∀ (x : α), x ∈ l → cmpLT cmp x v) → (∀ (x : α), x ∈ r → cmpLT cmp v x) → ∀ (x : α), x ∈ l → ∀ (a : α), a ∈ r → cmpLT cmp x a exact fun _ _ hl hr a ha b hb => (hl _ ha).trans (hr _ hb) Qed
Std.RBNode.setBlack_toList α : Type u_1 t : RBNode α ⊢ toList (setBlack t) = toList t cases t <;> simp [setBlack] ** Qed
Std.RBNode.setRed_toList α : Type u_1 t : RBNode α ⊢ toList (setRed t) = toList t cases t <;> simp [setRed] ** Qed
Std.RBNode.balance1_toList α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (balance1 l v r) = toList l ++ v :: toList r unfold balance1 α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (match l, v, r with \| node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d) \| node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d) \| a, x, b => node black a x b) = toList l ++ v :: toList r split <;> simp ** Qed
Std.RBNode.balance2_toList α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (balance2 l v r) = toList l ++ v :: toList r unfold balance2 α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (match l, v, r with \| a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d) \| a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d) \| a, x, b => node black a x b) = toList l ++ v :: toList r split <;> simp ** Qed
Std.RBNode.balLeft_toList α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (balLeft l v r) = toList l ++ v :: toList r unfold balLeft α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (match l with \| node red a x b => node red (node black a x b) v r \| l => match r with \| node black a y b => balance2 l v (node red a y b) \| node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c)) \| r => node red l v r) = toList l ++ v :: toList r split <;> (try simp) case h_2 α : Type u_1 l : RBNode α v : α r l✝ : RBNode α x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), l = node red a x b → False ⊢ toList (match r with \| node black a y b => balance2 l v (node red a y b) \| node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c)) \| r => node red l v r) = toList l ++ v :: toList r split <;> simp case h_1 α : Type u_1 v : α r l✝ a✝ : RBNode α x✝ : α b✝ : RBNode α ⊢ toList (node red (node black a✝ x✝ b✝) v r) = toList (node red a✝ x✝ b✝) ++ v :: toList r try simp case h_1 α : Type u_1 v : α r l✝ a✝ : RBNode α x✝ : α b✝ : RBNode α ⊢ toList (node red (node black a✝ x✝ b✝) v r) = toList (node red a✝ x✝ b✝) ++ v :: toList r simp ** Qed
Std.RBNode.balRight_toList α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (balRight l v r) = toList l ++ v :: toList r unfold balRight α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (match r with \| node red b y c => node red l v (node black b y c) \| r => match l with \| node black a x b => balance1 (node red a x b) v r \| node red a x (node black b y c) => node red (balance1 (setRed a) x b) y (node black c v r) \| l => node red l v r) = toList l ++ v :: toList r split <;> (try simp) case h_2 α : Type u_1 l : RBNode α v : α r l✝ : RBNode α x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), r = node red a x b → False ⊢ toList (match l with \| node black a x b => balance1 (node red a x b) v r \| node red a x (node black b y c) => node red (balance1 (setRed a) x b) y (node black c v r) \| l => node red l v r) = toList l ++ v :: toList r split <;> simp case h_1 α : Type u_1 l : RBNode α v : α l✝ a✝ : RBNode α x✝ : α b✝ : RBNode α ⊢ toList (node red l v (node black a✝ x✝ b✝)) = toList l ++ v :: toList (node red a✝ x✝ b✝) try simp case h_1 α : Type u_1 l : RBNode α v : α l✝ a✝ : RBNode α x✝ : α b✝ : RBNode α ⊢ toList (node red l v (node black a✝ x✝ b✝)) = toList l ++ v :: toList (node red a✝ x✝ b✝) simp ** Qed
Std.RBNode.size_eq α : Type u_1 t : RBNode α ⊢ size t = List.length (toList t) induction t <;> simp [, size] * case node α : Type u_1 c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : size l✝ = List.length (toList l✝) r_ih✝ : size r✝ = List.length (toList r✝) ⊢ List.length (toList l✝) + List.length (toList r✝) + 1 = List.length (toList l✝) + Nat.succ (List.length (toList r✝)) rfl Qed
Std.RBNode.Path.rootOrdered_iff α : Type u_1 cmp : α → α → Ordering v : α p : Path α hp : Ordered cmp p ⊢ RootOrdered cmp p v ↔ (∀ (a : α), a ∈ listL p → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR p → cmpLT cmp v a induction p with (simp [All_def] at hp; simp [, and_assoc, and_left_comm, and_comm, or_imp, forall_and]) \| left _ _ x _ ih => exact fun vx _ _ _ ha => vx.trans (hp.2.1 _ ha) \| right _ _ x _ ih => exact fun xv _ _ _ ha => (hp.2.1 _ ha).trans xv * case root α : Type u_1 cmp : α → α → Ordering v : α hp : Ordered cmp root ⊢ RootOrdered cmp root v ↔ (∀ (a : α), a ∈ listL root → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR root → cmpLT cmp v a simp [All_def] at hp case root α : Type u_1 cmp : α → α → Ordering v : α hp : True ⊢ RootOrdered cmp root v ↔ (∀ (a : α), a ∈ listL root → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR root → cmpLT cmp v a ** simp [, and_assoc, and_left_comm, and_comm, or_imp, forall_and] * case left α : Type u_1 cmp : α → α → Ordering v : α c✝ : RBColor parent✝ : Path α x : α r✝ : RBNode α ih : Ordered cmp parent✝ → (RootOrdered cmp parent✝ v ↔ (∀ (a : α), a ∈ listL parent✝ → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR parent✝ → cmpLT cmp v a) hp : Ordered cmp parent✝ ∧ (∀ (x_1 : α), x_1 ∈ r✝ → cmpLT cmp x x_1) ∧ RootOrdered cmp parent✝ x ∧ (∀ (x : α), x ∈ r✝ → RootOrdered cmp parent✝ x) ∧ RBNode.Ordered cmp r✝ ⊢ cmpLT cmp v x → (∀ (a : α), a ∈ listL parent✝ → cmpLT cmp a v) → (∀ (a : α), a ∈ listR parent✝ → cmpLT cmp v a) → ∀ (x : α), x ∈ r✝ → cmpLT cmp v x exact fun vx _ _ _ ha => vx.trans (hp.2.1 _ ha) case right α : Type u_1 cmp : α → α → Ordering v : α c✝ : RBColor l✝ : RBNode α x : α parent✝ : Path α ih : Ordered cmp parent✝ → (RootOrdered cmp parent✝ v ↔ (∀ (a : α), a ∈ listL parent✝ → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR parent✝ → cmpLT cmp v a) hp : Ordered cmp parent✝ ∧ (∀ (x_1 : α), x_1 ∈ l✝ → cmpLT cmp x_1 x) ∧ RootOrdered cmp parent✝ x ∧ (∀ (x : α), x ∈ l✝ → RootOrdered cmp parent✝ x) ∧ RBNode.Ordered cmp l✝ ⊢ cmpLT cmp x v → (∀ (a : α), a ∈ listL parent✝ → cmpLT cmp a v) → (∀ (a : α), a ∈ listR parent✝ → cmpLT cmp v a) → ∀ (x : α), x ∈ l✝ → cmpLT cmp x v exact fun xv _ _ _ ha => (hp.2.1 _ ha).trans xv Qed
Std.RBNode.Path.fill_toList α : Type u_1 t : RBNode α p : Path α ⊢ toList (fill p t) = withList p (toList t) induction p generalizing t <;> simp [] * Qed
Std.RBNode.Path.ins_toList α : Type u_1 t : RBNode α p : Path α ⊢ toList (ins p t) = withList p (toList t) match p with \| .root \| .left red .. \| .right red .. \| .left black .. \| .right black .. => simp [ins, ins_toList] α : Type u_1 t : RBNode α p : Path α l✝ : RBNode α v✝ : α parent✝ : Path α ⊢ toList (ins (right black l✝ v✝ parent✝) t) = withList (right black l✝ v✝ parent✝) (toList t) simp [ins, ins_toList] ** Qed
Std.RBNode.mem_insert α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t ⊢ v' ∈ insert cmp t v ↔ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v refine ⟨fun h => ?_, fun \| .inl ⟨h₁, h₂⟩ => ?_ \| .inr h => ?_⟩ α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' ∈ insert cmp t v p : Path α e : zoom (cmp v) t Path.root = (nil, p) ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v let ⟨_, _, h₁, h₂⟩ := exists_insert_toList_zoom_nil ht e α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' ∈ insert cmp t v p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v simp [← mem_toList, h₂] at h α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' = v ∨ v' ∈ w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v rw [← or_assoc, or_right_comm] at h α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : (v' ∈ w✝¹ ∨ v' ∈ w✝) ∨ v' = v ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v refine h.imp_left fun h => ?_ α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : (v' ∈ w✝¹ ∨ v' ∈ w✝) ∨ v' = v h : v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' simp [← mem_toList, h₁, h] α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : (v' ∈ w✝¹ ∨ v' ∈ w✝) ∨ v' = v h : v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ ¬find? (cmp v) t = some v' rw [find?_eq_zoom, e] α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : (v' ∈ w✝¹ ∨ v' ∈ w✝) ∨ v' = v h : v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ ¬root? (nil, p).fst = some v' intro. α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' ∈ insert cmp t v c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v let ⟨_, _, h₁, h₂⟩ := exists_insert_toList_zoom_node ht e α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' ∈ insert cmp t v c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v simp [← mem_toList, h₂] at h α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' = v ∨ v' ∈ w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v simp [← mem_toList, h₁] α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' = v ∨ v' ∈ w✝ ⊢ (v' ∈ w✝¹ ∨ v' = v✝ ∨ v' ∈ w✝) ∧ ¬find? (cmp v) t = some v' ∨ v' = v rw [or_left_comm] at h ⊢ α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' = v ∨ v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ (v' = v✝ ∨ v' ∈ w✝¹ ∨ v' ∈ w✝) ∧ ¬find? (cmp v) t = some v' ∨ v' = v rcases h with _\|h <;> simp [] * case inr α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ ¬find? (cmp v) t = some v' ∨ v' = v refine .inl fun h => ?_ case inr α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : v' ∈ w✝¹ ∨ v' ∈ w✝ h : find? (cmp v) t = some v' ⊢ False rw [find?_eq_zoom, e] at h case inr α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : v' ∈ w✝¹ ∨ v' ∈ w✝ h : root? (node c✝ l✝ v✝ r✝, p).fst = some v' ⊢ False cases h case inr.refl α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ r✝ : RBNode α p : Path α w✝¹ w✝ : List α h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ e : zoom (cmp v) t Path.root = (node c✝ l✝ v' r✝, p) h₁ : toList t = w✝¹ ++ v' :: w✝ ⊢ False suffices cmpLT cmp v' v' by cases OrientedCmp.cmp_refl.symm.trans this.1 case inr.refl α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ r✝ : RBNode α p : Path α w✝¹ w✝ : List α h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ e : zoom (cmp v) t Path.root = (node c✝ l✝ v' r✝, p) h₁ : toList t = w✝¹ ++ v' :: w✝ ⊢ cmpLT cmp v' v' have := ht₂.toList_sorted case inr.refl α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ r✝ : RBNode α p : Path α w✝¹ w✝ : List α h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ e : zoom (cmp v) t Path.root = (node c✝ l✝ v' r✝, p) h₁ : toList t = w✝¹ ++ v' :: w✝ this : List.Pairwise (cmpLT cmp) (toList t) ⊢ cmpLT cmp v' v' simp [h₁, List.pairwise_append] at this α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ r✝ : RBNode α p : Path α w✝¹ w✝ : List α h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ e : zoom (cmp v) t Path.root = (node c✝ l✝ v' r✝, p) h₁ : toList t = w✝¹ ++ v' :: w✝ this : cmpLT cmp v' v' ⊢ False cases OrientedCmp.cmp_refl.symm.trans this.1 case refine_2 α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h₁ : v' ∈ t h₂ : find? (cmp v) t ≠ some v' ⊢ v' ∈ insert cmp t v exact (mem_insert_of_mem ht h₁).resolve_right fun h' => h₂ <\| ht₂.find?_some.2 ⟨h₁, h'⟩ case refine_3 α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' = v ⊢ v' ∈ insert cmp t v exact h ▸ mem_insert_self ht Qed
Std.RBSet.mem_iff_mem_toList α : Type u_1 cmp : α → α → Ordering x : α t : RBSet α cmp ⊢ (∃ y, y ∈ t.val ∧ cmp x y = Ordering.eq) ↔ ∃ y, y ∈ toList t ∧ cmp x y = Ordering.eq simp [mem_toList] ** Qed
Std.RBSet.find?_some α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp t : RBSet α cmp ⊢ y ∈ t.val ∧ cmp x y = Ordering.eq ↔ y ∈ toList t ∧ cmp x y = Ordering.eq simp [mem_toList] ** Qed
Std.RBSet.find?_congr α : Type u_1 cmp : α → α → Ordering v₁ v₂ : α inst✝ : TransCmp cmp t : RBSet α cmp h : cmp v₁ v₂ = Ordering.eq ⊢ find? t v₁ = find? t v₂ simp [find?, TransCmp.cmp_congr_left' h] ** Qed
Nat.strongRec_eq motive : Nat → Sort u_1 ind : (n : Nat) → ((m : Nat) → m < n → motive m) → motive n t : Nat ⊢ Nat.strongRec ind t = ind t fun m x => Nat.strongRec ind m conv => lhs; unfold Nat.strongRec ** Qed
Nat.recDiagAux_zero_left motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) n : Nat ⊢ Nat.recDiagAux zero_left zero_right succ_succ 0 n = zero_left n cases n <;> rfl ** Qed
Nat.recDiagAux_zero_right motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) m : Nat h : autoParam (zero_left 0 = zero_right 0) _auto✝ ⊢ Nat.recDiagAux zero_left zero_right succ_succ m 0 = zero_right m cases m case zero motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) h : autoParam (zero_left 0 = zero_right 0) _auto✝ ⊢ Nat.recDiagAux zero_left zero_right succ_succ zero 0 = zero_right zero case succ motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) h : autoParam (zero_left 0 = zero_right 0) _auto✝ n✝ : Nat ⊢ Nat.recDiagAux zero_left zero_right succ_succ (succ n✝) 0 = zero_right (succ n✝) exact h case succ motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) h : autoParam (zero_left 0 = zero_right 0) _auto✝ n✝ : Nat ⊢ Nat.recDiagAux zero_left zero_right succ_succ (succ n✝) 0 = zero_right (succ n✝) rfl ** Qed
Nat.recDiag_zero_succ motive : Nat → Nat → Sort u_1 zero_zero : motive 0 0 zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1) succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) n : Nat ⊢ Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 (n + 1) = zero_succ n (Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 n) simp [Nat.recDiag] motive : Nat → Nat → Sort u_1 zero_zero : motive 0 0 zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1) succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) n : Nat ⊢ recDiag.left zero_zero zero_succ (n + 1) = zero_succ n (recDiag.left zero_zero zero_succ n) rfl ** Qed
Nat.recDiag_succ_zero motive : Nat → Nat → Sort u_1 zero_zero : motive 0 0 zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1) succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) m : Nat ⊢ Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m + 1) 0 = succ_zero m (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m 0) simp [Nat.recDiag] motive : Nat → Nat → Sort u_1 zero_zero : motive 0 0 zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1) succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) m : Nat ⊢ Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ (m + 1) 0 = succ_zero m (Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ m 0) cases m <;> rfl ** Qed
Nat.eq_zero_or_eq_succ_pred n : Nat ⊢ n = 0 ∨ n = succ (pred n) cases n <;> simp ** Qed
Nat.succ_eq_one_add n : Nat ⊢ succ n = 1 + n rw [Nat.succ_eq_add_one, Nat.add_comm] ** Qed
Nat.pred_inj a b : Nat x✝¹ : 0 < a + 1 x✝ : 0 < b + 1 h : pred (a + 1) = pred (b + 1) ⊢ a + 1 = b + 1 rw [show a = b from h] ** Qed
Nat.eq_zero_of_add_eq_zero_right m : Nat ⊢ 0 + m = 0 → 0 = 0 simp [Nat.zero_add] n m : Nat h : n + 1 + m = 0 ⊢ n + 1 = 0 rw [add_one, succ_add] at h n m : Nat h : succ (n + m) = 0 ⊢ n + 1 = 0 cases succ_ne_zero _ h ** Qed
Nat.succ_add_eq_succ_add n m : Nat ⊢ succ n + m = n + succ m simp [succ_add, add_succ] ** Qed
Nat.one_add n : Nat ⊢ 1 + n = succ n simp [Nat.add_comm] ** Qed
Nat.lt_of_add_lt_add_left k n m : Nat h : k + n < k + m heq : n = m ⊢ k + m < k + m rwa [heq] at h ** Qed
Nat.lt_of_add_lt_add_right a b c : Nat h : a + b < c + b ⊢ b + a < b + c rwa [Nat.add_comm b a, Nat.add_comm b c] ** Qed
Nat.lt_add_of_pos_left n k : Nat h : 0 < k ⊢ n < k + n rw [Nat.add_comm] n k : Nat h : 0 < k ⊢ n < n + k exact Nat.lt_add_of_pos_right h ** Qed
Nat.pos_of_lt_add_left n k : Nat h : n < k + n ⊢ 0 + ?m.18605 h < k + ?m.18605 h rw [Nat.zero_add] n k : Nat h : n < k + n ⊢ ?m.18605 h < k + ?m.18605 h ⊢ {n k : Nat} → n < k + n → Nat exact h ** Qed
Nat.add_pos_right n m : Nat h : 0 < n ⊢ 0 < m + n rw [Nat.add_comm] n m : Nat h : 0 < n ⊢ 0 < n + m exact add_pos_left h m ** Qed
Nat.le_of_le_of_sub_le_sub_right n m k : Nat h₀ : succ k ≤ succ m h₁ : succ n - succ k ≤ succ m - succ k ⊢ succ n ≤ succ m simp [succ_sub_succ] at h₁ n m k : Nat h₀ : succ k ≤ succ m h₁ : n - k ≤ m - k ⊢ succ n ≤ succ m exact succ_le_succ <\| Nat.le_of_le_of_sub_le_sub_right (le_of_succ_le_succ h₀) h₁ ** Qed
Nat.add_le_to_le_sub x y k : Nat h : k ≤ y ⊢ x + k ≤ y ↔ x ≤ y - k rw [← Nat.add_sub_cancel x k, Nat.sub_le_sub_iff_right h, Nat.add_sub_cancel] ** Qed
Nat.le_of_sub_eq_zero n : Nat H : n - 0 = 0 ⊢ n ≤ 0 rw [Nat.sub_zero] at H n : Nat H : n = 0 ⊢ n ≤ 0 simp [H] n m : Nat H : n + 1 - (m + 1) = 0 ⊢ n - m = 0 simp [Nat.add_sub_add_right] at H n m : Nat H : n - m = 0 ⊢ n - m = 0 exact H ** Qed
Nat.sub_eq_iff_eq_add a b c : Nat ab : b ≤ a c_eq : a - b = c ⊢ a = c + b rw [c_eq.symm, Nat.sub_add_cancel ab] a b c : Nat ab : b ≤ a a_eq : a = c + b ⊢ a - b = c rw [a_eq, Nat.add_sub_cancel] ** Qed
Nat.lt_of_sub_eq_succ m n l : Nat H : m - n = succ l H' : m ≤ n ⊢ False simp [Nat.sub_eq_zero_of_le H'] at H ** Qed
Nat.sub_le_sub_left n m k a : Nat h : n ≤ n + a ⊢ k - (n + a) ≤ k - n rw [← Nat.sub_sub] n m k a : Nat h : n ≤ n + a ⊢ k - n - a ≤ k - n apply sub_le ** Qed
Nat.succ_sub_sub_succ n m k : Nat ⊢ succ n - m - succ k = n - m - k rw [Nat.sub_sub, Nat.sub_sub, add_succ, succ_sub_succ] ** Qed
Nat.sub_right_comm m n k : Nat ⊢ m - n - k = m - k - n rw [Nat.sub_sub, Nat.sub_sub, Nat.add_comm] ** Qed
Nat.sub_pos_of_lt m n : Nat h : m < n ⊢ 0 < n - m apply Nat.lt_of_add_lt_add_right (b := m) m n : Nat h : m < n ⊢ 0 + m < n - m + m rwa [Nat.zero_add, Nat.sub_add_cancel (Nat.le_of_lt h)] ** Qed
Nat.sub_add_comm n m k : Nat h : k ≤ n ⊢ n + m - k = n - k + m rw [Nat.sub_eq_iff_eq_add (Nat.le_trans h (Nat.le_add_right ..))] n m k : Nat h : k ≤ n ⊢ n + m = n - k + m + k rwa [Nat.add_right_comm, Nat.sub_add_cancel] ** Qed
Nat.sub_one_sub_lt i n : Nat h : i < n ⊢ n - 1 - i < n rw [Nat.sub_sub] i n : Nat h : i < n ⊢ n - (1 + i) < n apply Nat.sub_lt (Nat.lt_of_lt_of_le (Nat.zero_lt_succ _) h) i n : Nat h : i < n ⊢ 0 < 1 + i rw [Nat.add_comm] i n : Nat h : i < n ⊢ 0 < i + 1 apply Nat.zero_lt_succ ** Qed
Nat.sub_lt_self a b : Nat h₀ : 0 < a h₁ : a ≤ b ⊢ b - a < b apply sub_lt _ h₀ a b : Nat h₀ : 0 < a h₁ : a ≤ b ⊢ 0 < b apply Nat.lt_of_lt_of_le h₀ h₁ ** Qed
Nat.add_sub_cancel' n m : Nat h : m ≤ n ⊢ m + (n - m) = n rw [Nat.add_comm, Nat.sub_add_cancel h] ** Qed
Nat.le_sub_iff_add_le x y k : Nat h : k ≤ y ⊢ x ≤ y - k ↔ x + k ≤ y rw [← Nat.add_sub_cancel x k, Nat.sub_le_sub_iff_right h, Nat.add_sub_cancel] ** Qed
Nat.sub_le_sub_iff_left n m k : Nat hn : n ≤ k ⊢ k - m ≤ k - n ↔ n ≤ m refine ⟨fun h => ?_, Nat.sub_le_sub_left _⟩ n m k : Nat hn : n ≤ k h : k - m ≤ k - n ⊢ n ≤ m rwa [Nat.sub_le_iff_le_add', ← Nat.add_sub_assoc hn, le_sub_iff_add_le (Nat.le_trans hn (Nat.le_add_left ..)), Nat.add_comm, Nat.add_le_add_iff_right] at h ** Qed
Nat.le_min a b c : Nat x✝ : a ≤ b ∧ a ≤ c h₁ : a ≤ b h₂ : a ≤ c ⊢ a ≤ min b c rw [Nat.min_def] a b c : Nat x✝ : a ≤ b ∧ a ≤ c h₁ : a ≤ b h₂ : a ≤ c ⊢ a ≤ if b ≤ c then b else c split <;> assumption ** Qed
Nat.min_eq_left a b : Nat h : a ≤ b ⊢ min a b = a simp [Nat.min_def, h] ** Qed
Nat.min_eq_right a b : Nat h : b ≤ a ⊢ min a b = b rw [Nat.min_comm a b] a b : Nat h : b ≤ a ⊢ min b a = b exact Nat.min_eq_left h ** Qed
Nat.max_le a b c : Nat x✝ : a ≤ c ∧ b ≤ c h₁ : a ≤ c h₂ : b ≤ c ⊢ max a b ≤ c rw [Nat.max_def] a b c : Nat x✝ : a ≤ c ∧ b ≤ c h₁ : a ≤ c h₂ : b ≤ c ⊢ (if a ≤ b then b else a) ≤ c split <;> assumption ** Qed
Nat.max_eq_right a b : Nat h : a ≤ b ⊢ max a b = b simp [Nat.max_def, h, Nat.not_lt.2 h] ** Qed
Nat.max_eq_left a b : Nat h : b ≤ a ⊢ max a b = a rw [← Nat.max_comm b a] a b : Nat h : b ≤ a ⊢ max b a = a exact Nat.max_eq_right h ** Qed
Nat.min_succ_succ x y : Nat ⊢ min (succ x) (succ y) = succ (min x y) simp [Nat.min_def, succ_le_succ_iff] x y : Nat ⊢ (if x ≤ y then succ x else succ y) = succ (if x ≤ y then x else y) split <;> rfl ** Qed
Nat.sub_eq_sub_min n m : Nat ⊢ n - m = n - min n m rw [Nat.min_def] n m : Nat ⊢ n - m = n - if n ≤ m then n else m split case inl n m : Nat h✝ : n ≤ m ⊢ n - m = n - n rw [Nat.sub_eq_zero_of_le ‹n ≤ m›, Nat.sub_self] case inr n m : Nat h✝ : ¬n ≤ m ⊢ n - m = n - m rfl ** Qed
Nat.mul_right_comm ** n m k : Nat ⊢ n * m * k = n * k * m rw [Nat.mul_assoc, Nat.mul_comm m, ← Nat.mul_assoc] Qed
Nat.mul_mul_mul_comm ** a b c d : Nat ⊢ a * b * (c * d) = a * c * (b * d) rw [Nat.mul_assoc, Nat.mul_assoc, Nat.mul_left_comm b] Qed
Nat.mul_two ** n : Nat ⊢ n * 2 = n + n simp [Nat.mul_succ] Qed
Nat.two_mul ** n : Nat ⊢ 2 * n = n + n simp [Nat.succ_mul] Qed
Nat.mul_eq_zero ** n✝ m✝ : Nat h✝ : n✝ * m✝ = 0 n m : Nat h : (n + 1) * m = 0 ⊢ n + 1 = 0 ∨ m = 0 rw [succ_mul] at h n✝ m✝ : Nat h✝ : n✝ * m✝ = 0 n m : Nat h : n * m + m = 0 ⊢ n + 1 = 0 ∨ m = 0 exact .inr (Nat.eq_zero_of_add_eq_zero_left h) n m : Nat h : m = 0 ⊢ n * m = 0 simp [h] Qed
Nat.mul_ne_zero_iff ** n m : Nat ⊢ n * m ≠ 0 ↔ n ≠ 0 ∧ m ≠ 0 simp [mul_eq_zero, not_or] Qed
Nat.mul_le_mul_of_nonneg_left ** a b c : Nat h₁ : a ≤ b ⊢ c * a ≤ c * b if hba : b ≤ a then simp [Nat.le_antisymm hba h₁] else if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul] else exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) a b c : Nat h₁ : a ≤ b hba : b ≤ a ⊢ c * a ≤ c * b simp [Nat.le_antisymm hba h₁] a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a ⊢ c * a ≤ c * b if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul] else exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a hc0 : c ≤ 0 ⊢ c * a ≤ c * b simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul] a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a hc0 : ¬c ≤ 0 ⊢ c * a ≤ c * b exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) Qed
Nat.mul_le_mul_of_nonneg_right ** a b c : Nat h₁ : a ≤ b ⊢ a * c ≤ b * c if hba : b ≤ a then simp [Nat.le_antisymm hba h₁] else if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero] else exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) a b c : Nat h₁ : a ≤ b hba : b ≤ a ⊢ a * c ≤ b * c simp [Nat.le_antisymm hba h₁] a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a ⊢ a * c ≤ b * c if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero] else exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a hc0 : c ≤ 0 ⊢ a * c ≤ b * c simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero] a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a hc0 : ¬c ≤ 0 ⊢ a * c ≤ b * c exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) Qed
Nat.succ_mul_succ_eq ** a b : Nat ⊢ succ a * succ b = a * b + a + b + 1 rw [mul_succ, succ_mul, Nat.add_right_comm _ a] a b : Nat ⊢ a * b + b + succ a = a * b + b + a + 1 rfl Qed
Nat.mul_self_sub_mul_self_eq ** a b : Nat ⊢ a * a - b * b = (a + b) * (a - b) ** rw [Nat.mul_sub_left_distrib, Nat.right_distrib, Nat.right_distrib, Nat.mul_comm b a, Nat.add_comm (aa) (ab), Nat.add_sub_add_left] ** Qed
Nat.div_one n : Nat ⊢ n / 1 = n have := mod_add_div n 1 ** n : Nat this : n % 1 + 1 * (n / 1) = n ⊢ n / 1 = n rwa [mod_one, Nat.zero_add, Nat.one_mul] at this Qed
Nat.div_zero n : Nat ⊢ n / 0 = 0 rw [div_eq] n : Nat ⊢ (if 0 < 0 ∧ 0 ≤ n then (n - 0) / 0 + 1 else 0) = 0 simp [Nat.lt_irrefl] ** Qed
Nat.le_div_iff_mul_le ** k x y : Nat k0 : 0 < k ⊢ x ≤ y / k ↔ x * k ≤ y ** induction y, k using mod.inductionOn generalizing x with (rw [div_eq]; simp [h]; cases x with \| zero => simp [zero_le] \| succ x => ?_) \| base y k h => simp [not_succ_le_zero x, succ_mul, Nat.add_comm] refine Nat.lt_of_lt_of_le ?_ (Nat.le_add_right ..) exact Nat.not_le.1 fun h' => h ⟨k0, h'⟩ \| ind y k h IH => rw [← add_one, Nat.add_le_add_iff_right, IH k0, succ_mul, ← Nat.add_sub_cancel (xk) k, Nat.sub_le_sub_iff_right h.2, Nat.add_sub_cancel] * case ind y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) x : Nat k0 : 0 < k ⊢ x ≤ y / k ↔ x * k ≤ y rw [div_eq] case ind y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) x : Nat k0 : 0 < k ⊢ (x ≤ if 0 < k ∧ k ≤ y then (y - k) / k + 1 else 0) ↔ x * k ≤ y simp [h] case ind y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) x : Nat k0 : 0 < k ⊢ x ≤ (y - k) / k + 1 ↔ x * k ≤ y cases x with \| zero => simp [zero_le] \| succ x => ?_ case ind.zero y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) k0 : 0 < k ⊢ zero ≤ (y - k) / k + 1 ↔ zero * k ≤ y simp [zero_le] case base.succ y k : Nat h : ¬(0 < k ∧ k ≤ y) k0 : 0 < k x : Nat ⊢ succ x = 0 ↔ succ x * k ≤ y simp [not_succ_le_zero x, succ_mul, Nat.add_comm] case base.succ y k : Nat h : ¬(0 < k ∧ k ≤ y) k0 : 0 < k x : Nat ⊢ y < k + x * k refine Nat.lt_of_lt_of_le ?_ (Nat.le_add_right ..) case base.succ y k : Nat h : ¬(0 < k ∧ k ≤ y) k0 : 0 < k x : Nat ⊢ y < k exact Nat.not_le.1 fun h' => h ⟨k0, h'⟩ case ind.succ y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) k0 : 0 < k x : Nat ⊢ succ x ≤ (y - k) / k + 1 ↔ succ x * k ≤ y ** rw [← add_one, Nat.add_le_add_iff_right, IH k0, succ_mul, ← Nat.add_sub_cancel (xk) k, Nat.sub_le_sub_iff_right h.2, Nat.add_sub_cancel] * Qed
Nat.div_le_of_le_mul ** m n : Nat x✝ : m ≤ 0 * n ⊢ m / 0 ≤ n simp [Nat.div_zero, n.zero_le] m n k : Nat h : m ≤ succ k * n ⊢ m / succ k ≤ n ** suffices succ k * (m / succ k) ≤ succ k * n from Nat.le_of_mul_le_mul_left this (zero_lt_succ _) ** m n k : Nat h : m ≤ succ k * n ⊢ succ k * (m / succ k) ≤ succ k * n ** have h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) := Nat.le_add_left _ _ ** m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) ⊢ succ k * (m / succ k) ≤ succ k * n ** have h2 : m % succ k + succ k * (m / succ k) = m := by rw [mod_add_div] ** m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) h2 : m % succ k + succ k * (m / succ k) = m ⊢ succ k * (m / succ k) ≤ succ k * n ** have h3 : m ≤ succ k * n := h ** m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) h2 : m % succ k + succ k * (m / succ k) = m h3 : m ≤ succ k * n ⊢ succ k * (m / succ k) ≤ succ k * n rw [← h2] at h3 m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) h2 : m % succ k + succ k * (m / succ k) = m h3 : m % succ k + succ k * (m / succ k) ≤ succ k * n ⊢ succ k * (m / succ k) ≤ succ k * n exact Nat.le_trans h1 h3 m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) ⊢ m % succ k + succ k * (m / succ k) = m rw [mod_add_div] Qed
Nat.div_eq_sub_div b a : Nat h₁ : 0 < b h₂ : b ≤ a ⊢ a / b = (a - b) / b + 1 rw [div_eq a, if_pos] case hc b a : Nat h₁ : 0 < b h₂ : b ≤ a ⊢ 0 < b ∧ b ≤ a constructor <;> assumption ** Qed
Nat.div_eq_of_lt a b : Nat h₀ : a < b ⊢ a / b = 0 rw [div_eq a, if_neg] case hnc a b : Nat h₀ : a < b ⊢ ¬(0 < b ∧ b ≤ a) intro h₁ case hnc a b : Nat h₀ : a < b h₁ : 0 < b ∧ b ≤ a ⊢ False apply Nat.not_le_of_gt h₀ h₁.right ** Qed
Nat.div_lt_iff_lt_mul ** k x y : Nat Hk : 0 < k ⊢ x / k < y ↔ x < y * k rw [← Nat.not_le, ← Nat.not_le] k x y : Nat Hk : 0 < k ⊢ ¬y ≤ x / k ↔ ¬y * k ≤ x exact not_congr (le_div_iff_mul_le Hk) Qed
Nat.sub_mul_div ** x n p : Nat h₁ : n * p ≤ x ⊢ (x - n * p) / n = x / n - p ** match eq_zero_or_pos n with \| .inl h₀ => rw [h₀, Nat.div_zero, Nat.div_zero, Nat.zero_sub] \| .inr h₀ => induction p with \| zero => rw [Nat.mul_zero, Nat.sub_zero, Nat.sub_zero] \| succ p IH => have h₂ : n * p ≤ x := Nat.le_trans (Nat.mul_le_mul_left _ (le_succ _)) h₁ have h₃ : x - n * p ≥ n := by apply Nat.le_of_add_le_add_right rw [Nat.sub_add_cancel h₂, Nat.add_comm] rw [mul_succ] at h₁ exact h₁ rw [sub_succ, ← IH h₂, div_eq_sub_div h₀ h₃] simp [add_one, Nat.pred_succ, mul_succ, Nat.sub_sub] ** x n p : Nat h₁ : n * p ≤ x h₀ : n = 0 ⊢ (x - n * p) / n = x / n - p rw [h₀, Nat.div_zero, Nat.div_zero, Nat.zero_sub] x n p : Nat h₁ : n * p ≤ x h₀ : n > 0 ⊢ (x - n * p) / n = x / n - p ** induction p with \| zero => rw [Nat.mul_zero, Nat.sub_zero, Nat.sub_zero] \| succ p IH => have h₂ : n * p ≤ x := Nat.le_trans (Nat.mul_le_mul_left _ (le_succ _)) h₁ have h₃ : x - n * p ≥ n := by apply Nat.le_of_add_le_add_right rw [Nat.sub_add_cancel h₂, Nat.add_comm] rw [mul_succ] at h₁ exact h₁ rw [sub_succ, ← IH h₂, div_eq_sub_div h₀ h₃] simp [add_one, Nat.pred_succ, mul_succ, Nat.sub_sub] ** case zero x n : Nat h₀ : n > 0 h₁ : n * zero ≤ x ⊢ (x - n * zero) / n = x / n - zero rw [Nat.mul_zero, Nat.sub_zero, Nat.sub_zero] case succ x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x ⊢ (x - n * succ p) / n = x / n - succ p ** have h₂ : n * p ≤ x := Nat.le_trans (Nat.mul_le_mul_left _ (le_succ _)) h₁ ** case succ x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ (x - n * succ p) / n = x / n - succ p ** have h₃ : x - n * p ≥ n := by apply Nat.le_of_add_le_add_right rw [Nat.sub_add_cancel h₂, Nat.add_comm] rw [mul_succ] at h₁ exact h₁ ** case succ x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x h₃ : x - n * p ≥ n ⊢ (x - n * succ p) / n = x / n - succ p rw [sub_succ, ← IH h₂, div_eq_sub_div h₀ h₃] case succ x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x h₃ : x - n * p ≥ n ⊢ (x - n * succ p) / n = pred ((x - n * p - n) / n + 1) simp [add_one, Nat.pred_succ, mul_succ, Nat.sub_sub] x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ x - n * p ≥ n apply Nat.le_of_add_le_add_right case a x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ n + ?b ≤ x - n * p + ?b case b x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ Nat rw [Nat.sub_add_cancel h₂, Nat.add_comm] case a x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ n * p + n ≤ x rw [mul_succ] at h₁ case a x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * p + n ≤ x h₂ : n * p ≤ x ⊢ n * p + n ≤ x exact h₁ Qed
Nat.div_mul_le_self ** m : Nat ⊢ m / 0 * 0 ≤ m simp Qed
Nat.add_div_right x z : Nat H : 0 < z ⊢ (x + z) / z = succ (x / z) rw [div_eq_sub_div H (Nat.le_add_left _ _), Nat.add_sub_cancel] ** Qed
Nat.add_div_left x z : Nat H : 0 < z ⊢ (z + x) / z = succ (x / z) rw [Nat.add_comm, add_div_right x H] ** Qed
Nat.mul_div_right ** n m : Nat H : 0 < m ⊢ m * n / m = n induction n <;> simp_all [mul_succ] Qed
Nat.mul_div_left ** m n : Nat H : 0 < n ⊢ m * n / n = m rw [Nat.mul_comm, mul_div_right _ H] Qed
Nat.div_self n : Nat H : 0 < n ⊢ n / n = 1 let t := add_div_right 0 H n : Nat H : 0 < n t : (0 + n) / n = succ (0 / n) := add_div_right 0 H ⊢ n / n = 1 rwa [Nat.zero_add, Nat.zero_div] at t ** Qed
Nat.add_mul_div_left ** x z y : Nat H : 0 < y ⊢ (x + y * z) / y = x / y + z induction z with \| zero => rw [Nat.mul_zero, Nat.add_zero, Nat.add_zero] \| succ z ih => rw [mul_succ, ← Nat.add_assoc, add_div_right _ H, ih]; rfl case zero x y : Nat H : 0 < y ⊢ (x + y * zero) / y = x / y + zero rw [Nat.mul_zero, Nat.add_zero, Nat.add_zero] case succ x y : Nat H : 0 < y z : Nat ih : (x + y * z) / y = x / y + z ⊢ (x + y * succ z) / y = x / y + succ z rw [mul_succ, ← Nat.add_assoc, add_div_right _ H, ih] case succ x y : Nat H : 0 < y z : Nat ih : (x + y * z) / y = x / y + z ⊢ succ (x / y + z) = x / y + succ z rfl Qed
Nat.add_mul_div_right ** x y z : Nat H : 0 < z ⊢ (x + y * z) / z = x / z + y rw [Nat.mul_comm, add_mul_div_left _ _ H] Qed
Nat.mul_div_cancel ** m n : Nat H : 0 < n ⊢ m * n / n = m let t := add_mul_div_right 0 m H m n : Nat H : 0 < n t : (0 + m * n) / n = 0 / n + m := add_mul_div_right 0 m H ⊢ m * n / n = m rwa [Nat.zero_add, Nat.zero_div, Nat.zero_add] at t Qed
Nat.mul_div_cancel_left ** m n : Nat H : 0 < n ⊢ n * m / n = m rw [Nat.mul_comm, Nat.mul_div_cancel _ H] Qed
Nat.div_eq_of_eq_mul_left ** n m k : Nat H1 : 0 < n H2 : m = k * n ⊢ m / n = k rw [H2, Nat.mul_div_cancel _ H1] Qed
Nat.div_eq_of_eq_mul_right ** n m k : Nat H1 : 0 < n H2 : m = n * k ⊢ m / n = k rw [H2, Nat.mul_div_cancel_left _ H1] Qed
Nat.div_eq_of_lt_le ** k n m : Nat lo : k * n ≤ m hi : m < succ k * n hn : n = 0 ⊢ False rw [hn, Nat.mul_zero] at hi lo k n m : Nat lo : 0 ≤ m hi : m < 0 hn : n = 0 ⊢ False exact absurd lo (Nat.not_le_of_gt hi) Qed
Nat.mul_sub_div ** x n p : Nat h₁ : x < n * p ⊢ (n * p - succ x) / n = p - succ (x / n) have npos : 0 < n := (eq_zero_or_pos _).resolve_left fun n0 => by rw [n0, Nat.zero_mul] at h₁; exact not_lt_zero _ h₁ x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ (n * p - succ x) / n = p - succ (x / n) apply Nat.div_eq_of_lt_le x n p : Nat h₁ : x < n * p n0 : n = 0 ⊢ False rw [n0, Nat.zero_mul] at h₁ x n p : Nat h₁ : x < 0 n0 : n = 0 ⊢ False exact not_lt_zero _ h₁ case lo x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ (p - succ (x / n)) * n ≤ n * p - succ x rw [Nat.mul_sub_right_distrib, Nat.mul_comm] case lo x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ n * p - succ (x / n) * n ≤ n * p - succ x exact Nat.sub_le_sub_left _ <\| (div_lt_iff_lt_mul npos).1 (lt_succ_self _) case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ n * p - succ x < succ (p - succ (x / n)) * n ** show succ (pred (n * p - x)) ≤ (succ (pred (p - x / n))) * n ** case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ succ (pred (n * p - x)) ≤ succ (pred (p - x / n)) * n rw [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁), fun h => succ_pred_eq_of_pos (Nat.sub_pos_of_lt h)] case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ n * p - x ≤ (p - x / n) * n rw [Nat.mul_sub_right_distrib, Nat.mul_comm] case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ p * n - x ≤ p * n - x / n * n exact Nat.sub_le_sub_left _ <\| div_mul_le_self .. case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ x / n < p rwa [div_lt_iff_lt_mul npos, Nat.mul_comm] Qed
Nat.div_div_eq_div_mul ** m n k : Nat ⊢ m / n / k = m / (n * k) cases eq_zero_or_pos k with \| inl k0 => rw [k0, Nat.mul_zero, Nat.div_zero, Nat.div_zero] \| inr kpos => ?_ case inr m n k : Nat kpos : k > 0 ⊢ m / n / k = m / (n * k) cases eq_zero_or_pos n with \| inl n0 => rw [n0, Nat.zero_mul, Nat.div_zero, Nat.zero_div] \| inr npos => ?_ case inr.inr m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k = m / (n * k) apply Nat.le_antisymm case inl m n k : Nat k0 : k = 0 ⊢ m / n / k = m / (n * k) rw [k0, Nat.mul_zero, Nat.div_zero, Nat.div_zero] case inr.inl m n k : Nat kpos : k > 0 n0 : n = 0 ⊢ m / n / k = m / (n * k) rw [n0, Nat.zero_mul, Nat.div_zero, Nat.zero_div] case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k ≤ m / (n * k) apply (le_div_iff_mul_le (Nat.mul_pos npos kpos)).2 case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k * (n * k) ≤ m rw [Nat.mul_comm n k, ← Nat.mul_assoc] case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k * k * n ≤ m apply (le_div_iff_mul_le npos).1 case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k * k ≤ m / n apply (le_div_iff_mul_le kpos).1 case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k ≤ m / n / k (apply Nat.le_refl) case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k ≤ m / n / k apply Nat.le_refl case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (n * k) ≤ m / n / k apply (le_div_iff_mul_le kpos).2 case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (n * k) * k ≤ m / n apply (le_div_iff_mul_le npos).2 case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (n * k) * k * n ≤ m rw [Nat.mul_assoc, Nat.mul_comm n k] case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (k * n) * (k * n) ≤ m apply (le_div_iff_mul_le (Nat.mul_pos kpos npos)).1 case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (k * n) ≤ m / (k * n) apply Nat.le_refl Qed
Nat.mul_div_mul_left ** m n k : Nat H : 0 < m ⊢ m * n / (m * k) = n / k rw [← Nat.div_div_eq_div_mul, Nat.mul_div_cancel_left _ H] Qed
Nat.mul_div_mul_right ** m n k : Nat H : 0 < m ⊢ n * m / (k * m) = n / k rw [Nat.mul_comm, Nat.mul_comm k, Nat.mul_div_mul_left _ _ H] Qed

Subsets and Splits

No community queries yet

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

formal stringlengths 41 427k	informal stringclasses 1 value
Std.RBNode.forM_eq_forM_toList m : Type u_1 → Type u_2 α : Type u_3 f : α → m PUnit inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ forM f t = List.forM (toList t) f induction t <;> simp [] * Qed
Std.RBNode.foldlM_eq_foldlM_toList m : Type u_1 → Type u_2 α : Type u_3 a✝ : Type u_1 f : a✝ → α → m a✝ init : a✝ inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ foldlM f init t = List.foldlM f init (toList t) induction t generalizing init <;> simp [] * Qed
Std.RBNode.forIn_visit_eq_bindList m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 f : α → α✝ → m (ForInStep α✝) init : α✝ inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ forIn.visit f t init = ForInStep.bindList f (toList t) (ForInStep.yield init) induction t generalizing init <;> simp [, forIn.visit] * Qed
Std.RBNode.forIn_eq_forIn_toList m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 init : α✝ f : α → α✝ → m (ForInStep α✝) inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ forIn t init f = forIn (toList t) init f simp [forIn, RBNode.forIn] m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 init : α✝ f : α → α✝ → m (ForInStep α✝) inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ ForInStep.run <$> forIn.visit f t init = forIn (toList t) init f rw [List.forIn_eq_bindList, forIn_visit_eq_bindList] ** Qed
Std.RBNode.Stream.foldr_cons α : Type u_1 t : RBNode.Stream α l : List α ⊢ foldr (fun x x_1 => x :: x_1) t l = toList t ++ l unfold toList α : Type u_1 t : RBNode.Stream α l : List α ⊢ foldr (fun x x_1 => x :: x_1) t l = foldr (fun x x_1 => x :: x_1) t [] ++ l apply Eq.symm case h α : Type u_1 t : RBNode.Stream α l : List α ⊢ foldr (fun x x_1 => x :: x_1) t [] ++ l = foldr (fun x x_1 => x :: x_1) t l induction t <;> simp [, foldr, RBNode.foldr_cons] * Qed
Std.RBNode.Stream.toList_cons α : Type u_1 x : α r : RBNode α s : RBNode.Stream α ⊢ toList (cons x r s) = x :: RBNode.toList r ++ toList s rw [toList, toList, foldr, RBNode.foldr_cons] α : Type u_1 x : α r : RBNode α s : RBNode.Stream α ⊢ x :: (RBNode.toList r ++ foldr (fun x x_1 => x :: x_1) s []) = x :: RBNode.toList r ++ foldr (fun x x_1 => x :: x_1) s [] rfl ** Qed
Std.RBNode.Stream.foldr_eq_foldr_toList α : Type u_1 α✝ : Type u_2 f : α → α✝ → α✝ init : α✝ s : RBNode.Stream α ⊢ foldr f s init = List.foldr f init (toList s) induction s <;> simp [, RBNode.foldr_eq_foldr_toList] * Qed
Std.RBNode.Stream.foldl_eq_foldl_toList α : Type u_1 α✝ : Type u_2 f : α✝ → α → α✝ init : α✝ t : RBNode.Stream α ⊢ foldl f init t = List.foldl f init (toList t) induction t generalizing init <;> simp [, RBNode.foldl_eq_foldl_toList] * Qed
Std.RBNode.Stream.forIn_eq_forIn_toList m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 init : α✝ f : α → α✝ → m (ForInStep α✝) inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ forIn t init f = forIn (RBNode.toList t) init f simp [forIn, RBNode.forIn] m : Type u_1 → Type u_2 α : Type u_3 α✝ : Type u_1 init : α✝ f : α → α✝ → m (ForInStep α✝) inst✝¹ : Monad m inst✝ : LawfulMonad m t : RBNode α ⊢ ForInStep.run <$> forIn.visit f t init = forIn (RBNode.toList t) init f rw [List.forIn_eq_bindList, forIn_visit_eq_bindList] ** Qed
Std.RBNode.toStream_toList' α : Type u_1 t : RBNode α s : RBNode.Stream α ⊢ Stream.toList (toStream t s) = toList t ++ Stream.toList s induction t generalizing s <;> simp [, toStream] * Qed
Std.RBNode.toStream_toList α : Type u_1 t : RBNode α ⊢ Stream.toList (toStream t Stream.nil) = toList t simp [toStream_toList'] ** Qed
Std.RBNode.ordered_iff α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp t ↔ List.Pairwise (cmpLT cmp) (toList t) induction t with \| nil => simp \| node c l v r ihl ihr => simp [, List.pairwise_append, Ordered, All_def, and_assoc, and_left_comm, and_comm, imp_and, forall_and] exact fun _ _ hl hr a ha b hb => (hl _ ha).trans (hr _ hb) * case nil α : Type u_1 cmp : α → α → Ordering ⊢ Ordered cmp nil ↔ List.Pairwise (cmpLT cmp) (toList nil) simp case node α : Type u_1 cmp : α → α → Ordering c : RBColor l : RBNode α v : α r : RBNode α ihl : Ordered cmp l ↔ List.Pairwise (cmpLT cmp) (toList l) ihr : Ordered cmp r ↔ List.Pairwise (cmpLT cmp) (toList r) ⊢ Ordered cmp (node c l v r) ↔ List.Pairwise (cmpLT cmp) (toList (node c l v r)) ** simp [, List.pairwise_append, Ordered, All_def, and_assoc, and_left_comm, and_comm, imp_and, forall_and] * case node α : Type u_1 cmp : α → α → Ordering c : RBColor l : RBNode α v : α r : RBNode α ihl : Ordered cmp l ↔ List.Pairwise (cmpLT cmp) (toList l) ihr : Ordered cmp r ↔ List.Pairwise (cmpLT cmp) (toList r) ⊢ List.Pairwise (cmpLT cmp) (toList l) → List.Pairwise (cmpLT cmp) (toList r) → (∀ (x : α), x ∈ l → cmpLT cmp x v) → (∀ (x : α), x ∈ r → cmpLT cmp v x) → ∀ (x : α), x ∈ l → ∀ (a : α), a ∈ r → cmpLT cmp x a exact fun _ _ hl hr a ha b hb => (hl _ ha).trans (hr _ hb) Qed
Std.RBNode.setBlack_toList α : Type u_1 t : RBNode α ⊢ toList (setBlack t) = toList t cases t <;> simp [setBlack] ** Qed
Std.RBNode.setRed_toList α : Type u_1 t : RBNode α ⊢ toList (setRed t) = toList t cases t <;> simp [setRed] ** Qed
Std.RBNode.balance1_toList α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (balance1 l v r) = toList l ++ v :: toList r unfold balance1 α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (match l, v, r with \| node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d) \| node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d) \| a, x, b => node black a x b) = toList l ++ v :: toList r split <;> simp ** Qed
Std.RBNode.balance2_toList α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (balance2 l v r) = toList l ++ v :: toList r unfold balance2 α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (match l, v, r with \| a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d) \| a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d) \| a, x, b => node black a x b) = toList l ++ v :: toList r split <;> simp ** Qed
Std.RBNode.balLeft_toList α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (balLeft l v r) = toList l ++ v :: toList r unfold balLeft α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (match l with \| node red a x b => node red (node black a x b) v r \| l => match r with \| node black a y b => balance2 l v (node red a y b) \| node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c)) \| r => node red l v r) = toList l ++ v :: toList r split <;> (try simp) case h_2 α : Type u_1 l : RBNode α v : α r l✝ : RBNode α x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), l = node red a x b → False ⊢ toList (match r with \| node black a y b => balance2 l v (node red a y b) \| node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c)) \| r => node red l v r) = toList l ++ v :: toList r split <;> simp case h_1 α : Type u_1 v : α r l✝ a✝ : RBNode α x✝ : α b✝ : RBNode α ⊢ toList (node red (node black a✝ x✝ b✝) v r) = toList (node red a✝ x✝ b✝) ++ v :: toList r try simp case h_1 α : Type u_1 v : α r l✝ a✝ : RBNode α x✝ : α b✝ : RBNode α ⊢ toList (node red (node black a✝ x✝ b✝) v r) = toList (node red a✝ x✝ b✝) ++ v :: toList r simp ** Qed
Std.RBNode.balRight_toList α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (balRight l v r) = toList l ++ v :: toList r unfold balRight α : Type u_1 l : RBNode α v : α r : RBNode α ⊢ toList (match r with \| node red b y c => node red l v (node black b y c) \| r => match l with \| node black a x b => balance1 (node red a x b) v r \| node red a x (node black b y c) => node red (balance1 (setRed a) x b) y (node black c v r) \| l => node red l v r) = toList l ++ v :: toList r split <;> (try simp) case h_2 α : Type u_1 l : RBNode α v : α r l✝ : RBNode α x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), r = node red a x b → False ⊢ toList (match l with \| node black a x b => balance1 (node red a x b) v r \| node red a x (node black b y c) => node red (balance1 (setRed a) x b) y (node black c v r) \| l => node red l v r) = toList l ++ v :: toList r split <;> simp case h_1 α : Type u_1 l : RBNode α v : α l✝ a✝ : RBNode α x✝ : α b✝ : RBNode α ⊢ toList (node red l v (node black a✝ x✝ b✝)) = toList l ++ v :: toList (node red a✝ x✝ b✝) try simp case h_1 α : Type u_1 l : RBNode α v : α l✝ a✝ : RBNode α x✝ : α b✝ : RBNode α ⊢ toList (node red l v (node black a✝ x✝ b✝)) = toList l ++ v :: toList (node red a✝ x✝ b✝) simp ** Qed
Std.RBNode.size_eq α : Type u_1 t : RBNode α ⊢ size t = List.length (toList t) induction t <;> simp [, size] * case node α : Type u_1 c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : size l✝ = List.length (toList l✝) r_ih✝ : size r✝ = List.length (toList r✝) ⊢ List.length (toList l✝) + List.length (toList r✝) + 1 = List.length (toList l✝) + Nat.succ (List.length (toList r✝)) rfl Qed
Std.RBNode.Path.rootOrdered_iff α : Type u_1 cmp : α → α → Ordering v : α p : Path α hp : Ordered cmp p ⊢ RootOrdered cmp p v ↔ (∀ (a : α), a ∈ listL p → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR p → cmpLT cmp v a induction p with (simp [All_def] at hp; simp [, and_assoc, and_left_comm, and_comm, or_imp, forall_and]) \| left _ _ x _ ih => exact fun vx _ _ _ ha => vx.trans (hp.2.1 _ ha) \| right _ _ x _ ih => exact fun xv _ _ _ ha => (hp.2.1 _ ha).trans xv * case root α : Type u_1 cmp : α → α → Ordering v : α hp : Ordered cmp root ⊢ RootOrdered cmp root v ↔ (∀ (a : α), a ∈ listL root → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR root → cmpLT cmp v a simp [All_def] at hp case root α : Type u_1 cmp : α → α → Ordering v : α hp : True ⊢ RootOrdered cmp root v ↔ (∀ (a : α), a ∈ listL root → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR root → cmpLT cmp v a ** simp [, and_assoc, and_left_comm, and_comm, or_imp, forall_and] * case left α : Type u_1 cmp : α → α → Ordering v : α c✝ : RBColor parent✝ : Path α x : α r✝ : RBNode α ih : Ordered cmp parent✝ → (RootOrdered cmp parent✝ v ↔ (∀ (a : α), a ∈ listL parent✝ → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR parent✝ → cmpLT cmp v a) hp : Ordered cmp parent✝ ∧ (∀ (x_1 : α), x_1 ∈ r✝ → cmpLT cmp x x_1) ∧ RootOrdered cmp parent✝ x ∧ (∀ (x : α), x ∈ r✝ → RootOrdered cmp parent✝ x) ∧ RBNode.Ordered cmp r✝ ⊢ cmpLT cmp v x → (∀ (a : α), a ∈ listL parent✝ → cmpLT cmp a v) → (∀ (a : α), a ∈ listR parent✝ → cmpLT cmp v a) → ∀ (x : α), x ∈ r✝ → cmpLT cmp v x exact fun vx _ _ _ ha => vx.trans (hp.2.1 _ ha) case right α : Type u_1 cmp : α → α → Ordering v : α c✝ : RBColor l✝ : RBNode α x : α parent✝ : Path α ih : Ordered cmp parent✝ → (RootOrdered cmp parent✝ v ↔ (∀ (a : α), a ∈ listL parent✝ → cmpLT cmp a v) ∧ ∀ (a : α), a ∈ listR parent✝ → cmpLT cmp v a) hp : Ordered cmp parent✝ ∧ (∀ (x_1 : α), x_1 ∈ l✝ → cmpLT cmp x_1 x) ∧ RootOrdered cmp parent✝ x ∧ (∀ (x : α), x ∈ l✝ → RootOrdered cmp parent✝ x) ∧ RBNode.Ordered cmp l✝ ⊢ cmpLT cmp x v → (∀ (a : α), a ∈ listL parent✝ → cmpLT cmp a v) → (∀ (a : α), a ∈ listR parent✝ → cmpLT cmp v a) → ∀ (x : α), x ∈ l✝ → cmpLT cmp x v exact fun xv _ _ _ ha => (hp.2.1 _ ha).trans xv Qed
Std.RBNode.Path.fill_toList α : Type u_1 t : RBNode α p : Path α ⊢ toList (fill p t) = withList p (toList t) induction p generalizing t <;> simp [] * Qed
Std.RBNode.Path.ins_toList α : Type u_1 t : RBNode α p : Path α ⊢ toList (ins p t) = withList p (toList t) match p with \| .root \| .left red .. \| .right red .. \| .left black .. \| .right black .. => simp [ins, ins_toList] α : Type u_1 t : RBNode α p : Path α l✝ : RBNode α v✝ : α parent✝ : Path α ⊢ toList (ins (right black l✝ v✝ parent✝) t) = withList (right black l✝ v✝ parent✝) (toList t) simp [ins, ins_toList] ** Qed
Std.RBNode.mem_insert α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t ⊢ v' ∈ insert cmp t v ↔ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v refine ⟨fun h => ?_, fun \| .inl ⟨h₁, h₂⟩ => ?_ \| .inr h => ?_⟩ α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' ∈ insert cmp t v p : Path α e : zoom (cmp v) t Path.root = (nil, p) ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v let ⟨_, _, h₁, h₂⟩ := exists_insert_toList_zoom_nil ht e α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' ∈ insert cmp t v p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v simp [← mem_toList, h₂] at h α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' = v ∨ v' ∈ w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v rw [← or_assoc, or_right_comm] at h α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : (v' ∈ w✝¹ ∨ v' ∈ w✝) ∨ v' = v ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v refine h.imp_left fun h => ?_ α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : (v' ∈ w✝¹ ∨ v' ∈ w✝) ∨ v' = v h : v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' simp [← mem_toList, h₁, h] α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : (v' ∈ w✝¹ ∨ v' ∈ w✝) ∨ v' = v h : v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ ¬find? (cmp v) t = some v' rw [find?_eq_zoom, e] α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t p : Path α e : zoom (cmp v) t Path.root = (nil, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : (v' ∈ w✝¹ ∨ v' ∈ w✝) ∨ v' = v h : v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ ¬root? (nil, p).fst = some v' intro. α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' ∈ insert cmp t v c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v let ⟨_, _, h₁, h₂⟩ := exists_insert_toList_zoom_node ht e α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' ∈ insert cmp t v c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v simp [← mem_toList, h₂] at h α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' = v ∨ v' ∈ w✝ ⊢ v' ∈ t ∧ find? (cmp v) t ≠ some v' ∨ v' = v simp [← mem_toList, h₁] α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' = v ∨ v' ∈ w✝ ⊢ (v' ∈ w✝¹ ∨ v' = v✝ ∨ v' ∈ w✝) ∧ ¬find? (cmp v) t = some v' ∨ v' = v rw [or_left_comm] at h ⊢ α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' = v ∨ v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ (v' = v✝ ∨ v' ∈ w✝¹ ∨ v' ∈ w✝) ∧ ¬find? (cmp v) t = some v' ∨ v' = v rcases h with _\|h <;> simp [] * case inr α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ ⊢ ¬find? (cmp v) t = some v' ∨ v' = v refine .inl fun h => ?_ case inr α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : v' ∈ w✝¹ ∨ v' ∈ w✝ h : find? (cmp v) t = some v' ⊢ False rw [find?_eq_zoom, e] at h case inr α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α p : Path α e : zoom (cmp v) t Path.root = (node c✝ l✝ v✝ r✝, p) w✝¹ w✝ : List α h₁ : toList t = w✝¹ ++ v✝ :: w✝ h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h✝ : v' ∈ w✝¹ ∨ v' ∈ w✝ h : root? (node c✝ l✝ v✝ r✝, p).fst = some v' ⊢ False cases h case inr.refl α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ r✝ : RBNode α p : Path α w✝¹ w✝ : List α h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ e : zoom (cmp v) t Path.root = (node c✝ l✝ v' r✝, p) h₁ : toList t = w✝¹ ++ v' :: w✝ ⊢ False suffices cmpLT cmp v' v' by cases OrientedCmp.cmp_refl.symm.trans this.1 case inr.refl α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ r✝ : RBNode α p : Path α w✝¹ w✝ : List α h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ e : zoom (cmp v) t Path.root = (node c✝ l✝ v' r✝, p) h₁ : toList t = w✝¹ ++ v' :: w✝ ⊢ cmpLT cmp v' v' have := ht₂.toList_sorted case inr.refl α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ r✝ : RBNode α p : Path α w✝¹ w✝ : List α h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ e : zoom (cmp v) t Path.root = (node c✝ l✝ v' r✝, p) h₁ : toList t = w✝¹ ++ v' :: w✝ this : List.Pairwise (cmpLT cmp) (toList t) ⊢ cmpLT cmp v' v' simp [h₁, List.pairwise_append] at this α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t c✝ : RBColor l✝ r✝ : RBNode α p : Path α w✝¹ w✝ : List α h₂ : toList (insert cmp t v) = w✝¹ ++ v :: w✝ h : v' ∈ w✝¹ ∨ v' ∈ w✝ e : zoom (cmp v) t Path.root = (node c✝ l✝ v' r✝, p) h₁ : toList t = w✝¹ ++ v' :: w✝ this : cmpLT cmp v' v' ⊢ False cases OrientedCmp.cmp_refl.symm.trans this.1 case refine_2 α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h₁ : v' ∈ t h₂ : find? (cmp v) t ≠ some v' ⊢ v' ∈ insert cmp t v exact (mem_insert_of_mem ht h₁).resolve_right fun h' => h₂ <\| ht₂.find?_some.2 ⟨h₁, h'⟩ case refine_3 α : Type u_1 cmp : α → α → Ordering c : RBColor n : Nat v' v : α inst✝ : TransCmp cmp t : RBNode α ht : Balanced t c n ht₂ : Ordered cmp t h : v' = v ⊢ v' ∈ insert cmp t v exact h ▸ mem_insert_self ht Qed
Std.RBSet.mem_iff_mem_toList α : Type u_1 cmp : α → α → Ordering x : α t : RBSet α cmp ⊢ (∃ y, y ∈ t.val ∧ cmp x y = Ordering.eq) ↔ ∃ y, y ∈ toList t ∧ cmp x y = Ordering.eq simp [mem_toList] ** Qed
Std.RBSet.find?_some α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp t : RBSet α cmp ⊢ y ∈ t.val ∧ cmp x y = Ordering.eq ↔ y ∈ toList t ∧ cmp x y = Ordering.eq simp [mem_toList] ** Qed
Std.RBSet.find?_congr α : Type u_1 cmp : α → α → Ordering v₁ v₂ : α inst✝ : TransCmp cmp t : RBSet α cmp h : cmp v₁ v₂ = Ordering.eq ⊢ find? t v₁ = find? t v₂ simp [find?, TransCmp.cmp_congr_left' h] ** Qed
Nat.strongRec_eq motive : Nat → Sort u_1 ind : (n : Nat) → ((m : Nat) → m < n → motive m) → motive n t : Nat ⊢ Nat.strongRec ind t = ind t fun m x => Nat.strongRec ind m conv => lhs; unfold Nat.strongRec ** Qed
Nat.recDiagAux_zero_left motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) n : Nat ⊢ Nat.recDiagAux zero_left zero_right succ_succ 0 n = zero_left n cases n <;> rfl ** Qed
Nat.recDiagAux_zero_right motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) m : Nat h : autoParam (zero_left 0 = zero_right 0) _auto✝ ⊢ Nat.recDiagAux zero_left zero_right succ_succ m 0 = zero_right m cases m case zero motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) h : autoParam (zero_left 0 = zero_right 0) _auto✝ ⊢ Nat.recDiagAux zero_left zero_right succ_succ zero 0 = zero_right zero case succ motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) h : autoParam (zero_left 0 = zero_right 0) _auto✝ n✝ : Nat ⊢ Nat.recDiagAux zero_left zero_right succ_succ (succ n✝) 0 = zero_right (succ n✝) exact h case succ motive : Nat → Nat → Sort u_1 zero_left : (n : Nat) → motive 0 n zero_right : (m : Nat) → motive m 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) h : autoParam (zero_left 0 = zero_right 0) _auto✝ n✝ : Nat ⊢ Nat.recDiagAux zero_left zero_right succ_succ (succ n✝) 0 = zero_right (succ n✝) rfl ** Qed
Nat.recDiag_zero_succ motive : Nat → Nat → Sort u_1 zero_zero : motive 0 0 zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1) succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) n : Nat ⊢ Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 (n + 1) = zero_succ n (Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 n) simp [Nat.recDiag] motive : Nat → Nat → Sort u_1 zero_zero : motive 0 0 zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1) succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) n : Nat ⊢ recDiag.left zero_zero zero_succ (n + 1) = zero_succ n (recDiag.left zero_zero zero_succ n) rfl ** Qed
Nat.recDiag_succ_zero motive : Nat → Nat → Sort u_1 zero_zero : motive 0 0 zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1) succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) m : Nat ⊢ Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m + 1) 0 = succ_zero m (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m 0) simp [Nat.recDiag] motive : Nat → Nat → Sort u_1 zero_zero : motive 0 0 zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1) succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0 succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1) m : Nat ⊢ Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ (m + 1) 0 = succ_zero m (Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ m 0) cases m <;> rfl ** Qed
Nat.eq_zero_or_eq_succ_pred n : Nat ⊢ n = 0 ∨ n = succ (pred n) cases n <;> simp ** Qed
Nat.succ_eq_one_add n : Nat ⊢ succ n = 1 + n rw [Nat.succ_eq_add_one, Nat.add_comm] ** Qed
Nat.pred_inj a b : Nat x✝¹ : 0 < a + 1 x✝ : 0 < b + 1 h : pred (a + 1) = pred (b + 1) ⊢ a + 1 = b + 1 rw [show a = b from h] ** Qed
Nat.eq_zero_of_add_eq_zero_right m : Nat ⊢ 0 + m = 0 → 0 = 0 simp [Nat.zero_add] n m : Nat h : n + 1 + m = 0 ⊢ n + 1 = 0 rw [add_one, succ_add] at h n m : Nat h : succ (n + m) = 0 ⊢ n + 1 = 0 cases succ_ne_zero _ h ** Qed
Nat.succ_add_eq_succ_add n m : Nat ⊢ succ n + m = n + succ m simp [succ_add, add_succ] ** Qed
Nat.one_add n : Nat ⊢ 1 + n = succ n simp [Nat.add_comm] ** Qed
Nat.lt_of_add_lt_add_left k n m : Nat h : k + n < k + m heq : n = m ⊢ k + m < k + m rwa [heq] at h ** Qed
Nat.lt_of_add_lt_add_right a b c : Nat h : a + b < c + b ⊢ b + a < b + c rwa [Nat.add_comm b a, Nat.add_comm b c] ** Qed
Nat.lt_add_of_pos_left n k : Nat h : 0 < k ⊢ n < k + n rw [Nat.add_comm] n k : Nat h : 0 < k ⊢ n < n + k exact Nat.lt_add_of_pos_right h ** Qed
Nat.pos_of_lt_add_left n k : Nat h : n < k + n ⊢ 0 + ?m.18605 h < k + ?m.18605 h rw [Nat.zero_add] n k : Nat h : n < k + n ⊢ ?m.18605 h < k + ?m.18605 h ⊢ {n k : Nat} → n < k + n → Nat exact h ** Qed
Nat.add_pos_right n m : Nat h : 0 < n ⊢ 0 < m + n rw [Nat.add_comm] n m : Nat h : 0 < n ⊢ 0 < n + m exact add_pos_left h m ** Qed
Nat.le_of_le_of_sub_le_sub_right n m k : Nat h₀ : succ k ≤ succ m h₁ : succ n - succ k ≤ succ m - succ k ⊢ succ n ≤ succ m simp [succ_sub_succ] at h₁ n m k : Nat h₀ : succ k ≤ succ m h₁ : n - k ≤ m - k ⊢ succ n ≤ succ m exact succ_le_succ <\| Nat.le_of_le_of_sub_le_sub_right (le_of_succ_le_succ h₀) h₁ ** Qed
Nat.add_le_to_le_sub x y k : Nat h : k ≤ y ⊢ x + k ≤ y ↔ x ≤ y - k rw [← Nat.add_sub_cancel x k, Nat.sub_le_sub_iff_right h, Nat.add_sub_cancel] ** Qed
Nat.le_of_sub_eq_zero n : Nat H : n - 0 = 0 ⊢ n ≤ 0 rw [Nat.sub_zero] at H n : Nat H : n = 0 ⊢ n ≤ 0 simp [H] n m : Nat H : n + 1 - (m + 1) = 0 ⊢ n - m = 0 simp [Nat.add_sub_add_right] at H n m : Nat H : n - m = 0 ⊢ n - m = 0 exact H ** Qed
Nat.sub_eq_iff_eq_add a b c : Nat ab : b ≤ a c_eq : a - b = c ⊢ a = c + b rw [c_eq.symm, Nat.sub_add_cancel ab] a b c : Nat ab : b ≤ a a_eq : a = c + b ⊢ a - b = c rw [a_eq, Nat.add_sub_cancel] ** Qed
Nat.lt_of_sub_eq_succ m n l : Nat H : m - n = succ l H' : m ≤ n ⊢ False simp [Nat.sub_eq_zero_of_le H'] at H ** Qed
Nat.sub_le_sub_left n m k a : Nat h : n ≤ n + a ⊢ k - (n + a) ≤ k - n rw [← Nat.sub_sub] n m k a : Nat h : n ≤ n + a ⊢ k - n - a ≤ k - n apply sub_le ** Qed
Nat.succ_sub_sub_succ n m k : Nat ⊢ succ n - m - succ k = n - m - k rw [Nat.sub_sub, Nat.sub_sub, add_succ, succ_sub_succ] ** Qed
Nat.sub_right_comm m n k : Nat ⊢ m - n - k = m - k - n rw [Nat.sub_sub, Nat.sub_sub, Nat.add_comm] ** Qed
Nat.sub_pos_of_lt m n : Nat h : m < n ⊢ 0 < n - m apply Nat.lt_of_add_lt_add_right (b := m) m n : Nat h : m < n ⊢ 0 + m < n - m + m rwa [Nat.zero_add, Nat.sub_add_cancel (Nat.le_of_lt h)] ** Qed
Nat.sub_add_comm n m k : Nat h : k ≤ n ⊢ n + m - k = n - k + m rw [Nat.sub_eq_iff_eq_add (Nat.le_trans h (Nat.le_add_right ..))] n m k : Nat h : k ≤ n ⊢ n + m = n - k + m + k rwa [Nat.add_right_comm, Nat.sub_add_cancel] ** Qed
Nat.sub_one_sub_lt i n : Nat h : i < n ⊢ n - 1 - i < n rw [Nat.sub_sub] i n : Nat h : i < n ⊢ n - (1 + i) < n apply Nat.sub_lt (Nat.lt_of_lt_of_le (Nat.zero_lt_succ _) h) i n : Nat h : i < n ⊢ 0 < 1 + i rw [Nat.add_comm] i n : Nat h : i < n ⊢ 0 < i + 1 apply Nat.zero_lt_succ ** Qed
Nat.sub_lt_self a b : Nat h₀ : 0 < a h₁ : a ≤ b ⊢ b - a < b apply sub_lt _ h₀ a b : Nat h₀ : 0 < a h₁ : a ≤ b ⊢ 0 < b apply Nat.lt_of_lt_of_le h₀ h₁ ** Qed
Nat.add_sub_cancel' n m : Nat h : m ≤ n ⊢ m + (n - m) = n rw [Nat.add_comm, Nat.sub_add_cancel h] ** Qed
Nat.le_sub_iff_add_le x y k : Nat h : k ≤ y ⊢ x ≤ y - k ↔ x + k ≤ y rw [← Nat.add_sub_cancel x k, Nat.sub_le_sub_iff_right h, Nat.add_sub_cancel] ** Qed
Nat.sub_le_sub_iff_left n m k : Nat hn : n ≤ k ⊢ k - m ≤ k - n ↔ n ≤ m refine ⟨fun h => ?_, Nat.sub_le_sub_left _⟩ n m k : Nat hn : n ≤ k h : k - m ≤ k - n ⊢ n ≤ m rwa [Nat.sub_le_iff_le_add', ← Nat.add_sub_assoc hn, le_sub_iff_add_le (Nat.le_trans hn (Nat.le_add_left ..)), Nat.add_comm, Nat.add_le_add_iff_right] at h ** Qed
Nat.le_min a b c : Nat x✝ : a ≤ b ∧ a ≤ c h₁ : a ≤ b h₂ : a ≤ c ⊢ a ≤ min b c rw [Nat.min_def] a b c : Nat x✝ : a ≤ b ∧ a ≤ c h₁ : a ≤ b h₂ : a ≤ c ⊢ a ≤ if b ≤ c then b else c split <;> assumption ** Qed
Nat.min_eq_left a b : Nat h : a ≤ b ⊢ min a b = a simp [Nat.min_def, h] ** Qed
Nat.min_eq_right a b : Nat h : b ≤ a ⊢ min a b = b rw [Nat.min_comm a b] a b : Nat h : b ≤ a ⊢ min b a = b exact Nat.min_eq_left h ** Qed
Nat.max_le a b c : Nat x✝ : a ≤ c ∧ b ≤ c h₁ : a ≤ c h₂ : b ≤ c ⊢ max a b ≤ c rw [Nat.max_def] a b c : Nat x✝ : a ≤ c ∧ b ≤ c h₁ : a ≤ c h₂ : b ≤ c ⊢ (if a ≤ b then b else a) ≤ c split <;> assumption ** Qed
Nat.max_eq_right a b : Nat h : a ≤ b ⊢ max a b = b simp [Nat.max_def, h, Nat.not_lt.2 h] ** Qed
Nat.max_eq_left a b : Nat h : b ≤ a ⊢ max a b = a rw [← Nat.max_comm b a] a b : Nat h : b ≤ a ⊢ max b a = a exact Nat.max_eq_right h ** Qed
Nat.min_succ_succ x y : Nat ⊢ min (succ x) (succ y) = succ (min x y) simp [Nat.min_def, succ_le_succ_iff] x y : Nat ⊢ (if x ≤ y then succ x else succ y) = succ (if x ≤ y then x else y) split <;> rfl ** Qed
Nat.sub_eq_sub_min n m : Nat ⊢ n - m = n - min n m rw [Nat.min_def] n m : Nat ⊢ n - m = n - if n ≤ m then n else m split case inl n m : Nat h✝ : n ≤ m ⊢ n - m = n - n rw [Nat.sub_eq_zero_of_le ‹n ≤ m›, Nat.sub_self] case inr n m : Nat h✝ : ¬n ≤ m ⊢ n - m = n - m rfl ** Qed
Nat.mul_right_comm ** n m k : Nat ⊢ n * m * k = n * k * m rw [Nat.mul_assoc, Nat.mul_comm m, ← Nat.mul_assoc] Qed
Nat.mul_mul_mul_comm ** a b c d : Nat ⊢ a * b * (c * d) = a * c * (b * d) rw [Nat.mul_assoc, Nat.mul_assoc, Nat.mul_left_comm b] Qed
Nat.mul_two ** n : Nat ⊢ n * 2 = n + n simp [Nat.mul_succ] Qed
Nat.two_mul ** n : Nat ⊢ 2 * n = n + n simp [Nat.succ_mul] Qed
Nat.mul_eq_zero ** n✝ m✝ : Nat h✝ : n✝ * m✝ = 0 n m : Nat h : (n + 1) * m = 0 ⊢ n + 1 = 0 ∨ m = 0 rw [succ_mul] at h n✝ m✝ : Nat h✝ : n✝ * m✝ = 0 n m : Nat h : n * m + m = 0 ⊢ n + 1 = 0 ∨ m = 0 exact .inr (Nat.eq_zero_of_add_eq_zero_left h) n m : Nat h : m = 0 ⊢ n * m = 0 simp [h] Qed
Nat.mul_ne_zero_iff ** n m : Nat ⊢ n * m ≠ 0 ↔ n ≠ 0 ∧ m ≠ 0 simp [mul_eq_zero, not_or] Qed
Nat.mul_le_mul_of_nonneg_left ** a b c : Nat h₁ : a ≤ b ⊢ c * a ≤ c * b if hba : b ≤ a then simp [Nat.le_antisymm hba h₁] else if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul] else exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) a b c : Nat h₁ : a ≤ b hba : b ≤ a ⊢ c * a ≤ c * b simp [Nat.le_antisymm hba h₁] a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a ⊢ c * a ≤ c * b if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul] else exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a hc0 : c ≤ 0 ⊢ c * a ≤ c * b simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul] a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a hc0 : ¬c ≤ 0 ⊢ c * a ≤ c * b exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) Qed
Nat.mul_le_mul_of_nonneg_right ** a b c : Nat h₁ : a ≤ b ⊢ a * c ≤ b * c if hba : b ≤ a then simp [Nat.le_antisymm hba h₁] else if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero] else exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) a b c : Nat h₁ : a ≤ b hba : b ≤ a ⊢ a * c ≤ b * c simp [Nat.le_antisymm hba h₁] a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a ⊢ a * c ≤ b * c if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero] else exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a hc0 : c ≤ 0 ⊢ a * c ≤ b * c simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero] a b c : Nat h₁ : a ≤ b hba : ¬b ≤ a hc0 : ¬c ≤ 0 ⊢ a * c ≤ b * c exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0)) Qed
Nat.succ_mul_succ_eq ** a b : Nat ⊢ succ a * succ b = a * b + a + b + 1 rw [mul_succ, succ_mul, Nat.add_right_comm _ a] a b : Nat ⊢ a * b + b + succ a = a * b + b + a + 1 rfl Qed
Nat.mul_self_sub_mul_self_eq ** a b : Nat ⊢ a * a - b * b = (a + b) * (a - b) ** rw [Nat.mul_sub_left_distrib, Nat.right_distrib, Nat.right_distrib, Nat.mul_comm b a, Nat.add_comm (aa) (ab), Nat.add_sub_add_left] ** Qed
Nat.div_one n : Nat ⊢ n / 1 = n have := mod_add_div n 1 ** n : Nat this : n % 1 + 1 * (n / 1) = n ⊢ n / 1 = n rwa [mod_one, Nat.zero_add, Nat.one_mul] at this Qed
Nat.div_zero n : Nat ⊢ n / 0 = 0 rw [div_eq] n : Nat ⊢ (if 0 < 0 ∧ 0 ≤ n then (n - 0) / 0 + 1 else 0) = 0 simp [Nat.lt_irrefl] ** Qed
Nat.le_div_iff_mul_le ** k x y : Nat k0 : 0 < k ⊢ x ≤ y / k ↔ x * k ≤ y ** induction y, k using mod.inductionOn generalizing x with (rw [div_eq]; simp [h]; cases x with \| zero => simp [zero_le] \| succ x => ?_) \| base y k h => simp [not_succ_le_zero x, succ_mul, Nat.add_comm] refine Nat.lt_of_lt_of_le ?_ (Nat.le_add_right ..) exact Nat.not_le.1 fun h' => h ⟨k0, h'⟩ \| ind y k h IH => rw [← add_one, Nat.add_le_add_iff_right, IH k0, succ_mul, ← Nat.add_sub_cancel (xk) k, Nat.sub_le_sub_iff_right h.2, Nat.add_sub_cancel] * case ind y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) x : Nat k0 : 0 < k ⊢ x ≤ y / k ↔ x * k ≤ y rw [div_eq] case ind y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) x : Nat k0 : 0 < k ⊢ (x ≤ if 0 < k ∧ k ≤ y then (y - k) / k + 1 else 0) ↔ x * k ≤ y simp [h] case ind y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) x : Nat k0 : 0 < k ⊢ x ≤ (y - k) / k + 1 ↔ x * k ≤ y cases x with \| zero => simp [zero_le] \| succ x => ?_ case ind.zero y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) k0 : 0 < k ⊢ zero ≤ (y - k) / k + 1 ↔ zero * k ≤ y simp [zero_le] case base.succ y k : Nat h : ¬(0 < k ∧ k ≤ y) k0 : 0 < k x : Nat ⊢ succ x = 0 ↔ succ x * k ≤ y simp [not_succ_le_zero x, succ_mul, Nat.add_comm] case base.succ y k : Nat h : ¬(0 < k ∧ k ≤ y) k0 : 0 < k x : Nat ⊢ y < k + x * k refine Nat.lt_of_lt_of_le ?_ (Nat.le_add_right ..) case base.succ y k : Nat h : ¬(0 < k ∧ k ≤ y) k0 : 0 < k x : Nat ⊢ y < k exact Nat.not_le.1 fun h' => h ⟨k0, h'⟩ case ind.succ y k : Nat h : 0 < k ∧ k ≤ y IH : ∀ {x : Nat}, 0 < k → (x ≤ (y - k) / k ↔ x * k ≤ y - k) k0 : 0 < k x : Nat ⊢ succ x ≤ (y - k) / k + 1 ↔ succ x * k ≤ y ** rw [← add_one, Nat.add_le_add_iff_right, IH k0, succ_mul, ← Nat.add_sub_cancel (xk) k, Nat.sub_le_sub_iff_right h.2, Nat.add_sub_cancel] * Qed
Nat.div_le_of_le_mul ** m n : Nat x✝ : m ≤ 0 * n ⊢ m / 0 ≤ n simp [Nat.div_zero, n.zero_le] m n k : Nat h : m ≤ succ k * n ⊢ m / succ k ≤ n ** suffices succ k * (m / succ k) ≤ succ k * n from Nat.le_of_mul_le_mul_left this (zero_lt_succ _) ** m n k : Nat h : m ≤ succ k * n ⊢ succ k * (m / succ k) ≤ succ k * n ** have h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) := Nat.le_add_left _ _ ** m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) ⊢ succ k * (m / succ k) ≤ succ k * n ** have h2 : m % succ k + succ k * (m / succ k) = m := by rw [mod_add_div] ** m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) h2 : m % succ k + succ k * (m / succ k) = m ⊢ succ k * (m / succ k) ≤ succ k * n ** have h3 : m ≤ succ k * n := h ** m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) h2 : m % succ k + succ k * (m / succ k) = m h3 : m ≤ succ k * n ⊢ succ k * (m / succ k) ≤ succ k * n rw [← h2] at h3 m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) h2 : m % succ k + succ k * (m / succ k) = m h3 : m % succ k + succ k * (m / succ k) ≤ succ k * n ⊢ succ k * (m / succ k) ≤ succ k * n exact Nat.le_trans h1 h3 m n k : Nat h : m ≤ succ k * n h1 : succ k * (m / succ k) ≤ m % succ k + succ k * (m / succ k) ⊢ m % succ k + succ k * (m / succ k) = m rw [mod_add_div] Qed
Nat.div_eq_sub_div b a : Nat h₁ : 0 < b h₂ : b ≤ a ⊢ a / b = (a - b) / b + 1 rw [div_eq a, if_pos] case hc b a : Nat h₁ : 0 < b h₂ : b ≤ a ⊢ 0 < b ∧ b ≤ a constructor <;> assumption ** Qed
Nat.div_eq_of_lt a b : Nat h₀ : a < b ⊢ a / b = 0 rw [div_eq a, if_neg] case hnc a b : Nat h₀ : a < b ⊢ ¬(0 < b ∧ b ≤ a) intro h₁ case hnc a b : Nat h₀ : a < b h₁ : 0 < b ∧ b ≤ a ⊢ False apply Nat.not_le_of_gt h₀ h₁.right ** Qed
Nat.div_lt_iff_lt_mul ** k x y : Nat Hk : 0 < k ⊢ x / k < y ↔ x < y * k rw [← Nat.not_le, ← Nat.not_le] k x y : Nat Hk : 0 < k ⊢ ¬y ≤ x / k ↔ ¬y * k ≤ x exact not_congr (le_div_iff_mul_le Hk) Qed
Nat.sub_mul_div ** x n p : Nat h₁ : n * p ≤ x ⊢ (x - n * p) / n = x / n - p ** match eq_zero_or_pos n with \| .inl h₀ => rw [h₀, Nat.div_zero, Nat.div_zero, Nat.zero_sub] \| .inr h₀ => induction p with \| zero => rw [Nat.mul_zero, Nat.sub_zero, Nat.sub_zero] \| succ p IH => have h₂ : n * p ≤ x := Nat.le_trans (Nat.mul_le_mul_left _ (le_succ _)) h₁ have h₃ : x - n * p ≥ n := by apply Nat.le_of_add_le_add_right rw [Nat.sub_add_cancel h₂, Nat.add_comm] rw [mul_succ] at h₁ exact h₁ rw [sub_succ, ← IH h₂, div_eq_sub_div h₀ h₃] simp [add_one, Nat.pred_succ, mul_succ, Nat.sub_sub] ** x n p : Nat h₁ : n * p ≤ x h₀ : n = 0 ⊢ (x - n * p) / n = x / n - p rw [h₀, Nat.div_zero, Nat.div_zero, Nat.zero_sub] x n p : Nat h₁ : n * p ≤ x h₀ : n > 0 ⊢ (x - n * p) / n = x / n - p ** induction p with \| zero => rw [Nat.mul_zero, Nat.sub_zero, Nat.sub_zero] \| succ p IH => have h₂ : n * p ≤ x := Nat.le_trans (Nat.mul_le_mul_left _ (le_succ _)) h₁ have h₃ : x - n * p ≥ n := by apply Nat.le_of_add_le_add_right rw [Nat.sub_add_cancel h₂, Nat.add_comm] rw [mul_succ] at h₁ exact h₁ rw [sub_succ, ← IH h₂, div_eq_sub_div h₀ h₃] simp [add_one, Nat.pred_succ, mul_succ, Nat.sub_sub] ** case zero x n : Nat h₀ : n > 0 h₁ : n * zero ≤ x ⊢ (x - n * zero) / n = x / n - zero rw [Nat.mul_zero, Nat.sub_zero, Nat.sub_zero] case succ x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x ⊢ (x - n * succ p) / n = x / n - succ p ** have h₂ : n * p ≤ x := Nat.le_trans (Nat.mul_le_mul_left _ (le_succ _)) h₁ ** case succ x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ (x - n * succ p) / n = x / n - succ p ** have h₃ : x - n * p ≥ n := by apply Nat.le_of_add_le_add_right rw [Nat.sub_add_cancel h₂, Nat.add_comm] rw [mul_succ] at h₁ exact h₁ ** case succ x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x h₃ : x - n * p ≥ n ⊢ (x - n * succ p) / n = x / n - succ p rw [sub_succ, ← IH h₂, div_eq_sub_div h₀ h₃] case succ x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x h₃ : x - n * p ≥ n ⊢ (x - n * succ p) / n = pred ((x - n * p - n) / n + 1) simp [add_one, Nat.pred_succ, mul_succ, Nat.sub_sub] x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ x - n * p ≥ n apply Nat.le_of_add_le_add_right case a x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ n + ?b ≤ x - n * p + ?b case b x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ Nat rw [Nat.sub_add_cancel h₂, Nat.add_comm] case a x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * succ p ≤ x h₂ : n * p ≤ x ⊢ n * p + n ≤ x rw [mul_succ] at h₁ case a x n : Nat h₀ : n > 0 p : Nat IH : n * p ≤ x → (x - n * p) / n = x / n - p h₁ : n * p + n ≤ x h₂ : n * p ≤ x ⊢ n * p + n ≤ x exact h₁ Qed
Nat.div_mul_le_self ** m : Nat ⊢ m / 0 * 0 ≤ m simp Qed
Nat.add_div_right x z : Nat H : 0 < z ⊢ (x + z) / z = succ (x / z) rw [div_eq_sub_div H (Nat.le_add_left _ _), Nat.add_sub_cancel] ** Qed
Nat.add_div_left x z : Nat H : 0 < z ⊢ (z + x) / z = succ (x / z) rw [Nat.add_comm, add_div_right x H] ** Qed
Nat.mul_div_right ** n m : Nat H : 0 < m ⊢ m * n / m = n induction n <;> simp_all [mul_succ] Qed
Nat.mul_div_left ** m n : Nat H : 0 < n ⊢ m * n / n = m rw [Nat.mul_comm, mul_div_right _ H] Qed
Nat.div_self n : Nat H : 0 < n ⊢ n / n = 1 let t := add_div_right 0 H n : Nat H : 0 < n t : (0 + n) / n = succ (0 / n) := add_div_right 0 H ⊢ n / n = 1 rwa [Nat.zero_add, Nat.zero_div] at t ** Qed
Nat.add_mul_div_left ** x z y : Nat H : 0 < y ⊢ (x + y * z) / y = x / y + z induction z with \| zero => rw [Nat.mul_zero, Nat.add_zero, Nat.add_zero] \| succ z ih => rw [mul_succ, ← Nat.add_assoc, add_div_right _ H, ih]; rfl case zero x y : Nat H : 0 < y ⊢ (x + y * zero) / y = x / y + zero rw [Nat.mul_zero, Nat.add_zero, Nat.add_zero] case succ x y : Nat H : 0 < y z : Nat ih : (x + y * z) / y = x / y + z ⊢ (x + y * succ z) / y = x / y + succ z rw [mul_succ, ← Nat.add_assoc, add_div_right _ H, ih] case succ x y : Nat H : 0 < y z : Nat ih : (x + y * z) / y = x / y + z ⊢ succ (x / y + z) = x / y + succ z rfl Qed
Nat.add_mul_div_right ** x y z : Nat H : 0 < z ⊢ (x + y * z) / z = x / z + y rw [Nat.mul_comm, add_mul_div_left _ _ H] Qed
Nat.mul_div_cancel ** m n : Nat H : 0 < n ⊢ m * n / n = m let t := add_mul_div_right 0 m H m n : Nat H : 0 < n t : (0 + m * n) / n = 0 / n + m := add_mul_div_right 0 m H ⊢ m * n / n = m rwa [Nat.zero_add, Nat.zero_div, Nat.zero_add] at t Qed
Nat.mul_div_cancel_left ** m n : Nat H : 0 < n ⊢ n * m / n = m rw [Nat.mul_comm, Nat.mul_div_cancel _ H] Qed
Nat.div_eq_of_eq_mul_left ** n m k : Nat H1 : 0 < n H2 : m = k * n ⊢ m / n = k rw [H2, Nat.mul_div_cancel _ H1] Qed
Nat.div_eq_of_eq_mul_right ** n m k : Nat H1 : 0 < n H2 : m = n * k ⊢ m / n = k rw [H2, Nat.mul_div_cancel_left _ H1] Qed
Nat.div_eq_of_lt_le ** k n m : Nat lo : k * n ≤ m hi : m < succ k * n hn : n = 0 ⊢ False rw [hn, Nat.mul_zero] at hi lo k n m : Nat lo : 0 ≤ m hi : m < 0 hn : n = 0 ⊢ False exact absurd lo (Nat.not_le_of_gt hi) Qed
Nat.mul_sub_div ** x n p : Nat h₁ : x < n * p ⊢ (n * p - succ x) / n = p - succ (x / n) have npos : 0 < n := (eq_zero_or_pos _).resolve_left fun n0 => by rw [n0, Nat.zero_mul] at h₁; exact not_lt_zero _ h₁ x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ (n * p - succ x) / n = p - succ (x / n) apply Nat.div_eq_of_lt_le x n p : Nat h₁ : x < n * p n0 : n = 0 ⊢ False rw [n0, Nat.zero_mul] at h₁ x n p : Nat h₁ : x < 0 n0 : n = 0 ⊢ False exact not_lt_zero _ h₁ case lo x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ (p - succ (x / n)) * n ≤ n * p - succ x rw [Nat.mul_sub_right_distrib, Nat.mul_comm] case lo x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ n * p - succ (x / n) * n ≤ n * p - succ x exact Nat.sub_le_sub_left _ <\| (div_lt_iff_lt_mul npos).1 (lt_succ_self _) case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ n * p - succ x < succ (p - succ (x / n)) * n ** show succ (pred (n * p - x)) ≤ (succ (pred (p - x / n))) * n ** case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ succ (pred (n * p - x)) ≤ succ (pred (p - x / n)) * n rw [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁), fun h => succ_pred_eq_of_pos (Nat.sub_pos_of_lt h)] case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ n * p - x ≤ (p - x / n) * n rw [Nat.mul_sub_right_distrib, Nat.mul_comm] case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ p * n - x ≤ p * n - x / n * n exact Nat.sub_le_sub_left _ <\| div_mul_le_self .. case hi x n p : Nat h₁ : x < n * p npos : 0 < n ⊢ x / n < p rwa [div_lt_iff_lt_mul npos, Nat.mul_comm] Qed
Nat.div_div_eq_div_mul ** m n k : Nat ⊢ m / n / k = m / (n * k) cases eq_zero_or_pos k with \| inl k0 => rw [k0, Nat.mul_zero, Nat.div_zero, Nat.div_zero] \| inr kpos => ?_ case inr m n k : Nat kpos : k > 0 ⊢ m / n / k = m / (n * k) cases eq_zero_or_pos n with \| inl n0 => rw [n0, Nat.zero_mul, Nat.div_zero, Nat.zero_div] \| inr npos => ?_ case inr.inr m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k = m / (n * k) apply Nat.le_antisymm case inl m n k : Nat k0 : k = 0 ⊢ m / n / k = m / (n * k) rw [k0, Nat.mul_zero, Nat.div_zero, Nat.div_zero] case inr.inl m n k : Nat kpos : k > 0 n0 : n = 0 ⊢ m / n / k = m / (n * k) rw [n0, Nat.zero_mul, Nat.div_zero, Nat.zero_div] case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k ≤ m / (n * k) apply (le_div_iff_mul_le (Nat.mul_pos npos kpos)).2 case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k * (n * k) ≤ m rw [Nat.mul_comm n k, ← Nat.mul_assoc] case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k * k * n ≤ m apply (le_div_iff_mul_le npos).1 case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k * k ≤ m / n apply (le_div_iff_mul_le kpos).1 case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k ≤ m / n / k (apply Nat.le_refl) case inr.inr.h₁ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / n / k ≤ m / n / k apply Nat.le_refl case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (n * k) ≤ m / n / k apply (le_div_iff_mul_le kpos).2 case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (n * k) * k ≤ m / n apply (le_div_iff_mul_le npos).2 case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (n * k) * k * n ≤ m rw [Nat.mul_assoc, Nat.mul_comm n k] case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (k * n) * (k * n) ≤ m apply (le_div_iff_mul_le (Nat.mul_pos kpos npos)).1 case inr.inr.h₂ m n k : Nat kpos : k > 0 npos : n > 0 ⊢ m / (k * n) ≤ m / (k * n) apply Nat.le_refl Qed
Nat.mul_div_mul_left ** m n k : Nat H : 0 < m ⊢ m * n / (m * k) = n / k rw [← Nat.div_div_eq_div_mul, Nat.mul_div_cancel_left _ H] Qed
Nat.mul_div_mul_right ** m n k : Nat H : 0 < m ⊢ n * m / (k * m) = n / k rw [Nat.mul_comm, Nat.mul_comm k, Nat.mul_div_mul_left _ _ H] Qed