Split (3)

train · 47.4k rows

formal stringlengths 41 427k	informal stringclasses 1 value
Array.size_ofFn_go α : Type u_1 n : Nat f : Fin n → α i : Nat acc : Array α ⊢ size (ofFn.go f i acc) = size acc + (n - i) if hin : i < n then unfold ofFn.go have : 1 + (n - (i + 1)) = n - i := Nat.sub_sub .. ▸ Nat.add_sub_cancel' (Nat.le_sub_of_add_le (Nat.add_comm .. ▸ hin)) rw [dif_pos hin, size_ofFn_...
Array.size_ofFn n : Nat α : Type u_1 f : Fin n → α ⊢ size (ofFn f) = n simp [ofFn] ** Qed
Array.getElem_ofFn_go n : Nat α : Type ?u.103683 f : Fin n → α i : Nat acc : Array α k : Nat hki : k < n hin : i ≤ n hi : i = size acc hacc : ∀ (j : Nat) (hj : j < size acc), acc[j] = f { val := j, isLt := (_ : j < n) } this : size acc + (n - size acc) = n ⊢ k < size (ofFn.go f i acc) simp [] * n : Nat α : Type...
Std.BinomialHeap.Imp.Heap.realSize_merge α : Type u_1 le : α → α → Bool s₁ s₂ : Heap α ⊢ realSize (merge le s₁ s₂) = realSize s₁ + realSize s₂ unfold merge ** α : Type u_1 le : α → α → Bool s₁ s₂ : Heap α ⊢ realSize (match s₁, s₂ with \| nil, h => h \| h, nil => h \| s₁@h:(cons r₁ a₁ n₁ t₁), ...
Std.BinomialHeap.Imp.Heap.realSize_findMin ** α : Type u_1 k : Heap α → Heap α n : Nat le : α → α → Bool res : FindMin α s✝ : Heap α m : Nat hk : ∀ (s : Heap α), realSize (k s) = m + realSize s hres : Std.BinomialHeap.Imp.FindMin.HasSize res n r : Nat a : α c : HeapNode α s : Heap α eq : n = m + realSize (cons r a c s)...
Std.BinomialHeap.Imp.HeapNode.realSize_toHeap α : Type u_1 s✝ : HeapNode α n : Nat res : Heap α a : α c s : HeapNode α ⊢ Heap.realSize (toHeap.go (node a c s) n res) = realSize (node a c s) + Heap.realSize res simp [toHeap.go, go, Nat.add_assoc, Nat.add_left_comm] ** Qed
Std.BinomialHeap.Imp.Heap.WF.merge' α✝ : Type u_1 le : α✝ → α✝ → Bool s₁ s₂ : Heap α✝ n : Nat h₁ : WF le n s₁ h₂ : WF le n s₂ ⊢ WF le n (merge le s₁ s₂) ∧ ((Heap.rankGT s₁ n ↔ Heap.rankGT s₂ n) → Heap.rankGT (merge le s₁ s₂) n) unfold merge ** α✝ : Type u_1 le : α✝ → α✝ → Bool s₁ s₂ : Heap α✝ n : Nat h₁ : WF le n...
Std.BinomialHeap.Imp.HeapNode.WF.toHeap ** α : Type u_1 le : α → α → Bool a✝ : α n✝ : Nat s✝ : HeapNode α h✝ : WF le a✝ s✝ n✝ res : Heap α a : α c s : HeapNode α n : Nat left✝ : ∀ [inst : TotalBLE le], le a✝ a = true h : WF le a c n h' : WF le a✝ s n hr : Heap.WF le (rank (node a c s)) res ⊢ WF le a c (rank (node a c s...
Std.BinomialHeap.Imp.Heap.WF.tail? α : Type u_1 s : Heap α le : α → α → Bool n : Nat tl : Heap α hwf : WF le n s ⊢ Heap.tail? le s = some tl → WF le 0 tl simp only [Heap.tail?] ** α : Type u_1 s : Heap α le : α → α → Bool n : Nat tl : Heap α hwf : WF le n s ⊢ Option.map (fun x => x.snd) (Heap.deleteMin le s) = so...
Nat.succ_sub m n : Nat h : n ≤ m ⊢ succ m - n = succ (m - n) let ⟨k, hk⟩ := Nat.le.dest h m n : Nat h : n ≤ m k : Nat hk : n + k = m ⊢ succ m - n = succ (m - n) rw [← hk, Nat.add_sub_cancel_left, ← add_succ, Nat.add_sub_cancel_left] ** Qed
Nat.sub_lt_left_of_lt_add n k m : Nat H : n ≤ k h : k < n + m ⊢ k - n < m have := Nat.sub_le_sub_right (succ_le_of_lt h) n n k m : Nat H : n ≤ k h : k < n + m this : succ k - n ≤ n + m - n ⊢ k - n < m rwa [Nat.add_sub_cancel_left, Nat.succ_sub H] at this ** Qed
Nat.min_comm a b : Nat ⊢ min a b = min b a simp [Nat.min_def] a b : Nat ⊢ (if a ≤ b then a else b) = if b ≤ a then b else a split <;> split <;> try simp [] * case inr.inl a b : Nat h✝¹ : ¬a ≤ b h✝ : b ≤ a ⊢ b = b ** simp [] * case inl.inl a b : Nat h✝¹ : a ≤ b h✝ : b ≤ a ⊢ a = b ** next h₁ h₂ => exact N...
Nat.min_le_right a b : Nat ⊢ min a b ≤ b rw [Nat.min_def] a b : Nat ⊢ (if a ≤ b then a else b) ≤ b split <;> simp [] * Qed
Nat.max_comm a b : Nat ⊢ max a b = max b a simp only [Nat.max_def] a b : Nat ⊢ (if a ≤ b then b else a) = if b ≤ a then a else b by_cases h₁ : a ≤ b <;> by_cases h₂ : b ≤ a <;> simp [h₁, h₂] case pos a b : Nat h₁ : a ≤ b h₂ : b ≤ a ⊢ b = a exact Nat.le_antisymm h₂ h₁ ** case neg a b : Nat h₁ : ¬a ≤ b ...
Nat.le_max_left a b : Nat ⊢ a ≤ max a b rw [Nat.max_def] a b : Nat ⊢ a ≤ if a ≤ b then b else a split <;> simp [] * Qed
Nat.pow_two_pos w : Nat ⊢ 0 < 2 decide ** Qed
Sum.liftRel_inl_inl α✝ : Type u_1 γ✝ : Type u_2 r : α✝ → γ✝ → Prop β✝ : Type u_3 δ✝ : Type u_4 s : β✝ → δ✝ → Prop a : α✝ c : γ✝ h : LiftRel r s (inl a) (inl c) ⊢ r a c cases h ** case inl α✝ : Type u_1 γ✝ : Type u_2 r : α✝ → γ✝ → Prop β✝ : Type u_3 δ✝ : Type u_4 s : β✝ → δ✝ → Prop a : α✝ c : γ✝ a✝ : r a c ⊢ r a c...
Sum.liftRel_inr_inr α✝ : Type u_1 γ✝ : Type u_2 r : α✝ → γ✝ → Prop β✝ : Type u_3 δ✝ : Type u_4 s : β✝ → δ✝ → Prop b : β✝ d : δ✝ h : LiftRel r s (inr b) (inr d) ⊢ s b d cases h ** case inr α✝ : Type u_1 γ✝ : Type u_2 r : α✝ → γ✝ → Prop β✝ : Type u_3 δ✝ : Type u_4 s : β✝ → δ✝ → Prop b : β✝ d : δ✝ a✝ : s b d ⊢ s b d...
Sum.lex_inl_inl α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop a₁ a₂ : α✝ h : Lex r s (inl a₁) (inl a₂) ⊢ r a₁ a₂ cases h case inl α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop a₁ a₂ : α✝ h✝ : r a₁ a₂ ⊢ r a₁ a₂ assumption ** Qed
Sum.lex_inr_inr α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop b₁ b₂ : β✝ h : Lex r s (inr b₁) (inr b₂) ⊢ s b₁ b₂ cases h case inr α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop b₁ b₂ : β✝ h✝ : s b₁ b₂ ⊢ s b₁ b₂ assumption ** Qed
Std.RBNode.All_and α : Type u_1 p q : α → Prop t : RBNode α ⊢ All (fun a => p a ∧ q a) t ↔ All p t ∧ All q t induction t <;> simp [, and_assoc, and_left_comm] * Qed
Std.RBNode.Ordered.balance1 α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode α lv : All (fun x => cmpLT cmp x v) l vr : All (fun x => cmpLT cmp v x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ Ordered cmp (balance1 l v r) unfold balance1 ** α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r :...
Std.RBNode.balance1_All α : Type u_1 p : α → Prop l : RBNode α v : α r : RBNode α ⊢ All p (balance1 l v r) ↔ p v ∧ All p l ∧ All p r unfold balance1 ** α : Type u_1 p : α → Prop l : RBNode α v : α r : RBNode α ⊢ All p (match l, v, r with \| node red (node red a x b) y c, z, d => node red (node black a ...
Std.RBNode.Ordered.balance2 α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode α lv : All (fun x => cmpLT cmp x v) l vr : All (fun x => cmpLT cmp v x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ Ordered cmp (balance2 l v r) unfold balance2 ** α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r :...
Std.RBNode.balance2_All α : Type u_1 p : α → Prop l : RBNode α v : α r : RBNode α ⊢ All p (balance2 l v r) ↔ p v ∧ All p l ∧ All p r unfold balance2 ** α : Type u_1 p : α → Prop l : RBNode α v : α r : RBNode α ⊢ All p (match l, v, r with \| a, x, node red (node red b y c) z d => node red (node black a ...
Std.RBNode.Ordered.setBlack α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp (setBlack t) ↔ Ordered cmp t unfold setBlack α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp (match t with \| nil => nil \| node c l v r => node black l v r) ↔ Ordered cmp t split <;...
Std.RBNode.setBlack_idem α : Type u_1 t : RBNode α ⊢ setBlack (setBlack t) = setBlack t cases t <;> rfl ** Qed
Std.RBNode.insert_setBlack α : Type u_1 cmp : α → α → Ordering v : α t : RBNode α ⊢ setBlack (insert cmp t v) = setBlack (ins cmp v t) unfold insert ** α : Type u_1 cmp : α → α → Ordering v : α t : RBNode α ⊢ setBlack (match isRed t with \| red => setBlack (ins cmp v t) \| black => ins cmp v t) = ...
Std.RBNode.All.ins α : Type u_1 p : α → Prop cmp : α → α → Ordering x : α t : RBNode α h₁ : p x h₂ : All p t ⊢ All p (ins cmp x t) induction t <;> unfold ins <;> try simp [] * case node α : Type u_1 p : α → Prop cmp : α → α → Ordering x : α h₁ : p x c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : All p ...
Std.RBNode.Ordered.ins α : Type u_1 cmp : α → α → Ordering x : α a : RBNode α y : α b : RBNode α ay : All (fun x => cmpLT cmp x y) a yb : All (fun x => cmpLT cmp y x) b ha : Ordered cmp a hb : Ordered cmp b ⊢ Ordered cmp (ins cmp x (node red a y b)) unfold ins ** α : Type u_1 cmp : α → α → Ordering x : α a : RBNo...
Std.RBNode.Ordered.insert α✝ : Type u_1 cmp : α✝ → α✝ → Ordering t : RBNode α✝ v : α✝ h : Ordered cmp t ⊢ Ordered cmp (insert cmp t v) unfold RBNode.insert ** α✝ : Type u_1 cmp : α✝ → α✝ → Ordering t : RBNode α✝ v : α✝ h : Ordered cmp t ⊢ Ordered cmp (match isRed t with \| red => setBlack (ins cmp v t) ...
Std.RBNode.RedRed.balance1 α : Type u_1 p : Prop n : Nat c : RBColor l : RBNode α v : α r : RBNode α hl : RedRed p l n hr : Balanced r c n ⊢ ∃ c, Balanced (balance1 l v r) c (n + 1) unfold balance1 ** α : Type u_1 p : Prop n : Nat c : RBColor l : RBNode α v : α r : RBNode α hl : RedRed p l n hr : Balanced r c n ⊢...
Std.RBNode.RedRed.balance2 α : Type u_1 c : RBColor n : Nat p : Prop l : RBNode α v : α r : RBNode α hl : Balanced l c n hr : RedRed p r n ⊢ ∃ c, Balanced (balance2 l v r) c (n + 1) unfold balance2 ** α : Type u_1 c : RBColor n : Nat p : Prop l : RBNode α v : α r : RBNode α hl : Balanced l c n hr : RedRed p r n ⊢...
Std.RBNode.balance1_eq α : Type u_1 c : RBColor n : Nat l : RBNode α v : α r : RBNode α hl : Balanced l c n ⊢ balance1 l v r = node black l v r unfold balance1 ** α : Type u_1 c : RBColor n : Nat l : RBNode α v : α r : RBNode α hl : Balanced l c n ⊢ (match l, v, r with \| node red (node red a x b) y c, z, d =>...
Std.RBNode.balance2_eq α : Type u_1 c : RBColor n : Nat l : RBNode α v : α r : RBNode α hr : Balanced r c n ⊢ balance2 l v r = node black l v r unfold balance2 ** α : Type u_1 c : RBColor n : Nat l : RBNode α v : α r : RBNode α hr : Balanced r c n ⊢ (match l, v, r with \| a, x, node red (node red b y c) z d =>...
Std.RBNode.Balanced.ins case nil α : Type u_1 c : RBColor n : Nat cmp : α → α → Ordering v : α t : RBNode α ⊢ RedRed (isRed nil = red) (ins cmp v nil) 0 exact .balanced (.red .nil .nil) ** case red α : Type u_1 c : RBColor n✝ : Nat cmp : α → α → Ordering v : α t a : RBNode α n : Nat b : RBNode α x : α hl : Balanc...
Std.RBNode.Balanced.insert α : Type u_1 c : RBColor n : Nat cmp : α → α → Ordering v : α t : RBNode α h : Balanced t c n ⊢ ∃ c' n', Balanced (RBNode.insert cmp t v) c' n' unfold insert ** α : Type u_1 c : RBColor n : Nat cmp : α → α → Ordering v : α t : RBNode α h : Balanced t c n ⊢ ∃ c' n', Balanced (m...
Std.RBNode.All.setRed α : Type u_1 p : α → Prop t : RBNode α h : All p t ⊢ All p (setRed t) unfold setRed α : Type u_1 p : α → Prop t : RBNode α h : All p t ⊢ All p (match t with \| node c a v b => node red a v b \| nil => nil) split <;> simp_all ** Qed
Std.RBNode.Ordered.setRed α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp (setRed t) ↔ Ordered cmp t unfold setRed α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp (match t with \| node c a v b => node red a v b \| nil => nil) ↔ Ordered cmp t split <;> simp [...
Std.RBNode.All.balLeft α✝ : Type u_1 p : α✝ → Prop l : RBNode α✝ v : α✝ r : RBNode α✝ hl : All p l hv : p v hr : All p r ⊢ All p (balLeft l v r) unfold balLeft ** α✝ : Type u_1 p : α✝ → Prop l : RBNode α✝ v : α✝ r : RBNode α✝ hl : All p l hv : p v hr : All p r ⊢ All p (match l with \| node red a x b => nod...
Std.RBNode.Ordered.balLeft α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode α lv : All (fun x => cmpLT cmp x v) l vr : All (fun x => cmpLT cmp v x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ Ordered cmp (balLeft l v r) unfold balLeft ** α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RB...
Std.RBNode.Balanced.balLeft α✝ : Type u_1 l : RBNode α✝ v : α✝ r : RBNode α✝ cr : RBColor n : Nat hl : RedRed True l n hr : Balanced r cr (n + 1) ⊢ RedRed (cr = red) (balLeft l v r) (n + 1) unfold balLeft ** α✝ : Type u_1 l : RBNode α✝ v : α✝ r : RBNode α✝ cr : RBColor n : Nat hl : RedRed True l n hr : Balanced r...
Std.RBNode.All.balRight α✝ : Type u_1 p : α✝ → Prop l : RBNode α✝ v : α✝ r : RBNode α✝ hl : All p l hv : p v hr : All p r ⊢ All p (balRight l v r) unfold balRight ** α✝ : Type u_1 p : α✝ → Prop l : RBNode α✝ v : α✝ r : RBNode α✝ hl : All p l hv : p v hr : All p r ⊢ All p (match r with \| node red b y c => ...
Std.RBNode.Balanced.balRight α✝ : Type u_1 l : RBNode α✝ v : α✝ r : RBNode α✝ cl : RBColor n : Nat hl : Balanced l cl (n + 1) hr : RedRed True r n ⊢ RedRed (cl = red) (balRight l v r) (n + 1) unfold balRight ** α✝ : Type u_1 l : RBNode α✝ v : α✝ r : RBNode α✝ cl : RBColor n : Nat hl : Balanced l cl (n + 1) hr : R...
Std.RBNode.Ordered.append α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode α lv : All (fun x => cmpLT cmp x v) l vr : All (fun x => cmpLT cmp v x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ Ordered cmp (append l r) unfold append ** α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode ...
Std.RBNode.Balanced.append α : Type u_1 c₁ : RBColor n : Nat c₂ : RBColor l r : RBNode α hl : Balanced l c₁ n hr : Balanced r c₂ n ⊢ RedRed (c₁ = black → c₂ ≠ black) (append l r) n unfold append ** α : Type u_1 c₁ : RBColor n : Nat c₂ : RBColor l r : RBNode α hl : Balanced l c₁ n hr : Balanced r c₂ n ⊢ RedRed (c₁...
Std.RBNode.DelProp.redred c : RBColor α✝ : Type u_1 t : RBNode α✝ n : Nat h : DelProp c t n ⊢ ∃ n', RedRed (c = black) t n' unfold DelProp at h ** c : RBColor α✝ : Type u_1 t : RBNode α✝ n : Nat h : match c with \| black => ∃ n', n = n' + 1 ∧ RedRed True t n' \| red => ∃ c, Balanced t c n ⊢ ∃ n', RedRed (c = ...
Std.RBNode.All.del α : Type u_1 p : α → Prop cut : α → Ordering c✝ : RBColor a✝² : RBNode α a✝¹ : α a✝ : RBNode α hy : p a✝¹ ha : All p a✝² hb : All p a✝ ⊢ All p (del cut (node c✝ a✝² a✝¹ a✝)) unfold del ** α : Type u_1 p : α → Prop cut : α → Ordering c✝ : RBColor a✝² : RBNode α a✝¹ : α a✝ : RBNode α hy : p a✝¹ h...
Std.RBNode.Ordered.del α : Type u_1 cmp : α → α → Ordering cut : α → Ordering c✝ : RBColor a : RBNode α y : α b : RBNode α ay : All (fun x => cmpLT cmp x y) a yb : All (fun x => cmpLT cmp y x) b ha : Ordered cmp a hb : Ordered cmp b ⊢ Ordered cmp (del cut (node c✝ a y b)) unfold del ** α : Type u_1 cmp : α → α → ...
Std.RBNode.Balanced.del case nil α : Type u_1 c : RBColor n : Nat cut : α → Ordering t : RBNode α ⊢ DelProp (isBlack nil) (del cut nil) 0 exact ⟨_, .nil⟩ ** case black α : Type u_1 c : RBColor n✝ : Nat cut : α → Ordering t a : RBNode α c₁✝ : RBColor n : Nat b : RBNode α c₂✝ : RBColor v✝ : α ha : Balanced a c₁✝ n ...
Rat.maybeNormalize_eq num : Int den g : Nat den_nz : den / g ≠ 0 reduced : Nat.Coprime (Int.natAbs (Int.div num ↑g)) (den / g) ⊢ maybeNormalize num den g den_nz reduced = mk' (Int.div num ↑g) (den / g) unfold maybeNormalize ** num : Int den g : Nat den_nz : den / g ≠ 0 reduced : Nat.Coprime (Int.natAbs (Int.div n...
Rat.normalize_zero d : Nat nz : d ≠ 0 ⊢ normalize 0 d = 0 simp [normalize, Int.zero_div, Int.natAbs_zero, Nat.div_self (Nat.pos_of_ne_zero nz)] d : Nat nz : d ≠ 0 ⊢ mk' 0 1 = 0 rfl ** Qed
Rat.mk_eq_normalize num : Int den : Nat nz : den ≠ 0 c : Nat.Coprime (Int.natAbs num) den ⊢ mk' num den = normalize num den simp [normalize_eq, c.gcd_eq_one] ** Qed
Rat.normalize_mul_left ** d : Nat n : Int a : Nat d0 : d ≠ 0 a0 : a ≠ 0 ⊢ normalize (↑a * n) (a * d) = normalize n d ** simp [normalize_eq, mk'.injEq, Int.natAbs_mul, Nat.gcd_mul_left, Nat.mul_div_mul_left _ _ (Nat.pos_of_ne_zero a0), Int.ofNat_mul, Int.mul_ediv_mul_of_pos _ _ (Int.ofNat_pos.2 <\| Nat.pos_of_ne_zero...
Rat.normalize_mul_right ** d : Nat n : Int a : Nat d0 : d ≠ 0 a0 : a ≠ 0 ⊢ normalize (n * ↑a) (d * a) = normalize n d rw [← normalize_mul_left (d0 := d0) a0] d : Nat n : Int a : Nat d0 : d ≠ 0 a0 : a ≠ 0 ⊢ normalize (n * ↑a) (d * a) = normalize (↑a * n) (a * d) ** congr 1 <;> [apply Int.mul_comm; apply Nat.mul_co...
Rat.maybeNormalize_eq_normalize num : Int den g : Nat den_nz : den / g ≠ 0 reduced : Nat.Coprime (Int.natAbs (Int.div num ↑g)) (den / g) hn : ↑g ∣ num hd : g ∣ den ⊢ maybeNormalize num den g den_nz reduced = normalize num den simp only [maybeNormalize_eq, mk_eq_normalize, Int.div_eq_ediv_of_dvd hn] ** num : Int d...
Rat.normalize_num_den' ** num : Int den : Nat nz : den ≠ 0 ⊢ ∃ d, d ≠ 0 ∧ num = (normalize num den).num * ↑d ∧ den = (normalize num den).den * d refine ⟨num.natAbs.gcd den, Nat.gcd_ne_zero_right nz, ?_⟩ num : Int den : Nat nz : den ≠ 0 ⊢ num = (normalize num den).num * ↑(Nat.gcd (Int.natAbs num) den) ∧ den = ...
Rat.normalize_eq_mkRat num : Int den : Nat den_nz : den ≠ 0 ⊢ normalize num den = mkRat num den simp [mkRat, den_nz] ** Qed
Rat.mkRat_self a : Rat ⊢ mkRat a.num a.den = a rw [← normalize_eq_mkRat a.den_nz, normalize_self] ** Qed
Rat.mk_eq_mkRat num : Int den : Nat nz : den ≠ 0 c : Nat.Coprime (Int.natAbs num) den ⊢ mk' num den = mkRat num den simp [mk_eq_normalize, normalize_eq_mkRat] ** Qed
Rat.zero_mkRat n : Nat ⊢ mkRat 0 n = 0 simp [mkRat_def] n : Nat ⊢ (if h : n = 0 then 0 else 0) = 0 apply ite_self ** Qed
Rat.mkRat_zero n : Int ⊢ mkRat n 0 = 0 simp [mkRat_def] ** Qed
Rat.mkRat_eq_zero d : Nat n : Int d0 : d ≠ 0 ⊢ mkRat n d = 0 ↔ n = 0 simp [mkRat_def, d0] ** Qed
Rat.mkRat_mul_left ** n : Int d a : Nat a0 : a ≠ 0 ⊢ mkRat (↑a * n) (a * d) = mkRat n d if d0 : d = 0 then simp [d0] else rw [← normalize_eq_mkRat d0, ← normalize_mul_left d0 a0, normalize_eq_mkRat] n : Int d a : Nat a0 : a ≠ 0 d0 : d = 0 ⊢ mkRat (↑a * n) (a * d) = mkRat n d simp [d0] n : Int d a : Nat a0 :...
Rat.mkRat_eq_iff ** d₁ d₂ : Nat n₁ n₂ : Int z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ mkRat n₁ d₁ = mkRat n₂ d₂ ↔ n₁ * ↑d₂ = n₂ * ↑d₁ rw [← normalize_eq_mkRat z₁, ← normalize_eq_mkRat z₂, normalize_eq_iff] Qed
Rat.divInt_ofNat num : Int den : Nat ⊢ num /. ↑den = mkRat num den simp [divInt, normalize_eq_mkRat] ** Qed
Rat.divInt_self a : Rat ⊢ a.num /. ↑a.den = a rw [divInt_ofNat, mkRat_self] ** Qed
Rat.zero_divInt n : Int ⊢ 0 /. n = 0 cases n <;> simp [divInt] ** Qed
Rat.neg_divInt_neg num den : Int ⊢ -num /. -den = num /. den match den with \| Nat.succ n => simp [divInt, Int.neg_ofNat_succ, normalize_eq_mkRat, Int.neg_neg] \| 0 => rfl \| Int.negSucc n => simp [divInt, Int.neg_negSucc, normalize_eq_mkRat, Int.neg_neg] ** num den : Int n : Nat ⊢ -num /. -↑(Nat.succ n) = num /. ↑(...
Rat.divInt_neg' num den : Int ⊢ num /. -den = -num /. den rw [← neg_divInt_neg, Int.neg_neg] ** Qed
Rat.divInt_eq_iff ** d₁ d₂ n₁ n₂ : Int z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ n₁ /. d₁ = n₂ /. d₂ ↔ n₁ * d₂ = n₂ * d₁ ** rcases Int.eq_nat_or_neg d₁ with ⟨_, rfl \| rfl⟩ <;> rcases Int.eq_nat_or_neg d₂ with ⟨_, rfl \| rfl⟩ <;> simp_all [divInt_neg', Int.ofNat_eq_zero, Int.neg_eq_zero, mkRat_eq_iff, Int.neg_mul, Int.mul_neg, Int.eq_...
Rat.divInt_num_den ** d n n' : Int d' : Nat z' : d' ≠ 0 c : Nat.Coprime (Int.natAbs n') d' z : d ≠ 0 h : n /. d = mk' n' d' ⊢ ∃ m, m ≠ 0 ∧ n = n' * m ∧ d = ↑d' * m rcases Int.eq_nat_or_neg d with ⟨_, rfl \| rfl⟩ <;> simp_all [divInt_neg', Int.ofNat_eq_zero, Int.neg_eq_zero] case intro.inl n n' : Int d' : Nat z' ...
Rat.add_def ** a b : Rat ⊢ a + b = normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) show Rat.add .. = _ a b : Rat ⊢ Rat.add a b = normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) delta Rat.add a b : Rat ⊢ (let g := Nat.gcd a.den b.den; if hg : g = 1 then let_fun den_nz := (_ ...
Rat.add_def' ** a b : Rat ⊢ a + b = mkRat (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) rw [add_def, normalize_eq_mkRat] Qed
Rat.normalize_add_normalize ** n₁ n₂ : Int d₁ d₂ : Nat z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ normalize n₁ d₁ + normalize n₂ d₂ = normalize (n₁ * ↑d₂ + n₂ * ↑d₁) (d₁ * d₂) cases e₁ : normalize n₁ d₁ z₁ case mk' n₁ n₂ : Int d₁ d₂ : Nat z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 num✝ : Int den✝ : Nat den_nz✝ : den✝ ≠ 0 reduced✝ : Nat.Coprime (Int...
Rat.divInt_add_divInt ** n₁ n₂ d₁ d₂ : Int z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ n₁ /. d₁ + n₂ /. d₂ = (n₁ * d₂ + n₂ * d₁) /. (d₁ * d₂) ** rcases Int.eq_nat_or_neg d₁ with ⟨_, rfl \| rfl⟩ <;> rcases Int.eq_nat_or_neg d₂ with ⟨_, rfl \| rfl⟩ <;> simp_all [-Int.natCast_mul, Int.ofNat_eq_zero, Int.neg_eq_zero, divInt_neg', Int.mul_neg,...
Rat.neg_normalize n : Int d : Nat z : d ≠ 0 ⊢ -normalize n d = normalize (-n) d simp [normalize, maybeNormalize_eq] n : Int d : Nat z : d ≠ 0 ⊢ -mk' (Int.div n ↑(Nat.gcd (Int.natAbs n) d)) (d / Nat.gcd (Int.natAbs n) d) = mk' (-Int.div n ↑(Nat.gcd (Int.natAbs n) d)) (d / Nat.gcd (Int.natAbs n) d) ext <;...
Rat.sub_def ** a b : Rat ⊢ a - b = normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) show Rat.sub .. = _ a b : Rat ⊢ Rat.sub a b = normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) delta Rat.sub a b : Rat ⊢ (let g := Nat.gcd a.den b.den; if hg : g = 1 then let_fun den_nz := (_ ...
Rat.sub_def' ** a b : Rat ⊢ a - b = mkRat (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) rw [sub_def, normalize_eq_mkRat] Qed
Rat.sub_eq_add_neg a b : Rat ⊢ a - b = a + -b simp [add_def, sub_def, Int.neg_mul, Int.sub_eq_add_neg] ** Qed
Rat.mul_def ** a b : Rat ⊢ a * b = normalize (a.num * b.num) (a.den * b.den) show Rat.mul .. = _ a b : Rat ⊢ Rat.mul a b = normalize (a.num * b.num) (a.den * b.den) delta Rat.mul a b : Rat ⊢ (let g1 := Nat.gcd (Int.natAbs a.num) b.den; let g2 := Nat.gcd (Int.natAbs b.num) a.den; mk' (Int.div a.num ↑...
Rat.mul_comm ** a b : Rat ⊢ a * b = b * a simp [mul_def, normalize_eq_mkRat, Int.mul_comm, Nat.mul_comm] Qed
Rat.zero_mul ** a : Rat ⊢ 0 * a = 0 simp [mul_def] Qed
Rat.mul_zero ** a : Rat ⊢ a * 0 = 0 simp [mul_def] Qed
Rat.one_mul ** a : Rat ⊢ 1 * a = a simp [mul_def, normalize_self] Qed
Rat.mul_one ** a : Rat ⊢ a * 1 = a simp [mul_def, normalize_self] Qed
Rat.normalize_mul_normalize ** n₁ n₂ : Int d₁ d₂ : Nat z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ normalize n₁ d₁ * normalize n₂ d₂ = normalize (n₁ * n₂) (d₁ * d₂) cases e₁ : normalize n₁ d₁ z₁ case mk' n₁ n₂ : Int d₁ d₂ : Nat z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 num✝ : Int den✝ : Nat den_nz✝ : den✝ ≠ 0 reduced✝ : Nat.Coprime (Int.natAbs num✝...
Rat.divInt_mul_divInt ** n₁ n₂ d₁ d₂ : Int z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ n₁ /. d₁ * (n₂ /. d₂) = n₁ * n₂ /. (d₁ * d₂) ** rcases Int.eq_nat_or_neg d₁ with ⟨_, rfl \| rfl⟩ <;> rcases Int.eq_nat_or_neg d₂ with ⟨_, rfl \| rfl⟩ <;> simp_all [-Int.natCast_mul, divInt_neg', Int.mul_neg, Int.ofNat_mul_ofNat, Int.neg_mul, mkRat_mu...
Rat.inv_def a : Rat ⊢ Rat.inv a = ↑a.den /. a.num unfold Rat.inv a : Rat ⊢ (if h : a.num < 0 then mk' (-↑a.den) (Int.natAbs a.num) else if h : a.num > 0 then mk' (↑a.den) (Int.natAbs a.num) else a) = ↑a.den /. a.num split ** case inr a : Rat h✝ : ¬a.num < 0 ⊢ (if h : a.num > 0 then mk' (↑a.den) (Int...
Rat.inv_zero ⊢ Rat.inv 0 = 0 unfold Rat.inv ⊢ (if h : 0.num < 0 then mk' (-↑0.den) (Int.natAbs 0.num) else if h : 0.num > 0 then mk' (↑0.den) (Int.natAbs 0.num) else 0) = 0 simp ** Qed
Rat.ofScientific_true_def m e : Nat ⊢ Rat.ofScientific m true e = mkRat (↑m) (10 ^ e) unfold Rat.ofScientific ** m e : Nat ⊢ (if true = true then normalize (↑m) (10 ^ e) else ↑↑(m * 10 ^ e)) = mkRat (↑m) (10 ^ e) rw [normalize_eq_mkRat] m e : Nat ⊢ (if true = true then mkRat (↑m) (10 ^ e) else ↑↑(m * 10 ^ e...
Rat.ofScientific_false_def ** m e : Nat ⊢ Rat.ofScientific m false e = ↑↑(m * 10 ^ e) unfold Rat.ofScientific m e : Nat ⊢ (if false = true then normalize (↑m) (10 ^ e) else ↑↑(m * 10 ^ e)) = ↑↑(m * 10 ^ e) rfl Qed
Rat.ofScientific_def ** m : Nat s : Bool e : Nat ⊢ Rat.ofScientific m s e = if s = true then mkRat (↑m) (10 ^ e) else ↑↑(m * 10 ^ e) cases s case false m e : Nat ⊢ Rat.ofScientific m false e = if false = true then mkRat (↑m) (10 ^ e) else ↑↑(m * 10 ^ e) case true m e : Nat ⊢ Rat.ofScientific m true e = if true =...
Rat.intCast_add a b : Int ⊢ ↑(a + b) = ↑a + ↑b rw [add_def] ** a b : Int ⊢ ↑(a + b) = normalize ((↑a).num * ↑(↑b).den + (↑b).num * ↑(↑a).den) ((↑a).den * (↑b).den) ext <;> simp [normalize_eq] Qed
Rat.intCast_neg a : Int ⊢ ↑(-a) = -↑a ext <;> simp [normalize_eq] ** Qed
Rat.intCast_sub a b : Int ⊢ ↑(a - b) = ↑a - ↑b rw [sub_def] ** a b : Int ⊢ ↑(a - b) = normalize ((↑a).num * ↑(↑b).den - (↑b).num * ↑(↑a).den) ((↑a).den * (↑b).den) ext <;> simp [normalize_eq] Qed
Rat.intCast_mul ** a b : Int ⊢ ↑(a * b) = ↑a * ↑b rw [mul_def] a b : Int ⊢ ↑(a * b) = normalize ((↑a).num * (↑b).num) ((↑a).den * (↑b).den) ext <;> simp [normalize_eq] Qed
Nat.gcd_rec m n : Nat ⊢ gcd 0 n = gcd (n % 0) 0 have := (mod_zero n).symm m n : Nat this : n = n % 0 ⊢ gcd 0 n = gcd (n % 0) 0 rwa [gcd_zero_right] m n n✝ : Nat ⊢ gcd (n✝ + 1) n = gcd (n % (n✝ + 1)) (n✝ + 1) simp [gcd_succ] ** Qed
Nat.gcd_dvd m n : Nat ⊢ gcd m n ∣ m ∧ gcd m n ∣ n induction m, n using gcd.induction with \| H0 n => rw [gcd_zero_left]; exact ⟨Nat.dvd_zero n, Nat.dvd_refl n⟩ \| H1 m n _ IH => rw [← gcd_rec] at IH; exact ⟨IH.2, (dvd_mod_iff IH.2).1 IH.1⟩ case H0 n : Nat ⊢ gcd 0 n ∣ 0 ∧ gcd 0 n ∣ n rw [gcd_zero_left] ** case...
Nat.dvd_gcd k m n : Nat ⊢ k ∣ m → k ∣ n → k ∣ gcd m n induction m, n using gcd.induction with intro km kn \| H0 n => rw [gcd_zero_left]; exact kn \| H1 n m _ IH => rw [gcd_rec]; exact IH ((dvd_mod_iff km).2 kn) km case H0 k n : Nat km : k ∣ 0 kn : k ∣ n ⊢ k ∣ gcd 0 n rw [gcd_zero_left] ** case H0 k n : Nat km...

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
Array.size_ofFn_go α : Type u_1 n : Nat f : Fin n → α i : Nat acc : Array α ⊢ size (ofFn.go f i acc) = size acc + (n - i) if hin : i < n then unfold ofFn.go have : 1 + (n - (i + 1)) = n - i := Nat.sub_sub .. ▸ Nat.add_sub_cancel' (Nat.le_sub_of_add_le (Nat.add_comm .. ▸ hin)) rw [dif_pos hin, size_ofFn_...
Array.size_ofFn n : Nat α : Type u_1 f : Fin n → α ⊢ size (ofFn f) = n simp [ofFn] ** Qed
Array.getElem_ofFn_go n : Nat α : Type ?u.103683 f : Fin n → α i : Nat acc : Array α k : Nat hki : k < n hin : i ≤ n hi : i = size acc hacc : ∀ (j : Nat) (hj : j < size acc), acc[j] = f { val := j, isLt := (_ : j < n) } this : size acc + (n - size acc) = n ⊢ k < size (ofFn.go f i acc) simp [] * n : Nat α : Type...
Std.BinomialHeap.Imp.Heap.realSize_merge α : Type u_1 le : α → α → Bool s₁ s₂ : Heap α ⊢ realSize (merge le s₁ s₂) = realSize s₁ + realSize s₂ unfold merge ** α : Type u_1 le : α → α → Bool s₁ s₂ : Heap α ⊢ realSize (match s₁, s₂ with \| nil, h => h \| h, nil => h \| s₁@h:(cons r₁ a₁ n₁ t₁), ...
Std.BinomialHeap.Imp.Heap.realSize_findMin ** α : Type u_1 k : Heap α → Heap α n : Nat le : α → α → Bool res : FindMin α s✝ : Heap α m : Nat hk : ∀ (s : Heap α), realSize (k s) = m + realSize s hres : Std.BinomialHeap.Imp.FindMin.HasSize res n r : Nat a : α c : HeapNode α s : Heap α eq : n = m + realSize (cons r a c s)...
Std.BinomialHeap.Imp.HeapNode.realSize_toHeap α : Type u_1 s✝ : HeapNode α n : Nat res : Heap α a : α c s : HeapNode α ⊢ Heap.realSize (toHeap.go (node a c s) n res) = realSize (node a c s) + Heap.realSize res simp [toHeap.go, go, Nat.add_assoc, Nat.add_left_comm] ** Qed
Std.BinomialHeap.Imp.Heap.WF.merge' α✝ : Type u_1 le : α✝ → α✝ → Bool s₁ s₂ : Heap α✝ n : Nat h₁ : WF le n s₁ h₂ : WF le n s₂ ⊢ WF le n (merge le s₁ s₂) ∧ ((Heap.rankGT s₁ n ↔ Heap.rankGT s₂ n) → Heap.rankGT (merge le s₁ s₂) n) unfold merge ** α✝ : Type u_1 le : α✝ → α✝ → Bool s₁ s₂ : Heap α✝ n : Nat h₁ : WF le n...
Std.BinomialHeap.Imp.HeapNode.WF.toHeap ** α : Type u_1 le : α → α → Bool a✝ : α n✝ : Nat s✝ : HeapNode α h✝ : WF le a✝ s✝ n✝ res : Heap α a : α c s : HeapNode α n : Nat left✝ : ∀ [inst : TotalBLE le], le a✝ a = true h : WF le a c n h' : WF le a✝ s n hr : Heap.WF le (rank (node a c s)) res ⊢ WF le a c (rank (node a c s...
Std.BinomialHeap.Imp.Heap.WF.tail? α : Type u_1 s : Heap α le : α → α → Bool n : Nat tl : Heap α hwf : WF le n s ⊢ Heap.tail? le s = some tl → WF le 0 tl simp only [Heap.tail?] ** α : Type u_1 s : Heap α le : α → α → Bool n : Nat tl : Heap α hwf : WF le n s ⊢ Option.map (fun x => x.snd) (Heap.deleteMin le s) = so...
Nat.succ_sub m n : Nat h : n ≤ m ⊢ succ m - n = succ (m - n) let ⟨k, hk⟩ := Nat.le.dest h m n : Nat h : n ≤ m k : Nat hk : n + k = m ⊢ succ m - n = succ (m - n) rw [← hk, Nat.add_sub_cancel_left, ← add_succ, Nat.add_sub_cancel_left] ** Qed
Nat.sub_lt_left_of_lt_add n k m : Nat H : n ≤ k h : k < n + m ⊢ k - n < m have := Nat.sub_le_sub_right (succ_le_of_lt h) n n k m : Nat H : n ≤ k h : k < n + m this : succ k - n ≤ n + m - n ⊢ k - n < m rwa [Nat.add_sub_cancel_left, Nat.succ_sub H] at this ** Qed
Nat.min_comm a b : Nat ⊢ min a b = min b a simp [Nat.min_def] a b : Nat ⊢ (if a ≤ b then a else b) = if b ≤ a then b else a split <;> split <;> try simp [] * case inr.inl a b : Nat h✝¹ : ¬a ≤ b h✝ : b ≤ a ⊢ b = b ** simp [] * case inl.inl a b : Nat h✝¹ : a ≤ b h✝ : b ≤ a ⊢ a = b ** next h₁ h₂ => exact N...
Nat.min_le_right a b : Nat ⊢ min a b ≤ b rw [Nat.min_def] a b : Nat ⊢ (if a ≤ b then a else b) ≤ b split <;> simp [] * Qed
Nat.max_comm a b : Nat ⊢ max a b = max b a simp only [Nat.max_def] a b : Nat ⊢ (if a ≤ b then b else a) = if b ≤ a then a else b by_cases h₁ : a ≤ b <;> by_cases h₂ : b ≤ a <;> simp [h₁, h₂] case pos a b : Nat h₁ : a ≤ b h₂ : b ≤ a ⊢ b = a exact Nat.le_antisymm h₂ h₁ ** case neg a b : Nat h₁ : ¬a ≤ b ...
Nat.le_max_left a b : Nat ⊢ a ≤ max a b rw [Nat.max_def] a b : Nat ⊢ a ≤ if a ≤ b then b else a split <;> simp [] * Qed
Nat.pow_two_pos w : Nat ⊢ 0 < 2 decide ** Qed
Sum.liftRel_inl_inl α✝ : Type u_1 γ✝ : Type u_2 r : α✝ → γ✝ → Prop β✝ : Type u_3 δ✝ : Type u_4 s : β✝ → δ✝ → Prop a : α✝ c : γ✝ h : LiftRel r s (inl a) (inl c) ⊢ r a c cases h ** case inl α✝ : Type u_1 γ✝ : Type u_2 r : α✝ → γ✝ → Prop β✝ : Type u_3 δ✝ : Type u_4 s : β✝ → δ✝ → Prop a : α✝ c : γ✝ a✝ : r a c ⊢ r a c...
Sum.liftRel_inr_inr α✝ : Type u_1 γ✝ : Type u_2 r : α✝ → γ✝ → Prop β✝ : Type u_3 δ✝ : Type u_4 s : β✝ → δ✝ → Prop b : β✝ d : δ✝ h : LiftRel r s (inr b) (inr d) ⊢ s b d cases h ** case inr α✝ : Type u_1 γ✝ : Type u_2 r : α✝ → γ✝ → Prop β✝ : Type u_3 δ✝ : Type u_4 s : β✝ → δ✝ → Prop b : β✝ d : δ✝ a✝ : s b d ⊢ s b d...
Sum.lex_inl_inl α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop a₁ a₂ : α✝ h : Lex r s (inl a₁) (inl a₂) ⊢ r a₁ a₂ cases h case inl α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop a₁ a₂ : α✝ h✝ : r a₁ a₂ ⊢ r a₁ a₂ assumption ** Qed
Sum.lex_inr_inr α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop b₁ b₂ : β✝ h : Lex r s (inr b₁) (inr b₂) ⊢ s b₁ b₂ cases h case inr α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop b₁ b₂ : β✝ h✝ : s b₁ b₂ ⊢ s b₁ b₂ assumption ** Qed
Std.RBNode.All_and α : Type u_1 p q : α → Prop t : RBNode α ⊢ All (fun a => p a ∧ q a) t ↔ All p t ∧ All q t induction t <;> simp [, and_assoc, and_left_comm] * Qed
Std.RBNode.Ordered.balance1 α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode α lv : All (fun x => cmpLT cmp x v) l vr : All (fun x => cmpLT cmp v x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ Ordered cmp (balance1 l v r) unfold balance1 ** α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r :...
Std.RBNode.balance1_All α : Type u_1 p : α → Prop l : RBNode α v : α r : RBNode α ⊢ All p (balance1 l v r) ↔ p v ∧ All p l ∧ All p r unfold balance1 ** α : Type u_1 p : α → Prop l : RBNode α v : α r : RBNode α ⊢ All p (match l, v, r with \| node red (node red a x b) y c, z, d => node red (node black a ...
Std.RBNode.Ordered.balance2 α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode α lv : All (fun x => cmpLT cmp x v) l vr : All (fun x => cmpLT cmp v x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ Ordered cmp (balance2 l v r) unfold balance2 ** α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r :...
Std.RBNode.balance2_All α : Type u_1 p : α → Prop l : RBNode α v : α r : RBNode α ⊢ All p (balance2 l v r) ↔ p v ∧ All p l ∧ All p r unfold balance2 ** α : Type u_1 p : α → Prop l : RBNode α v : α r : RBNode α ⊢ All p (match l, v, r with \| a, x, node red (node red b y c) z d => node red (node black a ...
Std.RBNode.Ordered.setBlack α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp (setBlack t) ↔ Ordered cmp t unfold setBlack α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp (match t with \| nil => nil \| node c l v r => node black l v r) ↔ Ordered cmp t split <;...
Std.RBNode.setBlack_idem α : Type u_1 t : RBNode α ⊢ setBlack (setBlack t) = setBlack t cases t <;> rfl ** Qed
Std.RBNode.insert_setBlack α : Type u_1 cmp : α → α → Ordering v : α t : RBNode α ⊢ setBlack (insert cmp t v) = setBlack (ins cmp v t) unfold insert ** α : Type u_1 cmp : α → α → Ordering v : α t : RBNode α ⊢ setBlack (match isRed t with \| red => setBlack (ins cmp v t) \| black => ins cmp v t) = ...
Std.RBNode.All.ins α : Type u_1 p : α → Prop cmp : α → α → Ordering x : α t : RBNode α h₁ : p x h₂ : All p t ⊢ All p (ins cmp x t) induction t <;> unfold ins <;> try simp [] * case node α : Type u_1 p : α → Prop cmp : α → α → Ordering x : α h₁ : p x c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : All p ...
Std.RBNode.Ordered.ins α : Type u_1 cmp : α → α → Ordering x : α a : RBNode α y : α b : RBNode α ay : All (fun x => cmpLT cmp x y) a yb : All (fun x => cmpLT cmp y x) b ha : Ordered cmp a hb : Ordered cmp b ⊢ Ordered cmp (ins cmp x (node red a y b)) unfold ins ** α : Type u_1 cmp : α → α → Ordering x : α a : RBNo...
Std.RBNode.Ordered.insert α✝ : Type u_1 cmp : α✝ → α✝ → Ordering t : RBNode α✝ v : α✝ h : Ordered cmp t ⊢ Ordered cmp (insert cmp t v) unfold RBNode.insert ** α✝ : Type u_1 cmp : α✝ → α✝ → Ordering t : RBNode α✝ v : α✝ h : Ordered cmp t ⊢ Ordered cmp (match isRed t with \| red => setBlack (ins cmp v t) ...
Std.RBNode.RedRed.balance1 α : Type u_1 p : Prop n : Nat c : RBColor l : RBNode α v : α r : RBNode α hl : RedRed p l n hr : Balanced r c n ⊢ ∃ c, Balanced (balance1 l v r) c (n + 1) unfold balance1 ** α : Type u_1 p : Prop n : Nat c : RBColor l : RBNode α v : α r : RBNode α hl : RedRed p l n hr : Balanced r c n ⊢...
Std.RBNode.RedRed.balance2 α : Type u_1 c : RBColor n : Nat p : Prop l : RBNode α v : α r : RBNode α hl : Balanced l c n hr : RedRed p r n ⊢ ∃ c, Balanced (balance2 l v r) c (n + 1) unfold balance2 ** α : Type u_1 c : RBColor n : Nat p : Prop l : RBNode α v : α r : RBNode α hl : Balanced l c n hr : RedRed p r n ⊢...
Std.RBNode.balance1_eq α : Type u_1 c : RBColor n : Nat l : RBNode α v : α r : RBNode α hl : Balanced l c n ⊢ balance1 l v r = node black l v r unfold balance1 ** α : Type u_1 c : RBColor n : Nat l : RBNode α v : α r : RBNode α hl : Balanced l c n ⊢ (match l, v, r with \| node red (node red a x b) y c, z, d =>...
Std.RBNode.balance2_eq α : Type u_1 c : RBColor n : Nat l : RBNode α v : α r : RBNode α hr : Balanced r c n ⊢ balance2 l v r = node black l v r unfold balance2 ** α : Type u_1 c : RBColor n : Nat l : RBNode α v : α r : RBNode α hr : Balanced r c n ⊢ (match l, v, r with \| a, x, node red (node red b y c) z d =>...
Std.RBNode.Balanced.ins case nil α : Type u_1 c : RBColor n : Nat cmp : α → α → Ordering v : α t : RBNode α ⊢ RedRed (isRed nil = red) (ins cmp v nil) 0 exact .balanced (.red .nil .nil) ** case red α : Type u_1 c : RBColor n✝ : Nat cmp : α → α → Ordering v : α t a : RBNode α n : Nat b : RBNode α x : α hl : Balanc...
Std.RBNode.Balanced.insert α : Type u_1 c : RBColor n : Nat cmp : α → α → Ordering v : α t : RBNode α h : Balanced t c n ⊢ ∃ c' n', Balanced (RBNode.insert cmp t v) c' n' unfold insert ** α : Type u_1 c : RBColor n : Nat cmp : α → α → Ordering v : α t : RBNode α h : Balanced t c n ⊢ ∃ c' n', Balanced (m...
Std.RBNode.All.setRed α : Type u_1 p : α → Prop t : RBNode α h : All p t ⊢ All p (setRed t) unfold setRed α : Type u_1 p : α → Prop t : RBNode α h : All p t ⊢ All p (match t with \| node c a v b => node red a v b \| nil => nil) split <;> simp_all ** Qed
Std.RBNode.Ordered.setRed α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp (setRed t) ↔ Ordered cmp t unfold setRed α : Type u_1 cmp : α → α → Ordering t : RBNode α ⊢ Ordered cmp (match t with \| node c a v b => node red a v b \| nil => nil) ↔ Ordered cmp t split <;> simp [...
Std.RBNode.All.balLeft α✝ : Type u_1 p : α✝ → Prop l : RBNode α✝ v : α✝ r : RBNode α✝ hl : All p l hv : p v hr : All p r ⊢ All p (balLeft l v r) unfold balLeft ** α✝ : Type u_1 p : α✝ → Prop l : RBNode α✝ v : α✝ r : RBNode α✝ hl : All p l hv : p v hr : All p r ⊢ All p (match l with \| node red a x b => nod...
Std.RBNode.Ordered.balLeft α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode α lv : All (fun x => cmpLT cmp x v) l vr : All (fun x => cmpLT cmp v x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ Ordered cmp (balLeft l v r) unfold balLeft ** α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RB...
Std.RBNode.Balanced.balLeft α✝ : Type u_1 l : RBNode α✝ v : α✝ r : RBNode α✝ cr : RBColor n : Nat hl : RedRed True l n hr : Balanced r cr (n + 1) ⊢ RedRed (cr = red) (balLeft l v r) (n + 1) unfold balLeft ** α✝ : Type u_1 l : RBNode α✝ v : α✝ r : RBNode α✝ cr : RBColor n : Nat hl : RedRed True l n hr : Balanced r...
Std.RBNode.All.balRight α✝ : Type u_1 p : α✝ → Prop l : RBNode α✝ v : α✝ r : RBNode α✝ hl : All p l hv : p v hr : All p r ⊢ All p (balRight l v r) unfold balRight ** α✝ : Type u_1 p : α✝ → Prop l : RBNode α✝ v : α✝ r : RBNode α✝ hl : All p l hv : p v hr : All p r ⊢ All p (match r with \| node red b y c => ...
Std.RBNode.Balanced.balRight α✝ : Type u_1 l : RBNode α✝ v : α✝ r : RBNode α✝ cl : RBColor n : Nat hl : Balanced l cl (n + 1) hr : RedRed True r n ⊢ RedRed (cl = red) (balRight l v r) (n + 1) unfold balRight ** α✝ : Type u_1 l : RBNode α✝ v : α✝ r : RBNode α✝ cl : RBColor n : Nat hl : Balanced l cl (n + 1) hr : R...
Std.RBNode.Ordered.append α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode α lv : All (fun x => cmpLT cmp x v) l vr : All (fun x => cmpLT cmp v x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ Ordered cmp (append l r) unfold append ** α : Type u_1 cmp : α → α → Ordering l : RBNode α v : α r : RBNode ...
Std.RBNode.Balanced.append α : Type u_1 c₁ : RBColor n : Nat c₂ : RBColor l r : RBNode α hl : Balanced l c₁ n hr : Balanced r c₂ n ⊢ RedRed (c₁ = black → c₂ ≠ black) (append l r) n unfold append ** α : Type u_1 c₁ : RBColor n : Nat c₂ : RBColor l r : RBNode α hl : Balanced l c₁ n hr : Balanced r c₂ n ⊢ RedRed (c₁...
Std.RBNode.DelProp.redred c : RBColor α✝ : Type u_1 t : RBNode α✝ n : Nat h : DelProp c t n ⊢ ∃ n', RedRed (c = black) t n' unfold DelProp at h ** c : RBColor α✝ : Type u_1 t : RBNode α✝ n : Nat h : match c with \| black => ∃ n', n = n' + 1 ∧ RedRed True t n' \| red => ∃ c, Balanced t c n ⊢ ∃ n', RedRed (c = ...
Std.RBNode.All.del α : Type u_1 p : α → Prop cut : α → Ordering c✝ : RBColor a✝² : RBNode α a✝¹ : α a✝ : RBNode α hy : p a✝¹ ha : All p a✝² hb : All p a✝ ⊢ All p (del cut (node c✝ a✝² a✝¹ a✝)) unfold del ** α : Type u_1 p : α → Prop cut : α → Ordering c✝ : RBColor a✝² : RBNode α a✝¹ : α a✝ : RBNode α hy : p a✝¹ h...
Std.RBNode.Ordered.del α : Type u_1 cmp : α → α → Ordering cut : α → Ordering c✝ : RBColor a : RBNode α y : α b : RBNode α ay : All (fun x => cmpLT cmp x y) a yb : All (fun x => cmpLT cmp y x) b ha : Ordered cmp a hb : Ordered cmp b ⊢ Ordered cmp (del cut (node c✝ a y b)) unfold del ** α : Type u_1 cmp : α → α → ...
Std.RBNode.Balanced.del case nil α : Type u_1 c : RBColor n : Nat cut : α → Ordering t : RBNode α ⊢ DelProp (isBlack nil) (del cut nil) 0 exact ⟨_, .nil⟩ ** case black α : Type u_1 c : RBColor n✝ : Nat cut : α → Ordering t a : RBNode α c₁✝ : RBColor n : Nat b : RBNode α c₂✝ : RBColor v✝ : α ha : Balanced a c₁✝ n ...
Rat.maybeNormalize_eq num : Int den g : Nat den_nz : den / g ≠ 0 reduced : Nat.Coprime (Int.natAbs (Int.div num ↑g)) (den / g) ⊢ maybeNormalize num den g den_nz reduced = mk' (Int.div num ↑g) (den / g) unfold maybeNormalize ** num : Int den g : Nat den_nz : den / g ≠ 0 reduced : Nat.Coprime (Int.natAbs (Int.div n...
Rat.normalize_zero d : Nat nz : d ≠ 0 ⊢ normalize 0 d = 0 simp [normalize, Int.zero_div, Int.natAbs_zero, Nat.div_self (Nat.pos_of_ne_zero nz)] d : Nat nz : d ≠ 0 ⊢ mk' 0 1 = 0 rfl ** Qed
Rat.mk_eq_normalize num : Int den : Nat nz : den ≠ 0 c : Nat.Coprime (Int.natAbs num) den ⊢ mk' num den = normalize num den simp [normalize_eq, c.gcd_eq_one] ** Qed
Rat.normalize_mul_left ** d : Nat n : Int a : Nat d0 : d ≠ 0 a0 : a ≠ 0 ⊢ normalize (↑a * n) (a * d) = normalize n d ** simp [normalize_eq, mk'.injEq, Int.natAbs_mul, Nat.gcd_mul_left, Nat.mul_div_mul_left _ _ (Nat.pos_of_ne_zero a0), Int.ofNat_mul, Int.mul_ediv_mul_of_pos _ _ (Int.ofNat_pos.2 <\| Nat.pos_of_ne_zero...
Rat.normalize_mul_right ** d : Nat n : Int a : Nat d0 : d ≠ 0 a0 : a ≠ 0 ⊢ normalize (n * ↑a) (d * a) = normalize n d rw [← normalize_mul_left (d0 := d0) a0] d : Nat n : Int a : Nat d0 : d ≠ 0 a0 : a ≠ 0 ⊢ normalize (n * ↑a) (d * a) = normalize (↑a * n) (a * d) ** congr 1 <;> [apply Int.mul_comm; apply Nat.mul_co...
Rat.maybeNormalize_eq_normalize num : Int den g : Nat den_nz : den / g ≠ 0 reduced : Nat.Coprime (Int.natAbs (Int.div num ↑g)) (den / g) hn : ↑g ∣ num hd : g ∣ den ⊢ maybeNormalize num den g den_nz reduced = normalize num den simp only [maybeNormalize_eq, mk_eq_normalize, Int.div_eq_ediv_of_dvd hn] ** num : Int d...
Rat.normalize_num_den' ** num : Int den : Nat nz : den ≠ 0 ⊢ ∃ d, d ≠ 0 ∧ num = (normalize num den).num * ↑d ∧ den = (normalize num den).den * d refine ⟨num.natAbs.gcd den, Nat.gcd_ne_zero_right nz, ?_⟩ num : Int den : Nat nz : den ≠ 0 ⊢ num = (normalize num den).num * ↑(Nat.gcd (Int.natAbs num) den) ∧ den = ...
Rat.normalize_eq_mkRat num : Int den : Nat den_nz : den ≠ 0 ⊢ normalize num den = mkRat num den simp [mkRat, den_nz] ** Qed
Rat.mkRat_self a : Rat ⊢ mkRat a.num a.den = a rw [← normalize_eq_mkRat a.den_nz, normalize_self] ** Qed
Rat.mk_eq_mkRat num : Int den : Nat nz : den ≠ 0 c : Nat.Coprime (Int.natAbs num) den ⊢ mk' num den = mkRat num den simp [mk_eq_normalize, normalize_eq_mkRat] ** Qed
Rat.zero_mkRat n : Nat ⊢ mkRat 0 n = 0 simp [mkRat_def] n : Nat ⊢ (if h : n = 0 then 0 else 0) = 0 apply ite_self ** Qed
Rat.mkRat_zero n : Int ⊢ mkRat n 0 = 0 simp [mkRat_def] ** Qed
Rat.mkRat_eq_zero d : Nat n : Int d0 : d ≠ 0 ⊢ mkRat n d = 0 ↔ n = 0 simp [mkRat_def, d0] ** Qed
Rat.mkRat_mul_left ** n : Int d a : Nat a0 : a ≠ 0 ⊢ mkRat (↑a * n) (a * d) = mkRat n d if d0 : d = 0 then simp [d0] else rw [← normalize_eq_mkRat d0, ← normalize_mul_left d0 a0, normalize_eq_mkRat] n : Int d a : Nat a0 : a ≠ 0 d0 : d = 0 ⊢ mkRat (↑a * n) (a * d) = mkRat n d simp [d0] n : Int d a : Nat a0 :...
Rat.mkRat_eq_iff ** d₁ d₂ : Nat n₁ n₂ : Int z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ mkRat n₁ d₁ = mkRat n₂ d₂ ↔ n₁ * ↑d₂ = n₂ * ↑d₁ rw [← normalize_eq_mkRat z₁, ← normalize_eq_mkRat z₂, normalize_eq_iff] Qed
Rat.divInt_ofNat num : Int den : Nat ⊢ num /. ↑den = mkRat num den simp [divInt, normalize_eq_mkRat] ** Qed
Rat.divInt_self a : Rat ⊢ a.num /. ↑a.den = a rw [divInt_ofNat, mkRat_self] ** Qed
Rat.zero_divInt n : Int ⊢ 0 /. n = 0 cases n <;> simp [divInt] ** Qed
Rat.neg_divInt_neg num den : Int ⊢ -num /. -den = num /. den match den with \| Nat.succ n => simp [divInt, Int.neg_ofNat_succ, normalize_eq_mkRat, Int.neg_neg] \| 0 => rfl \| Int.negSucc n => simp [divInt, Int.neg_negSucc, normalize_eq_mkRat, Int.neg_neg] ** num den : Int n : Nat ⊢ -num /. -↑(Nat.succ n) = num /. ↑(...
Rat.divInt_neg' num den : Int ⊢ num /. -den = -num /. den rw [← neg_divInt_neg, Int.neg_neg] ** Qed
Rat.divInt_eq_iff ** d₁ d₂ n₁ n₂ : Int z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ n₁ /. d₁ = n₂ /. d₂ ↔ n₁ * d₂ = n₂ * d₁ ** rcases Int.eq_nat_or_neg d₁ with ⟨_, rfl \| rfl⟩ <;> rcases Int.eq_nat_or_neg d₂ with ⟨_, rfl \| rfl⟩ <;> simp_all [divInt_neg', Int.ofNat_eq_zero, Int.neg_eq_zero, mkRat_eq_iff, Int.neg_mul, Int.mul_neg, Int.eq_...
Rat.divInt_num_den ** d n n' : Int d' : Nat z' : d' ≠ 0 c : Nat.Coprime (Int.natAbs n') d' z : d ≠ 0 h : n /. d = mk' n' d' ⊢ ∃ m, m ≠ 0 ∧ n = n' * m ∧ d = ↑d' * m rcases Int.eq_nat_or_neg d with ⟨_, rfl \| rfl⟩ <;> simp_all [divInt_neg', Int.ofNat_eq_zero, Int.neg_eq_zero] case intro.inl n n' : Int d' : Nat z' ...
Rat.add_def ** a b : Rat ⊢ a + b = normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) show Rat.add .. = _ a b : Rat ⊢ Rat.add a b = normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) delta Rat.add a b : Rat ⊢ (let g := Nat.gcd a.den b.den; if hg : g = 1 then let_fun den_nz := (_ ...
Rat.add_def' ** a b : Rat ⊢ a + b = mkRat (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) rw [add_def, normalize_eq_mkRat] Qed
Rat.normalize_add_normalize ** n₁ n₂ : Int d₁ d₂ : Nat z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ normalize n₁ d₁ + normalize n₂ d₂ = normalize (n₁ * ↑d₂ + n₂ * ↑d₁) (d₁ * d₂) cases e₁ : normalize n₁ d₁ z₁ case mk' n₁ n₂ : Int d₁ d₂ : Nat z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 num✝ : Int den✝ : Nat den_nz✝ : den✝ ≠ 0 reduced✝ : Nat.Coprime (Int...
Rat.divInt_add_divInt ** n₁ n₂ d₁ d₂ : Int z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ n₁ /. d₁ + n₂ /. d₂ = (n₁ * d₂ + n₂ * d₁) /. (d₁ * d₂) ** rcases Int.eq_nat_or_neg d₁ with ⟨_, rfl \| rfl⟩ <;> rcases Int.eq_nat_or_neg d₂ with ⟨_, rfl \| rfl⟩ <;> simp_all [-Int.natCast_mul, Int.ofNat_eq_zero, Int.neg_eq_zero, divInt_neg', Int.mul_neg,...
Rat.neg_normalize n : Int d : Nat z : d ≠ 0 ⊢ -normalize n d = normalize (-n) d simp [normalize, maybeNormalize_eq] n : Int d : Nat z : d ≠ 0 ⊢ -mk' (Int.div n ↑(Nat.gcd (Int.natAbs n) d)) (d / Nat.gcd (Int.natAbs n) d) = mk' (-Int.div n ↑(Nat.gcd (Int.natAbs n) d)) (d / Nat.gcd (Int.natAbs n) d) ext <;...
Rat.sub_def ** a b : Rat ⊢ a - b = normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) show Rat.sub .. = _ a b : Rat ⊢ Rat.sub a b = normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) delta Rat.sub a b : Rat ⊢ (let g := Nat.gcd a.den b.den; if hg : g = 1 then let_fun den_nz := (_ ...
Rat.sub_def' ** a b : Rat ⊢ a - b = mkRat (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) rw [sub_def, normalize_eq_mkRat] Qed
Rat.sub_eq_add_neg a b : Rat ⊢ a - b = a + -b simp [add_def, sub_def, Int.neg_mul, Int.sub_eq_add_neg] ** Qed
Rat.mul_def ** a b : Rat ⊢ a * b = normalize (a.num * b.num) (a.den * b.den) show Rat.mul .. = _ a b : Rat ⊢ Rat.mul a b = normalize (a.num * b.num) (a.den * b.den) delta Rat.mul a b : Rat ⊢ (let g1 := Nat.gcd (Int.natAbs a.num) b.den; let g2 := Nat.gcd (Int.natAbs b.num) a.den; mk' (Int.div a.num ↑...
Rat.mul_comm ** a b : Rat ⊢ a * b = b * a simp [mul_def, normalize_eq_mkRat, Int.mul_comm, Nat.mul_comm] Qed
Rat.zero_mul ** a : Rat ⊢ 0 * a = 0 simp [mul_def] Qed
Rat.mul_zero ** a : Rat ⊢ a * 0 = 0 simp [mul_def] Qed
Rat.one_mul ** a : Rat ⊢ 1 * a = a simp [mul_def, normalize_self] Qed
Rat.mul_one ** a : Rat ⊢ a * 1 = a simp [mul_def, normalize_self] Qed
Rat.normalize_mul_normalize ** n₁ n₂ : Int d₁ d₂ : Nat z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ normalize n₁ d₁ * normalize n₂ d₂ = normalize (n₁ * n₂) (d₁ * d₂) cases e₁ : normalize n₁ d₁ z₁ case mk' n₁ n₂ : Int d₁ d₂ : Nat z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 num✝ : Int den✝ : Nat den_nz✝ : den✝ ≠ 0 reduced✝ : Nat.Coprime (Int.natAbs num✝...
Rat.divInt_mul_divInt ** n₁ n₂ d₁ d₂ : Int z₁ : d₁ ≠ 0 z₂ : d₂ ≠ 0 ⊢ n₁ /. d₁ * (n₂ /. d₂) = n₁ * n₂ /. (d₁ * d₂) ** rcases Int.eq_nat_or_neg d₁ with ⟨_, rfl \| rfl⟩ <;> rcases Int.eq_nat_or_neg d₂ with ⟨_, rfl \| rfl⟩ <;> simp_all [-Int.natCast_mul, divInt_neg', Int.mul_neg, Int.ofNat_mul_ofNat, Int.neg_mul, mkRat_mu...
Rat.inv_def a : Rat ⊢ Rat.inv a = ↑a.den /. a.num unfold Rat.inv a : Rat ⊢ (if h : a.num < 0 then mk' (-↑a.den) (Int.natAbs a.num) else if h : a.num > 0 then mk' (↑a.den) (Int.natAbs a.num) else a) = ↑a.den /. a.num split ** case inr a : Rat h✝ : ¬a.num < 0 ⊢ (if h : a.num > 0 then mk' (↑a.den) (Int...
Rat.inv_zero ⊢ Rat.inv 0 = 0 unfold Rat.inv ⊢ (if h : 0.num < 0 then mk' (-↑0.den) (Int.natAbs 0.num) else if h : 0.num > 0 then mk' (↑0.den) (Int.natAbs 0.num) else 0) = 0 simp ** Qed
Rat.ofScientific_true_def m e : Nat ⊢ Rat.ofScientific m true e = mkRat (↑m) (10 ^ e) unfold Rat.ofScientific ** m e : Nat ⊢ (if true = true then normalize (↑m) (10 ^ e) else ↑↑(m * 10 ^ e)) = mkRat (↑m) (10 ^ e) rw [normalize_eq_mkRat] m e : Nat ⊢ (if true = true then mkRat (↑m) (10 ^ e) else ↑↑(m * 10 ^ e...
Rat.ofScientific_false_def ** m e : Nat ⊢ Rat.ofScientific m false e = ↑↑(m * 10 ^ e) unfold Rat.ofScientific m e : Nat ⊢ (if false = true then normalize (↑m) (10 ^ e) else ↑↑(m * 10 ^ e)) = ↑↑(m * 10 ^ e) rfl Qed
Rat.ofScientific_def ** m : Nat s : Bool e : Nat ⊢ Rat.ofScientific m s e = if s = true then mkRat (↑m) (10 ^ e) else ↑↑(m * 10 ^ e) cases s case false m e : Nat ⊢ Rat.ofScientific m false e = if false = true then mkRat (↑m) (10 ^ e) else ↑↑(m * 10 ^ e) case true m e : Nat ⊢ Rat.ofScientific m true e = if true =...
Rat.intCast_add a b : Int ⊢ ↑(a + b) = ↑a + ↑b rw [add_def] ** a b : Int ⊢ ↑(a + b) = normalize ((↑a).num * ↑(↑b).den + (↑b).num * ↑(↑a).den) ((↑a).den * (↑b).den) ext <;> simp [normalize_eq] Qed
Rat.intCast_neg a : Int ⊢ ↑(-a) = -↑a ext <;> simp [normalize_eq] ** Qed
Rat.intCast_sub a b : Int ⊢ ↑(a - b) = ↑a - ↑b rw [sub_def] ** a b : Int ⊢ ↑(a - b) = normalize ((↑a).num * ↑(↑b).den - (↑b).num * ↑(↑a).den) ((↑a).den * (↑b).den) ext <;> simp [normalize_eq] Qed
Rat.intCast_mul ** a b : Int ⊢ ↑(a * b) = ↑a * ↑b rw [mul_def] a b : Int ⊢ ↑(a * b) = normalize ((↑a).num * (↑b).num) ((↑a).den * (↑b).den) ext <;> simp [normalize_eq] Qed
Nat.gcd_rec m n : Nat ⊢ gcd 0 n = gcd (n % 0) 0 have := (mod_zero n).symm m n : Nat this : n = n % 0 ⊢ gcd 0 n = gcd (n % 0) 0 rwa [gcd_zero_right] m n n✝ : Nat ⊢ gcd (n✝ + 1) n = gcd (n % (n✝ + 1)) (n✝ + 1) simp [gcd_succ] ** Qed
Nat.gcd_dvd m n : Nat ⊢ gcd m n ∣ m ∧ gcd m n ∣ n induction m, n using gcd.induction with \| H0 n => rw [gcd_zero_left]; exact ⟨Nat.dvd_zero n, Nat.dvd_refl n⟩ \| H1 m n _ IH => rw [← gcd_rec] at IH; exact ⟨IH.2, (dvd_mod_iff IH.2).1 IH.1⟩ case H0 n : Nat ⊢ gcd 0 n ∣ 0 ∧ gcd 0 n ∣ n rw [gcd_zero_left] ** case...
Nat.dvd_gcd k m n : Nat ⊢ k ∣ m → k ∣ n → k ∣ gcd m n induction m, n using gcd.induction with intro km kn \| H0 n => rw [gcd_zero_left]; exact kn \| H1 n m _ IH => rw [gcd_rec]; exact IH ((dvd_mod_iff km).2 kn) km case H0 k n : Nat km : k ∣ 0 kn : k ∣ n ⊢ k ∣ gcd 0 n rw [gcd_zero_left] ** case H0 k n : Nat km...