akjadhav/leandojo-lean4-formal-informal-strings-split

formal stringlengths 41 427k	informal stringclasses 1 value
Nat.mul_div_le ** m n : Nat ⊢ n * (m / n) ≤ m match n, Nat.eq_zero_or_pos n with \| _, Or.inl rfl => rw [Nat.zero_mul]; exact m.zero_le \| n, Or.inr h => rw [Nat.mul_comm, ← Nat.le_div_iff_mul_le h]; exact Nat.le_refl _ m n : Nat ⊢ 0 * (m / 0) ≤ m rw [Nat.zero_mul] m n : Nat ⊢ 0 ≤ m exact m.zero_le m n✝ n : Nat h : n > 0 ⊢ n * (m / n) ≤ m rw [Nat.mul_comm, ← Nat.le_div_iff_mul_le h] m n✝ n : Nat h : n > 0 ⊢ m / n ≤ m / n exact Nat.le_refl _ Qed
Nat.mod_two_eq_zero_or_one n : Nat ⊢ 2 > 0 simp ** Qed
Nat.add_mod_right x z : Nat ⊢ (x + z) % z = x % z rw [mod_eq_sub_mod (Nat.le_add_left ..), Nat.add_sub_cancel] ** Qed
Nat.add_mod_left x z : Nat ⊢ (x + z) % x = z % x rw [Nat.add_comm, add_mod_right] ** Qed
Nat.add_mul_mod_self_left ** x y z : Nat ⊢ (x + y * z) % y = x % y match z with \| 0 => rw [Nat.mul_zero, Nat.add_zero] \| succ z => rw [mul_succ, ← Nat.add_assoc, add_mod_right, add_mul_mod_self_left (z := z)] x y z : Nat ⊢ (x + y * 0) % y = x % y rw [Nat.mul_zero, Nat.add_zero] x y z✝ z : Nat ⊢ (x + y * succ z) % y = x % y rw [mul_succ, ← Nat.add_assoc, add_mod_right, add_mul_mod_self_left (z := z)] Qed
Nat.add_mul_mod_self_right ** x y z : Nat ⊢ (x + y * z) % z = x % z rw [Nat.mul_comm, add_mul_mod_self_left] Qed
Nat.mul_mod_right ** m n : Nat ⊢ m * n % m = 0 ** rw [← Nat.zero_add (m * n), add_mul_mod_self_left, zero_mod] ** Qed
Nat.mul_mod_left ** m n : Nat ⊢ m * n % n = 0 rw [Nat.mul_comm, mul_mod_right] Qed
Nat.mul_mod_mul_left ** z x y : Nat y0 : y = 0 ⊢ z * x % (z * y) = z * (x % y) rw [y0, Nat.mul_zero, mod_zero, mod_zero] z x y : Nat y0 : ¬y = 0 z0 : z = 0 ⊢ z * x % (z * y) = z * (x % y) rw [z0, Nat.zero_mul, Nat.zero_mul, Nat.zero_mul, mod_zero] z x y : Nat y0 : ¬y = 0 z0 : ¬z = 0 ⊢ z * x % (z * y) = z * (x % y) induction x using Nat.strongInductionOn with \| _ n IH => have y0 : y > 0 := Nat.pos_of_ne_zero y0 have z0 : z > 0 := Nat.pos_of_ne_zero z0 cases Nat.lt_or_ge n y with \| inl yn => rw [mod_eq_of_lt yn, mod_eq_of_lt (Nat.mul_lt_mul_of_pos_left yn z0)] \| inr yn => rw [mod_eq_sub_mod yn, mod_eq_sub_mod (Nat.mul_le_mul_left z yn), ← Nat.mul_sub_left_distrib] exact IH _ (sub_lt (Nat.lt_of_lt_of_le y0 yn) y0) case ind z y : Nat y0 : ¬y = 0 z0 : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) ⊢ z * n % (z * y) = z * (n % y) have y0 : y > 0 := Nat.pos_of_ne_zero y0 case ind z y : Nat y0✝ : ¬y = 0 z0 : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 ⊢ z * n % (z * y) = z * (n % y) have z0 : z > 0 := Nat.pos_of_ne_zero z0 case ind z y : Nat y0✝ : ¬y = 0 z0✝ : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 z0 : z > 0 ⊢ z * n % (z * y) = z * (n % y) cases Nat.lt_or_ge n y with \| inl yn => rw [mod_eq_of_lt yn, mod_eq_of_lt (Nat.mul_lt_mul_of_pos_left yn z0)] \| inr yn => rw [mod_eq_sub_mod yn, mod_eq_sub_mod (Nat.mul_le_mul_left z yn), ← Nat.mul_sub_left_distrib] exact IH _ (sub_lt (Nat.lt_of_lt_of_le y0 yn) y0) case ind.inl z y : Nat y0✝ : ¬y = 0 z0✝ : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 z0 : z > 0 yn : n < y ⊢ z * n % (z * y) = z * (n % y) rw [mod_eq_of_lt yn, mod_eq_of_lt (Nat.mul_lt_mul_of_pos_left yn z0)] case ind.inr z y : Nat y0✝ : ¬y = 0 z0✝ : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 z0 : z > 0 yn : n ≥ y ⊢ z * n % (z * y) = z * (n % y) rw [mod_eq_sub_mod yn, mod_eq_sub_mod (Nat.mul_le_mul_left z yn), ← Nat.mul_sub_left_distrib] case ind.inr z y : Nat y0✝ : ¬y = 0 z0✝ : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 z0 : z > 0 yn : n ≥ y ⊢ z * (n - y) % (z * y) = z * ((n - y) % y) exact IH _ (sub_lt (Nat.lt_of_lt_of_le y0 yn) y0) Qed
Nat.mul_mod_mul_right ** z x y : Nat ⊢ x * z % (y * z) = x % y * z rw [Nat.mul_comm x z, Nat.mul_comm y z, Nat.mul_comm (x % y) z] z x y : Nat ⊢ z * x % (z * y) = z * (x % y) apply mul_mod_mul_left Qed
Nat.sub_mul_mod ** x k n : Nat h₁ : n * k ≤ x ⊢ (x - n * k) % n = x % n ** match k with \| 0 => rw [Nat.mul_zero, Nat.sub_zero] \| succ k => have h₂ : n * k ≤ x := Nat.le_trans (le_add_right _ n) h₁ have h₄ : x - n * k ≥ n := by apply Nat.le_of_add_le_add_right (b := n * k) rw [Nat.sub_add_cancel h₂] simp [mul_succ, Nat.add_comm] at h₁; simp [h₁] rw [mul_succ, ← Nat.sub_sub, ← mod_eq_sub_mod h₄, sub_mul_mod h₂] ** x k n : Nat h₁ : n * 0 ≤ x ⊢ (x - n * 0) % n = x % n rw [Nat.mul_zero, Nat.sub_zero] x k✝ n k : Nat h₁ : n * succ k ≤ x ⊢ (x - n * succ k) % n = x % n ** have h₂ : n * k ≤ x := Nat.le_trans (le_add_right _ n) h₁ ** x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x ⊢ (x - n * succ k) % n = x % n ** have h₄ : x - n * k ≥ n := by apply Nat.le_of_add_le_add_right (b := n * k) rw [Nat.sub_add_cancel h₂] simp [mul_succ, Nat.add_comm] at h₁; simp [h₁] ** x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x h₄ : x - n * k ≥ n ⊢ (x - n * succ k) % n = x % n rw [mul_succ, ← Nat.sub_sub, ← mod_eq_sub_mod h₄, sub_mul_mod h₂] x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x ⊢ x - n * k ≥ n ** apply Nat.le_of_add_le_add_right (b := n * k) ** x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x ⊢ n + n * k ≤ x - n * k + n * k rw [Nat.sub_add_cancel h₂] x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x ⊢ n + n * k ≤ x simp [mul_succ, Nat.add_comm] at h₁ x k✝ n k : Nat h₂ : n * k ≤ x h₁ : n + n * k ≤ x ⊢ n + n * k ≤ x simp [h₁] Qed
Nat.mod_mod a n : Nat n0 : n = 0 ⊢ a % n % n = a % n simp [n0, mod_zero] ** Qed
Nat.mul_mod ** a b n : Nat ⊢ a * b % n = a % n * (b % n) % n ** conv => lhs; rw [ ← mod_add_div a n, ← mod_add_div b n, Nat.add_mul, Nat.mul_add, Nat.mul_add, Nat.mul_assoc, Nat.mul_assoc, ← Nat.mul_add n, add_mul_mod_self_left, Nat.mul_comm _ (n * (b / n)), Nat.mul_assoc, add_mul_mod_self_left] ** Qed
Nat.mod_add_mod m n k : Nat ⊢ (m % n + k) % n = (m + k) % n have := (add_mul_mod_self_left (m % n + k) n (m / n)).symm ** m n k : Nat this : (m % n + k) % n = (m % n + k + n * (m / n)) % n ⊢ (m % n + k) % n = (m + k) % n rwa [Nat.add_right_comm, mod_add_div] at this Qed
Nat.add_mod_mod m n k : Nat ⊢ (m + n % k) % k = (m + n) % k rw [Nat.add_comm, mod_add_mod, Nat.add_comm] ** Qed
Nat.add_mod a b n : Nat ⊢ (a + b) % n = (a % n + b % n) % n rw [add_mod_mod, mod_add_mod] ** Qed
Nat.pow_succ' ** m n : Nat ⊢ m ^ succ n = m * m ^ n rw [Nat.pow_succ, Nat.mul_comm] Qed
Nat.shiftLeft_eq ** a b✝ b : Nat ⊢ 2 * a * 2 ^ b = a * 2 ^ (b + 1) simp [pow_succ, Nat.mul_assoc, Nat.mul_left_comm, Nat.mul_comm] Qed
Nat.one_shiftLeft n : Nat ⊢ 1 <<< n = 2 ^ n rw [shiftLeft_eq, Nat.one_mul] ** Qed
Nat.zero_pow n : Nat H : 0 < n ⊢ 0 ^ n = 0 match n with \| 0 => contradiction \| n+1 => rw [Nat.pow_succ, Nat.mul_zero] n : Nat H : 0 < 0 ⊢ 0 ^ 0 = 0 contradiction n✝ n : Nat H : 0 < n + 1 ⊢ 0 ^ (n + 1) = 0 rw [Nat.pow_succ, Nat.mul_zero] ** Qed
Nat.one_pow n : Nat ⊢ 1 ^ n = 1 induction n with \| zero => rfl \| succ _ ih => rw [Nat.pow_succ, Nat.mul_one, ih] case zero ⊢ 1 ^ zero = 1 rfl case succ n✝ : Nat ih : 1 ^ n✝ = 1 ⊢ 1 ^ succ n✝ = 1 rw [Nat.pow_succ, Nat.mul_one, ih] ** Qed
Nat.pow_one a : Nat ⊢ a ^ 1 = a rw [Nat.pow_succ, Nat.pow_zero, Nat.one_mul] ** Qed
Nat.pow_two ** a : Nat ⊢ a ^ 2 = a * a rw [Nat.pow_succ, Nat.pow_one] Qed
Nat.pow_add ** a m n : Nat ⊢ a ^ (m + n) = a ^ m * a ^ n induction n with \| zero => rw [Nat.add_zero, Nat.pow_zero, Nat.mul_one] \| succ _ ih => rw [Nat.add_succ, Nat.pow_succ, Nat.pow_succ, ih, Nat.mul_assoc] case zero a m : Nat ⊢ a ^ (m + zero) = a ^ m * a ^ zero rw [Nat.add_zero, Nat.pow_zero, Nat.mul_one] case succ a m n✝ : Nat ih : a ^ (m + n✝) = a ^ m * a ^ n✝ ⊢ a ^ (m + succ n✝) = a ^ m * a ^ succ n✝ rw [Nat.add_succ, Nat.pow_succ, Nat.pow_succ, ih, Nat.mul_assoc] Qed
Nat.pow_add' ** a m n : Nat ⊢ a ^ (m + n) = a ^ n * a ^ m rw [←Nat.pow_add, Nat.add_comm] Qed
Nat.pow_mul ** a m n : Nat ⊢ a ^ (m * n) = (a ^ m) ^ n induction n with \| zero => rw [Nat.mul_zero, Nat.pow_zero, Nat.pow_zero] \| succ _ ih => rw [Nat.mul_succ, Nat.pow_add, Nat.pow_succ, ih] case zero a m : Nat ⊢ a ^ (m * zero) = (a ^ m) ^ zero rw [Nat.mul_zero, Nat.pow_zero, Nat.pow_zero] case succ a m n✝ : Nat ih : a ^ (m * n✝) = (a ^ m) ^ n✝ ⊢ a ^ (m * succ n✝) = (a ^ m) ^ succ n✝ rw [Nat.mul_succ, Nat.pow_add, Nat.pow_succ, ih] Qed
Nat.pow_mul' ** a m n : Nat ⊢ a ^ (m * n) = (a ^ n) ^ m rw [←Nat.pow_mul, Nat.mul_comm] Qed
Nat.log2_lt n k : Nat h : n ≠ 0 ⊢ log2 n < k ↔ n < 2 ^ k rw [← Nat.not_le, ← Nat.not_le, le_log2 h] ** Qed
Nat.dvd_refl ** a : Nat ⊢ a = a * 1 simp Qed
Nat.dvd_zero ** a : Nat ⊢ 0 = a * 0 simp Qed
Nat.dvd_trans ** a b c : Nat h₁ : a ∣ b h₂ : b ∣ c d : Nat h₃ : b = a * d e : Nat h₄ : c = b * e ⊢ c = a * (d * e) simp[h₃,h₄, Nat.mul_assoc] Qed
Nat.dvd_add ** a b c : Nat h₁ : a ∣ b h₂ : a ∣ c d : Nat hd : b = a * d e : Nat he : c = a * e ⊢ b + c = a * (d + e) simp [Nat.left_distrib, hd, he] Qed
Nat.dvd_add_iff_left k m n : Nat h : k ∣ n ⊢ k ∣ m ↔ k ∣ m + n rw [Nat.add_comm] k m n : Nat h : k ∣ n ⊢ k ∣ m ↔ k ∣ n + m exact Nat.dvd_add_iff_right h ** Qed
Nat.dvd_sub k m n : Nat H : n ≤ m h₁ : k ∣ m h₂ : k ∣ n ⊢ k ∣ m - n + n rwa [Nat.sub_add_cancel H] ** Qed
Nat.mul_dvd_mul ** a b c d e : Nat he : b = a * e f : Nat hf : d = c * f ⊢ b * d = a * c * (e * f) simp [he, hf, Nat.mul_assoc, Nat.mul_left_comm, Nat.mul_comm] Qed
Nat.dvd_mod_iff ** k m n : Nat h : k ∣ n this : k ∣ ?m.55641 h ↔ k ∣ ?m.55641 h + n * (m / n) ⊢ k ∣ m % n ↔ k ∣ m rwa [mod_add_div] at this Qed
Nat.le_of_dvd ** m n : Nat h : 0 < n k : Nat e : n = m * k ⊢ m ≤ n revert h m n k : Nat e : n = m * k ⊢ 0 < n → m ≤ n rw [e] m n k : Nat e : n = m * k ⊢ 0 < m * k → m ≤ m * k match k with \| 0 => intro hn; simp at hn \| pk+1 => intro have := Nat.mul_le_mul_left m (succ_pos pk) rwa [Nat.mul_one] at this m n k : Nat e : n = m * 0 ⊢ 0 < m * 0 → m ≤ m * 0 intro hn m n k : Nat e : n = m * 0 hn : 0 < m * 0 ⊢ m ≤ m * 0 simp at hn m n k pk : Nat e : n = m * (pk + 1) ⊢ 0 < m * (pk + 1) → m ≤ m * (pk + 1) intro m n k pk : Nat e : n = m * (pk + 1) h✝ : 0 < m * (pk + 1) ⊢ m ≤ m * (pk + 1) have := Nat.mul_le_mul_left m (succ_pos pk) m n k pk : Nat e : n = m * (pk + 1) h✝ : 0 < m * (pk + 1) this : m * succ 0 ≤ m * succ pk ⊢ m ≤ m * (pk + 1) rwa [Nat.mul_one] at this Qed
Nat.eq_one_of_dvd_one n : Nat H : n ∣ 1 ⊢ 0 < 1 decide ** Qed
Nat.dvd_of_mod_eq_zero m n : Nat H : n % m = 0 ⊢ m ∣ n exists n / m ** m n : Nat H : n % m = 0 ⊢ n = m * (n / m) have := (mod_add_div n m).symm m n : Nat H : n % m = 0 this : n = n % m + m * (n / m) ⊢ n = m * (n / m) rwa [H, Nat.zero_add] at this Qed
Nat.mod_eq_zero_of_dvd m n : Nat H : m ∣ n ⊢ n % m = 0 let ⟨z, H⟩ := H ** m n : Nat H✝ : m ∣ n z : Nat H : n = m * z ⊢ n % m = 0 rw [H, mul_mod_right] Qed
Nat.mul_div_cancel' ** n m : Nat H : n ∣ m ⊢ n * (m / n) = m have := mod_add_div m n n m : Nat H : n ∣ m this : m % n + n * (m / n) = m ⊢ n * (m / n) = m rwa [mod_eq_zero_of_dvd H, Nat.zero_add] at this Qed
Nat.div_mul_cancel ** n m : Nat H : n ∣ m ⊢ m / n * n = m rw [Nat.mul_comm, Nat.mul_div_cancel' H] Qed
Nat.mul_div_assoc ** k n m : Nat H : k ∣ n ⊢ m * n / k = m * (n / k) ** match Nat.eq_zero_or_pos k with \| .inl h0 => rw [h0, Nat.div_zero, Nat.div_zero, Nat.mul_zero] \| .inr hpos => have h1 : m * n / k = m * (n / k * k) / k := by rw [Nat.div_mul_cancel H] rw [h1, ← Nat.mul_assoc, Nat.mul_div_cancel _ hpos] ** k n m : Nat H : k ∣ n h0 : k = 0 ⊢ m * n / k = m * (n / k) rw [h0, Nat.div_zero, Nat.div_zero, Nat.mul_zero] k n m : Nat H : k ∣ n hpos : k > 0 ⊢ m * n / k = m * (n / k) ** have h1 : m * n / k = m * (n / k * k) / k := by rw [Nat.div_mul_cancel H] ** k n m : Nat H : k ∣ n hpos : k > 0 h1 : m * n / k = m * (n / k * k) / k ⊢ m * n / k = m * (n / k) rw [h1, ← Nat.mul_assoc, Nat.mul_div_cancel _ hpos] k n m : Nat H : k ∣ n hpos : k > 0 ⊢ m * n / k = m * (n / k * k) / k rw [Nat.div_mul_cancel H] Qed
Nat.dvd_of_mul_dvd_mul_left ** k m n : Nat kpos : 0 < k H : k * m ∣ k * n ⊢ m ∣ n let ⟨l, H⟩ := H k m n : Nat kpos : 0 < k H✝ : k * m ∣ k * n l : Nat H : k * n = k * m * l ⊢ m ∣ n rw [Nat.mul_assoc] at H k m n : Nat kpos : 0 < k H✝ : k * m ∣ k * n l : Nat H : k * n = k * (m * l) ⊢ m ∣ n exact ⟨_, Nat.eq_of_mul_eq_mul_left kpos H⟩ Qed
Nat.dvd_of_mul_dvd_mul_right ** k m n : Nat kpos : 0 < k H : m * k ∣ n * k ⊢ m ∣ n rw [Nat.mul_comm m k, Nat.mul_comm n k] at H k m n : Nat kpos : 0 < k H : k * m ∣ k * n ⊢ m ∣ n exact Nat.dvd_of_mul_dvd_mul_left kpos H Qed
Nat.sum_append l₁ l₂ : List Nat ⊢ Nat.sum (l₁ ++ l₂) = Nat.sum l₁ + Nat.sum l₂ induction l₁ <;> simp [, Nat.add_assoc] * Qed
Nat.zero_shiftRight ⊢ 0 >>> 0 = 0 simp [shiftRight] n : Nat ⊢ 0 >>> (n + 1) = 0 simp [shiftRight, zero_shiftRight] ** Qed
Nat.shiftRight_add m n k : Nat ⊢ m >>> (n + (k + 1)) = m >>> n >>> (k + 1) simp [add_succ, shiftRight_add] ** Qed
Nat.shiftRight_eq_div_pow m k : Nat ⊢ m >>> (k + 1) = m / 2 ^ (k + 1) rw [shiftRight_add, shiftRight_eq_div_pow m k] m k : Nat ⊢ (m / 2 ^ k) >>> 1 = m / 2 ^ (k + 1) simp [Nat.div_div_eq_div_mul, ← Nat.pow_succ] ** Qed
List.append_inj α : Type u_1 a : α s₁ : List α b : α s₂ t₁ t₂ : List α h : a :: s₁ ++ t₁ = b :: s₂ ++ t₂ hl : length (a :: s₁) = length (b :: s₂) ⊢ a :: s₁ = b :: s₂ ∧ t₁ = t₂ simp [append_inj (cons.inj h).2 (Nat.succ.inj hl)] at h ⊢ α : Type u_1 a : α s₁ : List α b : α s₂ t₁ t₂ : List α hl : length (a :: s₁) = length (b :: s₂) h : a = b ⊢ a = b exact h ** Qed
List.append_inj' α✝ : Type u_1 s₁ t₁ s₂ t₂ : List α✝ h : s₁ ++ t₁ = s₂ ++ t₂ hl : length t₁ = length t₂ ⊢ length s₁ + length t₁ = length s₂ + length t₁ let hap := congrArg length h α✝ : Type u_1 s₁ t₁ s₂ t₂ : List α✝ h : s₁ ++ t₁ = s₂ ++ t₂ hl : length t₁ = length t₂ hap : length (s₁ ++ t₁) = length (s₂ ++ t₂) := congrArg length h ⊢ length s₁ + length t₁ = length s₂ + length t₁ simp only [length_append, ← hl] at hap α✝ : Type u_1 s₁ t₁ s₂ t₂ : List α✝ h : s₁ ++ t₁ = s₂ ++ t₂ hl : length t₁ = length t₂ hap : length s₁ + length t₁ = length s₂ + length t₁ ⊢ length s₁ + length t₁ = length s₂ + length t₁ exact hap ** Qed
List.map_append α : Type u_1 β : Type u_2 f : α → β ⊢ ∀ (l₁ l₂ : List α), map f (l₁ ++ l₂) = map f l₁ ++ map f l₂ intro l₁ α : Type u_1 β : Type u_2 f : α → β l₁ : List α ⊢ ∀ (l₂ : List α), map f (l₁ ++ l₂) = map f l₁ ++ map f l₂ induction l₁ <;> intros <;> simp_all ** Qed
List.map_id α : Type u_1 l : List α ⊢ map id l = l induction l <;> simp_all ** Qed
List.map_map β : Type u_1 γ : Type u_2 α : Type u_3 g : β → γ f : α → β l : List α ⊢ map g (map f l) = map (g ∘ f) l induction l <;> simp_all ** Qed
List.nil_bind α : Type u_1 β : Type u_2 f : α → List β ⊢ List.bind [] f = [] simp [join, List.bind] ** Qed
List.cons_bind α : Type u_1 β : Type u_2 x : α xs : List α f : α → List β ⊢ List.bind (x :: xs) f = f x ++ List.bind xs f simp [join, List.bind] ** Qed
List.append_bind α : Type u_1 β : Type u_2 xs ys : List α f : α → List β ⊢ List.bind (xs ++ ys) f = List.bind xs f ++ List.bind ys f induction xs case nil α : Type u_1 β : Type u_2 ys : List α f : α → List β ⊢ List.bind ([] ++ ys) f = List.bind [] f ++ List.bind ys f case cons α : Type u_1 β : Type u_2 ys : List α f : α → List β head✝ : α tail✝ : List α tail_ih✝ : List.bind (tail✝ ++ ys) f = List.bind tail✝ f ++ List.bind ys f ⊢ List.bind (head✝ :: tail✝ ++ ys) f = List.bind (head✝ :: tail✝) f ++ List.bind ys f {rfl} case cons α : Type u_1 β : Type u_2 ys : List α f : α → List β head✝ : α tail✝ : List α tail_ih✝ : List.bind (tail✝ ++ ys) f = List.bind tail✝ f ++ List.bind ys f ⊢ List.bind (head✝ :: tail✝ ++ ys) f = List.bind (head✝ :: tail✝) f ++ List.bind ys f simp_all [cons_bind, append_assoc] ** Qed
List.bind_id α : Type u_1 l : List (List α) ⊢ List.bind l id = join l simp [List.bind] ** Qed
List.reverse_map α : Type u_1 β : Type u_2 f : α → β l : List α ⊢ reverse (map f l) = map f (reverse l) induction l <;> simp [] * Qed
List.take_length_le α : Type u_1 i : Nat l : List α h : length l ≤ i ⊢ take i l = l have := take_append_drop i l α : Type u_1 i : Nat l : List α h : length l ≤ i this : take i l ++ drop i l = l ⊢ take i l = l rw [drop_length_le h, append_nil] at this α : Type u_1 i : Nat l : List α h : length l ≤ i this : take i l = l ⊢ take i l = l exact this ** Qed
List.take_nil α : Type u_1 i : Nat ⊢ take i [] = [] cases i <;> rfl ** Qed
List.take_concat_get α : Type u_1 l : List α i : Nat h : i < length l ⊢ l = concat (take i l) l[i] ++ drop (i + 1) l rw [concat_eq_append, append_assoc, singleton_append, get_drop_eq_drop, take_append_drop] ** Qed
List.reverse_concat α : Type u_1 l : List α a : α ⊢ reverse (concat l a) = a :: reverse l rw [concat_eq_append, reverse_append] α : Type u_1 l : List α a : α ⊢ reverse [a] ++ reverse l = a :: reverse l rfl ** Qed
List.foldlM_cons m : Type u_1 → Type u_2 β : Type u_1 α : Type u_3 inst✝ : Monad m f : β → α → m β b : β a : α l : List α ⊢ List.foldlM f b (a :: l) = do let init ← f b a List.foldlM f init l simp [List.foldlM] ** Qed
List.foldlM_append m : Type u_1 → Type u_2 β : Type u_1 α : Type u_3 inst✝¹ : Monad m inst✝ : LawfulMonad m f : β → α → m β b : β l l' : List α ⊢ List.foldlM f b (l ++ l') = do let init ← List.foldlM f b l List.foldlM f init l' induction l generalizing b <;> simp [] * Qed
List.foldrM_cons m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m a : α l : List α f : α → β → m β b : β ⊢ foldrM f b (a :: l) = foldrM f b l >>= f a simp only [foldrM] m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m a : α l : List α f : α → β → m β b : β ⊢ List.foldlM (fun s a => f a s) b (reverse (a :: l)) = List.foldlM (fun s a => f a s) b (reverse l) >>= f a induction l <;> simp_all ** Qed
List.foldrM_reverse m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝ : Monad m l : List α f : α → β → m β b : β ⊢ List.foldlM (fun y x => f x y) b (reverse (reverse l)) = List.foldlM (fun x y => f y x) b l simp ** Qed
List.foldl_eq_foldlM β : Type u_1 α : Type u_2 f : β → α → β b : β l : List α ⊢ foldl f b l = List.foldlM f b l induction l generalizing b <;> simp [, foldl] * Qed
List.foldr_eq_foldrM α : Type u_1 β : Type u_2 f : α → β → β b : β l : List α ⊢ foldr f b l = foldrM f b l induction l <;> simp [, foldr] * Qed
List.foldl_reverse α : Type u_1 β : Type u_2 l : List α f : β → α → β b : β ⊢ foldl f b (reverse l) = foldr (fun x y => f y x) b l simp [foldl_eq_foldlM, foldr_eq_foldrM] ** Qed
List.foldr_reverse α : Type u_1 β : Type u_2 l : List α f : α → β → β b : β ⊢ foldl (fun y x => f x y) b (reverse (reverse l)) = foldl (fun x y => f y x) b l simp ** Qed
List.foldrM_append m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → β → m β b : β l l' : List α ⊢ foldrM f b (l ++ l') = do let init ← foldrM f b l' foldrM f init l induction l <;> simp [] * Qed
List.foldl_append α : Type u_1 β : Type u_2 f : β → α → β b : β l l' : List α ⊢ foldl f b (l ++ l') = foldl f (foldl f b l) l' simp [foldl_eq_foldlM] ** Qed
List.foldr_append α : Type u_1 β : Type u_2 f : α → β → β b : β l l' : List α ⊢ foldr f b (l ++ l') = foldr f (foldr f b l') l simp [foldr_eq_foldrM] ** Qed
List.foldr_self_append α : Type u_1 l' l : List α ⊢ foldr cons l' l = l ++ l' induction l <;> simp [] * Qed
List.foldr_self α : Type u_1 l : List α ⊢ foldr cons [] l = l simp ** Qed
List.mapM'_eq_mapM m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β l : List α ⊢ mapM' f l = mapM f l simp [go, mapM] m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β l : List α acc : List β ⊢ mapM.loop f [] acc = do let __do_lift ← mapM' f [] pure (reverse acc ++ __do_lift) simp [mapM.loop, mapM'] m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β l✝ : List α a : α l : List α acc : List β ⊢ mapM.loop f (a :: l) acc = do let __do_lift ← mapM' f (a :: l) pure (reverse acc ++ __do_lift) simp [go l, mapM.loop, mapM'] ** Qed
List.mapM_append m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β l₁ l₂ : List α ⊢ mapM f (l₁ ++ l₂) = do let __do_lift ← mapM f l₁ let __do_lift_1 ← mapM f l₂ pure (__do_lift ++ __do_lift_1) induction l₁ <;> simp [] * Qed
List.zipWith_nil_left α : Type u_1 β : Type u_2 γ : Type u_3 l : List β f : α → β → γ ⊢ zipWith f [] l = [] rfl ** Qed
List.zipWith_nil_right α : Type u_1 β : Type u_2 γ : Type u_3 l : List α f : α → β → γ ⊢ zipWith f l [] = [] simp [zipWith] ** Qed
List.zipWith_cons_cons α : Type u_1 β : Type u_2 γ : Type u_3 a : α as : List α b : β bs : List β f : α → β → γ ⊢ zipWith f (a :: as) (b :: bs) = f a b :: zipWith f as bs rfl ** Qed
List.zip_nil_left α : Type u_1 β : Type u_2 l : List β ⊢ zip [] l = [] rfl ** Qed
List.zip_nil_right α : Type u_1 l : List α β : Type u_2 ⊢ zip l [] = [] simp [zip] ** Qed
List.zip_cons_cons α✝¹ : Type u_1 a : α✝¹ as : List α✝¹ α✝ : Type u_2 b : α✝ bs : List α✝ ⊢ zip (a :: as) (b :: bs) = (a, b) :: zip as bs rfl ** Qed
List.isPrefixOf_nil_left α : Type u_1 l : List α inst✝ : BEq α ⊢ isPrefixOf [] l = true simp [isPrefixOf] ** Qed
Sum.forall_sum α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop ⊢ (∀ (fab : (ab : α ⊕ β) → γ ab), p fab) ↔ ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t refine ⟨fun h fa fb => h _, fun h fab => ?_⟩ α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab ⊢ p fab have h1 : fab = Sum.rec (fun a => fab (Sum.inl a)) (fun b => fab (Sum.inr b)) := by ext ab; cases ab <;> rfl α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab h1 : fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t ⊢ p fab rw [h1] α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab h1 : fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t ⊢ p fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t exact h _ _ α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab ⊢ fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t ext ab case h α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab ab : α ⊕ β ⊢ fab ab = rec (fun a => fab (inl a)) (fun b => fab (inr b)) ab cases ab <;> rfl ** Qed
Sum.getLeft?_eq_none_iff α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ getLeft? x = none ↔ isRight x = true cases x <;> simp only [getLeft?, isRight, eq_self_iff_true] ** Qed
Sum.getRight?_eq_none_iff α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ getRight? x = none ↔ isLeft x = true cases x <;> simp only [getRight?, isLeft, eq_self_iff_true] ** Qed
Sum.getLeft_eq_iff α✝ : Type u_1 a : α✝ β✝ : Type u_2 x : α✝ ⊕ β✝ h : isLeft x = true ⊢ getLeft x h = a ↔ x = inl a cases x <;> simp at h ⊢ ** Qed
Sum.getRight_eq_iff β✝ : Type u_1 b : β✝ α✝ : Type u_2 x : α✝ ⊕ β✝ h : isRight x = true ⊢ getRight x h = b ↔ x = inr b cases x <;> simp at h ⊢ ** Qed
Sum.getLeft?_eq_some_iff α✝ : Type u_1 a : α✝ β✝ : Type u_2 x : α✝ ⊕ β✝ ⊢ getLeft? x = some a ↔ x = inl a cases x <;> simp only [getLeft?, Option.some.injEq, inl.injEq] ** Qed
Sum.getRight?_eq_some_iff β✝ : Type u_1 b : β✝ α✝ : Type u_2 x : α✝ ⊕ β✝ ⊢ getRight? x = some b ↔ x = inr b cases x <;> simp only [getRight?, Option.some.injEq, inr.injEq] ** Qed
Sum.bnot_isLeft α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ (!decide (isLeft x = isRight x)) = true cases x <;> rfl ** Qed
Sum.isLeft_eq_false α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ isLeft x = false ↔ isRight x = true cases x <;> simp ** Qed
Sum.not_isLeft α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ ¬isLeft x = true ↔ isRight x = true simp ** Qed
Sum.bnot_isRight α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ (!decide (isRight x = isLeft x)) = true cases x <;> rfl ** Qed
Sum.isRight_eq_false α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ isRight x = false ↔ isLeft x = true cases x <;> simp ** Qed
Sum.not_isRight α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ ¬isRight x = true ↔ isLeft x = true simp ** Qed
Sum.isLeft_iff α✝ : Type u_1 β✝ : Type u_2 x : α✝ ⊕ β✝ ⊢ isLeft x = true ↔ ∃ y, x = inl y cases x <;> simp ** Qed
Sum.isRight_iff α✝ : Type u_1 β✝ : Type u_2 x : α✝ ⊕ β✝ ⊢ isRight x = true ↔ ∃ y, x = inr y cases x <;> simp ** Qed

Nat.mul_div_le ** m n : Nat ⊢ n * (m / n) ≤ m ** match n, Nat.eq_zero_or_pos n with | _, Or.inl rfl => rw [Nat.zero_mul]; exact m.zero_le | n, Or.inr h => rw [Nat.mul_comm, ← Nat.le_div_iff_mul_le h]; exact Nat.le_refl _ ** m n : Nat ⊢ 0 * (m / 0) ≤ m ** rw [Nat.zero_mul] ** m n : Nat ⊢ 0 ≤ m ** exact m.zero_le ** m n✝ n : Nat h : n > 0 ⊢ n * (m / n) ≤ m ** rw [Nat.mul_comm, ← Nat.le_div_iff_mul_le h] ** m n✝ n : Nat h : n > 0 ⊢ m / n ≤ m / n ** exact Nat.le_refl _ ** Qed

Nat.mod_two_eq_zero_or_one ** n : Nat ⊢ 2 > 0 ** simp ** Qed

Nat.add_mod_right ** x z : Nat ⊢ (x + z) % z = x % z ** rw [mod_eq_sub_mod (Nat.le_add_left ..), Nat.add_sub_cancel] ** Qed

Nat.add_mod_left ** x z : Nat ⊢ (x + z) % x = z % x ** rw [Nat.add_comm, add_mod_right] ** Qed

Nat.add_mul_mod_self_left ** x y z : Nat ⊢ (x + y * z) % y = x % y ** match z with | 0 => rw [Nat.mul_zero, Nat.add_zero] | succ z => rw [mul_succ, ← Nat.add_assoc, add_mod_right, add_mul_mod_self_left (z := z)] ** x y z : Nat ⊢ (x + y * 0) % y = x % y ** rw [Nat.mul_zero, Nat.add_zero] ** x y z✝ z : Nat ⊢ (x + y * succ z) % y = x % y ** rw [mul_succ, ← Nat.add_assoc, add_mod_right, add_mul_mod_self_left (z := z)] ** Qed

Nat.add_mul_mod_self_right ** x y z : Nat ⊢ (x + y * z) % z = x % z ** rw [Nat.mul_comm, add_mul_mod_self_left] ** Qed

Nat.mul_mod_right ** m n : Nat ⊢ m * n % m = 0 ** rw [← Nat.zero_add (m * n), add_mul_mod_self_left, zero_mod] ** Qed

Nat.mul_mod_left ** m n : Nat ⊢ m * n % n = 0 ** rw [Nat.mul_comm, mul_mod_right] ** Qed

Nat.mul_mod_mul_left ** z x y : Nat y0 : y = 0 ⊢ z * x % (z * y) = z * (x % y) ** rw [y0, Nat.mul_zero, mod_zero, mod_zero] ** z x y : Nat y0 : ¬y = 0 z0 : z = 0 ⊢ z * x % (z * y) = z * (x % y) ** rw [z0, Nat.zero_mul, Nat.zero_mul, Nat.zero_mul, mod_zero] ** z x y : Nat y0 : ¬y = 0 z0 : ¬z = 0 ⊢ z * x % (z * y) = z * (x % y) ** induction x using Nat.strongInductionOn with | _ n IH => have y0 : y > 0 := Nat.pos_of_ne_zero y0 have z0 : z > 0 := Nat.pos_of_ne_zero z0 cases Nat.lt_or_ge n y with | inl yn => rw [mod_eq_of_lt yn, mod_eq_of_lt (Nat.mul_lt_mul_of_pos_left yn z0)] | inr yn => rw [mod_eq_sub_mod yn, mod_eq_sub_mod (Nat.mul_le_mul_left z yn), ← Nat.mul_sub_left_distrib] exact IH _ (sub_lt (Nat.lt_of_lt_of_le y0 yn) y0) ** case ind z y : Nat y0 : ¬y = 0 z0 : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) ⊢ z * n % (z * y) = z * (n % y) ** have y0 : y > 0 := Nat.pos_of_ne_zero y0 ** case ind z y : Nat y0✝ : ¬y = 0 z0 : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 ⊢ z * n % (z * y) = z * (n % y) ** have z0 : z > 0 := Nat.pos_of_ne_zero z0 ** case ind z y : Nat y0✝ : ¬y = 0 z0✝ : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 z0 : z > 0 ⊢ z * n % (z * y) = z * (n % y) ** cases Nat.lt_or_ge n y with | inl yn => rw [mod_eq_of_lt yn, mod_eq_of_lt (Nat.mul_lt_mul_of_pos_left yn z0)] | inr yn => rw [mod_eq_sub_mod yn, mod_eq_sub_mod (Nat.mul_le_mul_left z yn), ← Nat.mul_sub_left_distrib] exact IH _ (sub_lt (Nat.lt_of_lt_of_le y0 yn) y0) ** case ind.inl z y : Nat y0✝ : ¬y = 0 z0✝ : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 z0 : z > 0 yn : n < y ⊢ z * n % (z * y) = z * (n % y) ** rw [mod_eq_of_lt yn, mod_eq_of_lt (Nat.mul_lt_mul_of_pos_left yn z0)] ** case ind.inr z y : Nat y0✝ : ¬y = 0 z0✝ : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 z0 : z > 0 yn : n ≥ y ⊢ z * n % (z * y) = z * (n % y) ** rw [mod_eq_sub_mod yn, mod_eq_sub_mod (Nat.mul_le_mul_left z yn), ← Nat.mul_sub_left_distrib] ** case ind.inr z y : Nat y0✝ : ¬y = 0 z0✝ : ¬z = 0 n : Nat IH : ∀ (m : Nat), m < n → z * m % (z * y) = z * (m % y) y0 : y > 0 z0 : z > 0 yn : n ≥ y ⊢ z * (n - y) % (z * y) = z * ((n - y) % y) ** exact IH _ (sub_lt (Nat.lt_of_lt_of_le y0 yn) y0) ** Qed

Nat.mul_mod_mul_right ** z x y : Nat ⊢ x * z % (y * z) = x % y * z ** rw [Nat.mul_comm x z, Nat.mul_comm y z, Nat.mul_comm (x % y) z] ** z x y : Nat ⊢ z * x % (z * y) = z * (x % y) ** apply mul_mod_mul_left ** Qed

Nat.sub_mul_mod ** x k n : Nat h₁ : n * k ≤ x ⊢ (x - n * k) % n = x % n ** match k with | 0 => rw [Nat.mul_zero, Nat.sub_zero] | succ k => have h₂ : n * k ≤ x := Nat.le_trans (le_add_right _ n) h₁ have h₄ : x - n * k ≥ n := by apply Nat.le_of_add_le_add_right (b := n * k) rw [Nat.sub_add_cancel h₂] simp [mul_succ, Nat.add_comm] at h₁; simp [h₁] rw [mul_succ, ← Nat.sub_sub, ← mod_eq_sub_mod h₄, sub_mul_mod h₂] ** x k n : Nat h₁ : n * 0 ≤ x ⊢ (x - n * 0) % n = x % n ** rw [Nat.mul_zero, Nat.sub_zero] ** x k✝ n k : Nat h₁ : n * succ k ≤ x ⊢ (x - n * succ k) % n = x % n ** have h₂ : n * k ≤ x := Nat.le_trans (le_add_right _ n) h₁ ** x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x ⊢ (x - n * succ k) % n = x % n ** have h₄ : x - n * k ≥ n := by apply Nat.le_of_add_le_add_right (b := n * k) rw [Nat.sub_add_cancel h₂] simp [mul_succ, Nat.add_comm] at h₁; simp [h₁] ** x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x h₄ : x - n * k ≥ n ⊢ (x - n * succ k) % n = x % n ** rw [mul_succ, ← Nat.sub_sub, ← mod_eq_sub_mod h₄, sub_mul_mod h₂] ** x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x ⊢ x - n * k ≥ n ** apply Nat.le_of_add_le_add_right (b := n * k) ** x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x ⊢ n + n * k ≤ x - n * k + n * k ** rw [Nat.sub_add_cancel h₂] ** x k✝ n k : Nat h₁ : n * succ k ≤ x h₂ : n * k ≤ x ⊢ n + n * k ≤ x ** simp [mul_succ, Nat.add_comm] at h₁ ** x k✝ n k : Nat h₂ : n * k ≤ x h₁ : n + n * k ≤ x ⊢ n + n * k ≤ x ** simp [h₁] ** Qed

Nat.mod_mod ** a n : Nat n0 : n = 0 ⊢ a % n % n = a % n ** simp [n0, mod_zero] ** Qed

Nat.mul_mod ** a b n : Nat ⊢ a * b % n = a % n * (b % n) % n ** conv => lhs; rw [ ← mod_add_div a n, ← mod_add_div b n, Nat.add_mul, Nat.mul_add, Nat.mul_add, Nat.mul_assoc, Nat.mul_assoc, ← Nat.mul_add n, add_mul_mod_self_left, Nat.mul_comm _ (n * (b / n)), Nat.mul_assoc, add_mul_mod_self_left] ** Qed

Nat.mod_add_mod ** m n k : Nat ⊢ (m % n + k) % n = (m + k) % n ** have := (add_mul_mod_self_left (m % n + k) n (m / n)).symm ** m n k : Nat this : (m % n + k) % n = (m % n + k + n * (m / n)) % n ⊢ (m % n + k) % n = (m + k) % n ** rwa [Nat.add_right_comm, mod_add_div] at this ** Qed

Nat.add_mod_mod ** m n k : Nat ⊢ (m + n % k) % k = (m + n) % k ** rw [Nat.add_comm, mod_add_mod, Nat.add_comm] ** Qed

Nat.add_mod ** a b n : Nat ⊢ (a + b) % n = (a % n + b % n) % n ** rw [add_mod_mod, mod_add_mod] ** Qed

Nat.pow_succ' ** m n : Nat ⊢ m ^ succ n = m * m ^ n ** rw [Nat.pow_succ, Nat.mul_comm] ** Qed

Nat.shiftLeft_eq ** a b✝ b : Nat ⊢ 2 * a * 2 ^ b = a * 2 ^ (b + 1) ** simp [pow_succ, Nat.mul_assoc, Nat.mul_left_comm, Nat.mul_comm] ** Qed

Nat.one_shiftLeft ** n : Nat ⊢ 1 <<< n = 2 ^ n ** rw [shiftLeft_eq, Nat.one_mul] ** Qed

Nat.zero_pow ** n : Nat H : 0 < n ⊢ 0 ^ n = 0 ** match n with | 0 => contradiction | n+1 => rw [Nat.pow_succ, Nat.mul_zero] ** n : Nat H : 0 < 0 ⊢ 0 ^ 0 = 0 ** contradiction ** n✝ n : Nat H : 0 < n + 1 ⊢ 0 ^ (n + 1) = 0 ** rw [Nat.pow_succ, Nat.mul_zero] ** Qed

Nat.one_pow ** n : Nat ⊢ 1 ^ n = 1 ** induction n with | zero => rfl | succ _ ih => rw [Nat.pow_succ, Nat.mul_one, ih] ** case zero ⊢ 1 ^ zero = 1 ** rfl ** case succ n✝ : Nat ih : 1 ^ n✝ = 1 ⊢ 1 ^ succ n✝ = 1 ** rw [Nat.pow_succ, Nat.mul_one, ih] ** Qed

Nat.pow_one ** a : Nat ⊢ a ^ 1 = a ** rw [Nat.pow_succ, Nat.pow_zero, Nat.one_mul] ** Qed

Nat.pow_two ** a : Nat ⊢ a ^ 2 = a * a ** rw [Nat.pow_succ, Nat.pow_one] ** Qed

Nat.pow_add ** a m n : Nat ⊢ a ^ (m + n) = a ^ m * a ^ n ** induction n with | zero => rw [Nat.add_zero, Nat.pow_zero, Nat.mul_one] | succ _ ih => rw [Nat.add_succ, Nat.pow_succ, Nat.pow_succ, ih, Nat.mul_assoc] ** case zero a m : Nat ⊢ a ^ (m + zero) = a ^ m * a ^ zero ** rw [Nat.add_zero, Nat.pow_zero, Nat.mul_one] ** case succ a m n✝ : Nat ih : a ^ (m + n✝) = a ^ m * a ^ n✝ ⊢ a ^ (m + succ n✝) = a ^ m * a ^ succ n✝ ** rw [Nat.add_succ, Nat.pow_succ, Nat.pow_succ, ih, Nat.mul_assoc] ** Qed

Nat.pow_add' ** a m n : Nat ⊢ a ^ (m + n) = a ^ n * a ^ m ** rw [←Nat.pow_add, Nat.add_comm] ** Qed

Nat.pow_mul ** a m n : Nat ⊢ a ^ (m * n) = (a ^ m) ^ n ** induction n with | zero => rw [Nat.mul_zero, Nat.pow_zero, Nat.pow_zero] | succ _ ih => rw [Nat.mul_succ, Nat.pow_add, Nat.pow_succ, ih] ** case zero a m : Nat ⊢ a ^ (m * zero) = (a ^ m) ^ zero ** rw [Nat.mul_zero, Nat.pow_zero, Nat.pow_zero] ** case succ a m n✝ : Nat ih : a ^ (m * n✝) = (a ^ m) ^ n✝ ⊢ a ^ (m * succ n✝) = (a ^ m) ^ succ n✝ ** rw [Nat.mul_succ, Nat.pow_add, Nat.pow_succ, ih] ** Qed

Nat.pow_mul' ** a m n : Nat ⊢ a ^ (m * n) = (a ^ n) ^ m ** rw [←Nat.pow_mul, Nat.mul_comm] ** Qed

Nat.log2_lt ** n k : Nat h : n ≠ 0 ⊢ log2 n < k ↔ n < 2 ^ k ** rw [← Nat.not_le, ← Nat.not_le, le_log2 h] ** Qed

Nat.dvd_refl ** a : Nat ⊢ a = a * 1 ** simp ** Qed

Nat.dvd_zero ** a : Nat ⊢ 0 = a * 0 ** simp ** Qed

Nat.dvd_trans ** a b c : Nat h₁ : a ∣ b h₂ : b ∣ c d : Nat h₃ : b = a * d e : Nat h₄ : c = b * e ⊢ c = a * (d * e) ** simp[h₃,h₄, Nat.mul_assoc] ** Qed

Nat.dvd_add ** a b c : Nat h₁ : a ∣ b h₂ : a ∣ c d : Nat hd : b = a * d e : Nat he : c = a * e ⊢ b + c = a * (d + e) ** simp [Nat.left_distrib, hd, he] ** Qed

Nat.dvd_add_iff_left ** k m n : Nat h : k ∣ n ⊢ k ∣ m ↔ k ∣ m + n ** rw [Nat.add_comm] ** k m n : Nat h : k ∣ n ⊢ k ∣ m ↔ k ∣ n + m ** exact Nat.dvd_add_iff_right h ** Qed

Nat.dvd_sub ** k m n : Nat H : n ≤ m h₁ : k ∣ m h₂ : k ∣ n ⊢ k ∣ m - n + n ** rwa [Nat.sub_add_cancel H] ** Qed

Nat.mul_dvd_mul ** a b c d e : Nat he : b = a * e f : Nat hf : d = c * f ⊢ b * d = a * c * (e * f) ** simp [he, hf, Nat.mul_assoc, Nat.mul_left_comm, Nat.mul_comm] ** Qed

Nat.dvd_mod_iff ** k m n : Nat h : k ∣ n this : k ∣ ?m.55641 h ↔ k ∣ ?m.55641 h + n * (m / n) ⊢ k ∣ m % n ↔ k ∣ m ** rwa [mod_add_div] at this ** Qed

Nat.le_of_dvd ** m n : Nat h : 0 < n k : Nat e : n = m * k ⊢ m ≤ n ** revert h ** m n k : Nat e : n = m * k ⊢ 0 < n → m ≤ n ** rw [e] ** m n k : Nat e : n = m * k ⊢ 0 < m * k → m ≤ m * k ** match k with | 0 => intro hn; simp at hn | pk+1 => intro have := Nat.mul_le_mul_left m (succ_pos pk) rwa [Nat.mul_one] at this ** m n k : Nat e : n = m * 0 ⊢ 0 < m * 0 → m ≤ m * 0 ** intro hn ** m n k : Nat e : n = m * 0 hn : 0 < m * 0 ⊢ m ≤ m * 0 ** simp at hn ** m n k pk : Nat e : n = m * (pk + 1) ⊢ 0 < m * (pk + 1) → m ≤ m * (pk + 1) ** intro ** m n k pk : Nat e : n = m * (pk + 1) h✝ : 0 < m * (pk + 1) ⊢ m ≤ m * (pk + 1) ** have := Nat.mul_le_mul_left m (succ_pos pk) ** m n k pk : Nat e : n = m * (pk + 1) h✝ : 0 < m * (pk + 1) this : m * succ 0 ≤ m * succ pk ⊢ m ≤ m * (pk + 1) ** rwa [Nat.mul_one] at this ** Qed

Nat.eq_one_of_dvd_one ** n : Nat H : n ∣ 1 ⊢ 0 < 1 ** decide ** Qed

Nat.dvd_of_mod_eq_zero ** m n : Nat H : n % m = 0 ⊢ m ∣ n ** exists n / m ** m n : Nat H : n % m = 0 ⊢ n = m * (n / m) ** have := (mod_add_div n m).symm ** m n : Nat H : n % m = 0 this : n = n % m + m * (n / m) ⊢ n = m * (n / m) ** rwa [H, Nat.zero_add] at this ** Qed

Nat.mod_eq_zero_of_dvd ** m n : Nat H : m ∣ n ⊢ n % m = 0 ** let ⟨z, H⟩ := H ** m n : Nat H✝ : m ∣ n z : Nat H : n = m * z ⊢ n % m = 0 ** rw [H, mul_mod_right] ** Qed

Nat.mul_div_cancel' ** n m : Nat H : n ∣ m ⊢ n * (m / n) = m ** have := mod_add_div m n ** n m : Nat H : n ∣ m this : m % n + n * (m / n) = m ⊢ n * (m / n) = m ** rwa [mod_eq_zero_of_dvd H, Nat.zero_add] at this ** Qed

Nat.div_mul_cancel ** n m : Nat H : n ∣ m ⊢ m / n * n = m ** rw [Nat.mul_comm, Nat.mul_div_cancel' H] ** Qed

Nat.mul_div_assoc ** k n m : Nat H : k ∣ n ⊢ m * n / k = m * (n / k) ** match Nat.eq_zero_or_pos k with | .inl h0 => rw [h0, Nat.div_zero, Nat.div_zero, Nat.mul_zero] | .inr hpos => have h1 : m * n / k = m * (n / k * k) / k := by rw [Nat.div_mul_cancel H] rw [h1, ← Nat.mul_assoc, Nat.mul_div_cancel _ hpos] ** k n m : Nat H : k ∣ n h0 : k = 0 ⊢ m * n / k = m * (n / k) ** rw [h0, Nat.div_zero, Nat.div_zero, Nat.mul_zero] ** k n m : Nat H : k ∣ n hpos : k > 0 ⊢ m * n / k = m * (n / k) ** have h1 : m * n / k = m * (n / k * k) / k := by rw [Nat.div_mul_cancel H] ** k n m : Nat H : k ∣ n hpos : k > 0 h1 : m * n / k = m * (n / k * k) / k ⊢ m * n / k = m * (n / k) ** rw [h1, ← Nat.mul_assoc, Nat.mul_div_cancel _ hpos] ** k n m : Nat H : k ∣ n hpos : k > 0 ⊢ m * n / k = m * (n / k * k) / k ** rw [Nat.div_mul_cancel H] ** Qed

Nat.dvd_of_mul_dvd_mul_left ** k m n : Nat kpos : 0 < k H : k * m ∣ k * n ⊢ m ∣ n ** let ⟨l, H⟩ := H ** k m n : Nat kpos : 0 < k H✝ : k * m ∣ k * n l : Nat H : k * n = k * m * l ⊢ m ∣ n ** rw [Nat.mul_assoc] at H ** k m n : Nat kpos : 0 < k H✝ : k * m ∣ k * n l : Nat H : k * n = k * (m * l) ⊢ m ∣ n ** exact ⟨_, Nat.eq_of_mul_eq_mul_left kpos H⟩ ** Qed

Nat.dvd_of_mul_dvd_mul_right ** k m n : Nat kpos : 0 < k H : m * k ∣ n * k ⊢ m ∣ n ** rw [Nat.mul_comm m k, Nat.mul_comm n k] at H ** k m n : Nat kpos : 0 < k H : k * m ∣ k * n ⊢ m ∣ n ** exact Nat.dvd_of_mul_dvd_mul_left kpos H ** Qed

Nat.sum_append ** l₁ l₂ : List Nat ⊢ Nat.sum (l₁ ++ l₂) = Nat.sum l₁ + Nat.sum l₂ ** induction l₁ <;> simp [*, Nat.add_assoc] ** Qed

Nat.zero_shiftRight ** ⊢ 0 >>> 0 = 0 ** simp [shiftRight] ** n : Nat ⊢ 0 >>> (n + 1) = 0 ** simp [shiftRight, zero_shiftRight] ** Qed

Nat.shiftRight_add ** m n k : Nat ⊢ m >>> (n + (k + 1)) = m >>> n >>> (k + 1) ** simp [add_succ, shiftRight_add] ** Qed

Nat.shiftRight_eq_div_pow ** m k : Nat ⊢ m >>> (k + 1) = m / 2 ^ (k + 1) ** rw [shiftRight_add, shiftRight_eq_div_pow m k] ** m k : Nat ⊢ (m / 2 ^ k) >>> 1 = m / 2 ^ (k + 1) ** simp [Nat.div_div_eq_div_mul, ← Nat.pow_succ] ** Qed

List.append_inj ** α : Type u_1 a : α s₁ : List α b : α s₂ t₁ t₂ : List α h : a :: s₁ ++ t₁ = b :: s₂ ++ t₂ hl : length (a :: s₁) = length (b :: s₂) ⊢ a :: s₁ = b :: s₂ ∧ t₁ = t₂ ** simp [append_inj (cons.inj h).2 (Nat.succ.inj hl)] at h ⊢ ** α : Type u_1 a : α s₁ : List α b : α s₂ t₁ t₂ : List α hl : length (a :: s₁) = length (b :: s₂) h : a = b ⊢ a = b ** exact h ** Qed

List.append_inj' ** α✝ : Type u_1 s₁ t₁ s₂ t₂ : List α✝ h : s₁ ++ t₁ = s₂ ++ t₂ hl : length t₁ = length t₂ ⊢ length s₁ + length t₁ = length s₂ + length t₁ ** let hap := congrArg length h ** α✝ : Type u_1 s₁ t₁ s₂ t₂ : List α✝ h : s₁ ++ t₁ = s₂ ++ t₂ hl : length t₁ = length t₂ hap : length (s₁ ++ t₁) = length (s₂ ++ t₂) := congrArg length h ⊢ length s₁ + length t₁ = length s₂ + length t₁ ** simp only [length_append, ← hl] at hap ** α✝ : Type u_1 s₁ t₁ s₂ t₂ : List α✝ h : s₁ ++ t₁ = s₂ ++ t₂ hl : length t₁ = length t₂ hap : length s₁ + length t₁ = length s₂ + length t₁ ⊢ length s₁ + length t₁ = length s₂ + length t₁ ** exact hap ** Qed

List.map_append ** α : Type u_1 β : Type u_2 f : α → β ⊢ ∀ (l₁ l₂ : List α), map f (l₁ ++ l₂) = map f l₁ ++ map f l₂ ** intro l₁ ** α : Type u_1 β : Type u_2 f : α → β l₁ : List α ⊢ ∀ (l₂ : List α), map f (l₁ ++ l₂) = map f l₁ ++ map f l₂ ** induction l₁ <;> intros <;> simp_all ** Qed

List.map_id ** α : Type u_1 l : List α ⊢ map id l = l ** induction l <;> simp_all ** Qed

List.map_map ** β : Type u_1 γ : Type u_2 α : Type u_3 g : β → γ f : α → β l : List α ⊢ map g (map f l) = map (g ∘ f) l ** induction l <;> simp_all ** Qed

List.nil_bind ** α : Type u_1 β : Type u_2 f : α → List β ⊢ List.bind [] f = [] ** simp [join, List.bind] ** Qed

List.cons_bind ** α : Type u_1 β : Type u_2 x : α xs : List α f : α → List β ⊢ List.bind (x :: xs) f = f x ++ List.bind xs f ** simp [join, List.bind] ** Qed

List.append_bind ** α : Type u_1 β : Type u_2 xs ys : List α f : α → List β ⊢ List.bind (xs ++ ys) f = List.bind xs f ++ List.bind ys f ** induction xs ** case nil α : Type u_1 β : Type u_2 ys : List α f : α → List β ⊢ List.bind ([] ++ ys) f = List.bind [] f ++ List.bind ys f case cons α : Type u_1 β : Type u_2 ys : List α f : α → List β head✝ : α tail✝ : List α tail_ih✝ : List.bind (tail✝ ++ ys) f = List.bind tail✝ f ++ List.bind ys f ⊢ List.bind (head✝ :: tail✝ ++ ys) f = List.bind (head✝ :: tail✝) f ++ List.bind ys f ** {rfl} ** case cons α : Type u_1 β : Type u_2 ys : List α f : α → List β head✝ : α tail✝ : List α tail_ih✝ : List.bind (tail✝ ++ ys) f = List.bind tail✝ f ++ List.bind ys f ⊢ List.bind (head✝ :: tail✝ ++ ys) f = List.bind (head✝ :: tail✝) f ++ List.bind ys f ** simp_all [cons_bind, append_assoc] ** Qed

List.bind_id ** α : Type u_1 l : List (List α) ⊢ List.bind l id = join l ** simp [List.bind] ** Qed

List.reverse_map ** α : Type u_1 β : Type u_2 f : α → β l : List α ⊢ reverse (map f l) = map f (reverse l) ** induction l <;> simp [*] ** Qed

List.take_length_le ** α : Type u_1 i : Nat l : List α h : length l ≤ i ⊢ take i l = l ** have := take_append_drop i l ** α : Type u_1 i : Nat l : List α h : length l ≤ i this : take i l ++ drop i l = l ⊢ take i l = l ** rw [drop_length_le h, append_nil] at this ** α : Type u_1 i : Nat l : List α h : length l ≤ i this : take i l = l ⊢ take i l = l ** exact this ** Qed

List.take_nil ** α : Type u_1 i : Nat ⊢ take i [] = [] ** cases i <;> rfl ** Qed

List.take_concat_get ** α : Type u_1 l : List α i : Nat h : i < length l ⊢ l = concat (take i l) l[i] ++ drop (i + 1) l ** rw [concat_eq_append, append_assoc, singleton_append, get_drop_eq_drop, take_append_drop] ** Qed

List.reverse_concat ** α : Type u_1 l : List α a : α ⊢ reverse (concat l a) = a :: reverse l ** rw [concat_eq_append, reverse_append] ** α : Type u_1 l : List α a : α ⊢ reverse [a] ++ reverse l = a :: reverse l ** rfl ** Qed

List.foldlM_cons ** m : Type u_1 → Type u_2 β : Type u_1 α : Type u_3 inst✝ : Monad m f : β → α → m β b : β a : α l : List α ⊢ List.foldlM f b (a :: l) = do let init ← f b a List.foldlM f init l ** simp [List.foldlM] ** Qed

List.foldlM_append ** m : Type u_1 → Type u_2 β : Type u_1 α : Type u_3 inst✝¹ : Monad m inst✝ : LawfulMonad m f : β → α → m β b : β l l' : List α ⊢ List.foldlM f b (l ++ l') = do let init ← List.foldlM f b l List.foldlM f init l' ** induction l generalizing b <;> simp [*] ** Qed

List.foldrM_cons ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m a : α l : List α f : α → β → m β b : β ⊢ foldrM f b (a :: l) = foldrM f b l >>= f a ** simp only [foldrM] ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m a : α l : List α f : α → β → m β b : β ⊢ List.foldlM (fun s a => f a s) b (reverse (a :: l)) = List.foldlM (fun s a => f a s) b (reverse l) >>= f a ** induction l <;> simp_all ** Qed

List.foldrM_reverse ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝ : Monad m l : List α f : α → β → m β b : β ⊢ List.foldlM (fun y x => f x y) b (reverse (reverse l)) = List.foldlM (fun x y => f y x) b l ** simp ** Qed

List.foldl_eq_foldlM ** β : Type u_1 α : Type u_2 f : β → α → β b : β l : List α ⊢ foldl f b l = List.foldlM f b l ** induction l generalizing b <;> simp [*, foldl] ** Qed

List.foldr_eq_foldrM ** α : Type u_1 β : Type u_2 f : α → β → β b : β l : List α ⊢ foldr f b l = foldrM f b l ** induction l <;> simp [*, foldr] ** Qed

List.foldl_reverse ** α : Type u_1 β : Type u_2 l : List α f : β → α → β b : β ⊢ foldl f b (reverse l) = foldr (fun x y => f y x) b l ** simp [foldl_eq_foldlM, foldr_eq_foldrM] ** Qed

List.foldr_reverse ** α : Type u_1 β : Type u_2 l : List α f : α → β → β b : β ⊢ foldl (fun y x => f x y) b (reverse (reverse l)) = foldl (fun x y => f y x) b l ** simp ** Qed

List.foldrM_append ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → β → m β b : β l l' : List α ⊢ foldrM f b (l ++ l') = do let init ← foldrM f b l' foldrM f init l ** induction l <;> simp [*] ** Qed

List.foldl_append ** α : Type u_1 β : Type u_2 f : β → α → β b : β l l' : List α ⊢ foldl f b (l ++ l') = foldl f (foldl f b l) l' ** simp [foldl_eq_foldlM] ** Qed

List.foldr_append ** α : Type u_1 β : Type u_2 f : α → β → β b : β l l' : List α ⊢ foldr f b (l ++ l') = foldr f (foldr f b l') l ** simp [foldr_eq_foldrM] ** Qed

List.foldr_self_append ** α : Type u_1 l' l : List α ⊢ foldr cons l' l = l ++ l' ** induction l <;> simp [*] ** Qed

List.foldr_self ** α : Type u_1 l : List α ⊢ foldr cons [] l = l ** simp ** Qed

List.mapM'_eq_mapM ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β l : List α ⊢ mapM' f l = mapM f l ** simp [go, mapM] ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β l : List α acc : List β ⊢ mapM.loop f [] acc = do let __do_lift ← mapM' f [] pure (reverse acc ++ __do_lift) ** simp [mapM.loop, mapM'] ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β l✝ : List α a : α l : List α acc : List β ⊢ mapM.loop f (a :: l) acc = do let __do_lift ← mapM' f (a :: l) pure (reverse acc ++ __do_lift) ** simp [go l, mapM.loop, mapM'] ** Qed

List.mapM_append ** m : Type u_1 → Type u_2 α : Type u_3 β : Type u_1 inst✝¹ : Monad m inst✝ : LawfulMonad m f : α → m β l₁ l₂ : List α ⊢ mapM f (l₁ ++ l₂) = do let __do_lift ← mapM f l₁ let __do_lift_1 ← mapM f l₂ pure (__do_lift ++ __do_lift_1) ** induction l₁ <;> simp [*] ** Qed

List.zipWith_nil_left ** α : Type u_1 β : Type u_2 γ : Type u_3 l : List β f : α → β → γ ⊢ zipWith f [] l = [] ** rfl ** Qed

List.zipWith_nil_right ** α : Type u_1 β : Type u_2 γ : Type u_3 l : List α f : α → β → γ ⊢ zipWith f l [] = [] ** simp [zipWith] ** Qed

List.zipWith_cons_cons ** α : Type u_1 β : Type u_2 γ : Type u_3 a : α as : List α b : β bs : List β f : α → β → γ ⊢ zipWith f (a :: as) (b :: bs) = f a b :: zipWith f as bs ** rfl ** Qed

List.zip_nil_left ** α : Type u_1 β : Type u_2 l : List β ⊢ zip [] l = [] ** rfl ** Qed

List.zip_nil_right ** α : Type u_1 l : List α β : Type u_2 ⊢ zip l [] = [] ** simp [zip] ** Qed

List.zip_cons_cons ** α✝¹ : Type u_1 a : α✝¹ as : List α✝¹ α✝ : Type u_2 b : α✝ bs : List α✝ ⊢ zip (a :: as) (b :: bs) = (a, b) :: zip as bs ** rfl ** Qed

List.isPrefixOf_nil_left ** α : Type u_1 l : List α inst✝ : BEq α ⊢ isPrefixOf [] l = true ** simp [isPrefixOf] ** Qed

Sum.forall_sum ** α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop ⊢ (∀ (fab : (ab : α ⊕ β) → γ ab), p fab) ↔ ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t ** refine ⟨fun h fa fb => h _, fun h fab => ?_⟩ ** α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab ⊢ p fab ** have h1 : fab = Sum.rec (fun a => fab (Sum.inl a)) (fun b => fab (Sum.inr b)) := by ext ab; cases ab <;> rfl ** α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab h1 : fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t ⊢ p fab ** rw [h1] ** α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab h1 : fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t ⊢ p fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t ** exact h _ _ ** α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab ⊢ fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t ** ext ab ** case h α : Type u_1 β : Type u_2 γ : α ⊕ β → Sort u_3 p : ((ab : α ⊕ β) → γ ab) → Prop h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t fab : (ab : α ⊕ β) → γ ab ab : α ⊕ β ⊢ fab ab = rec (fun a => fab (inl a)) (fun b => fab (inr b)) ab ** cases ab <;> rfl ** Qed

Sum.getLeft?_eq_none_iff ** α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ getLeft? x = none ↔ isRight x = true ** cases x <;> simp only [getLeft?, isRight, eq_self_iff_true] ** Qed

Sum.getRight?_eq_none_iff ** α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ getRight? x = none ↔ isLeft x = true ** cases x <;> simp only [getRight?, isLeft, eq_self_iff_true] ** Qed

Sum.getLeft_eq_iff ** α✝ : Type u_1 a : α✝ β✝ : Type u_2 x : α✝ ⊕ β✝ h : isLeft x = true ⊢ getLeft x h = a ↔ x = inl a ** cases x <;> simp at h ⊢ ** Qed

Sum.getRight_eq_iff ** β✝ : Type u_1 b : β✝ α✝ : Type u_2 x : α✝ ⊕ β✝ h : isRight x = true ⊢ getRight x h = b ↔ x = inr b ** cases x <;> simp at h ⊢ ** Qed

Sum.getLeft?_eq_some_iff ** α✝ : Type u_1 a : α✝ β✝ : Type u_2 x : α✝ ⊕ β✝ ⊢ getLeft? x = some a ↔ x = inl a ** cases x <;> simp only [getLeft?, Option.some.injEq, inl.injEq] ** Qed

Sum.getRight?_eq_some_iff ** β✝ : Type u_1 b : β✝ α✝ : Type u_2 x : α✝ ⊕ β✝ ⊢ getRight? x = some b ↔ x = inr b ** cases x <;> simp only [getRight?, Option.some.injEq, inr.injEq] ** Qed

Sum.bnot_isLeft ** α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ (!decide (isLeft x = isRight x)) = true ** cases x <;> rfl ** Qed

Sum.isLeft_eq_false ** α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ isLeft x = false ↔ isRight x = true ** cases x <;> simp ** Qed

Sum.not_isLeft ** α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ ¬isLeft x = true ↔ isRight x = true ** simp ** Qed

Sum.bnot_isRight ** α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ (!decide (isRight x = isLeft x)) = true ** cases x <;> rfl ** Qed

Sum.isRight_eq_false ** α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ isRight x = false ↔ isLeft x = true ** cases x <;> simp ** Qed

Sum.not_isRight ** α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ ¬isRight x = true ↔ isLeft x = true ** simp ** Qed

Sum.isLeft_iff ** α✝ : Type u_1 β✝ : Type u_2 x : α✝ ⊕ β✝ ⊢ isLeft x = true ↔ ∃ y, x = inl y ** cases x <;> simp ** Qed

Sum.isRight_iff ** α✝ : Type u_1 β✝ : Type u_2 x : α✝ ⊕ β✝ ⊢ isRight x = true ↔ ∃ y, x = inr y ** cases x <;> simp ** Qed