ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.inter_subset_right
theorem inter_subset_right {l₁ l₂ : List α} : l₁ ∩ l₂ ⊆ l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α}
Goal: l₁ ∩ l₂ ⊆ l₂
-- List.subset_inter
theorem subset_inter {l l₁ l₂ : List α} (h₁ : l ⊆ l₁) (h₂ : l ⊆ l₂) : l ⊆ l₁ ∩ l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l l₁ l₂ : List α} (h₁ : l ⊆ l₁) (h₂ : l ⊆ l₂)
Goal: l ⊆ l₁ ∩ l₂
-- List.inter_eq_nil_iff_disjoint
theorem inter_eq_nil_iff_disjoint : l₁ ∩ l₂ = [] ↔ Disjoint l₁ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} [DecidableEq α]
Goal: l₁ ∩ l₂ = [] ↔ l₁.Disjoint l₂
-- List.forall_mem_inter_of_forall_left
theorem forall_mem_inter_of_forall_left (h : ∀ x ∈ l₁, p x) (l₂ : List α) :
    ∀ x, x ∈ l₁ ∩ l₂ → p x 
Arguments: {α : Type u_1} {l₁ : List α} {p : α → Prop} [DecidableEq α] (h : ∀ (x : α), x ∈ l₁ → p x) (l₂ : List α) (x : α)
Goal: x ∈ l₁ ∩ l₂ → p x
-- List.forall_mem_inter_of_forall_right
theorem forall_mem_inter_of_forall_right (l₁ : List α) (h : ∀ x ∈ l₂, p x) :
    ∀ x, x ∈ l₁ ∩ l₂ → p x 
Arguments: {α : Type u_1} {l₂ : List α} {p : α → Prop} [DecidableEq α] (l₁ : List α) (h : ∀ (x : α), x ∈ l₂ → p x) (x : α)
Goal: x ∈ l₁ ∩ l₂ → p x
-- List.inter_reverse
@[simp]
theorem inter_reverse {xs ys : List α} : xs.inter ys.reverse = xs.inter ys 
Arguments: {α : Type u_1} [DecidableEq α] {xs ys : List α}
Goal: xs.inter ys.reverse = xs.inter ys
-- List.Subset.inter_eq_left
theorem Subset.inter_eq_left {xs ys : List α} (h : xs ⊆ ys) : xs ∩ ys = xs 
Arguments: {α : Type u_1} [DecidableEq α] {xs ys : List α} (h : xs ⊆ ys)
Goal: xs ∩ ys = xs
-- List.nil_bagInter
@[simp]
theorem nil_bagInter (l : List α) : [].bagInter l = [] 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: [].bagInter l = []
-- List.bagInter_nil
@[simp]
theorem bagInter_nil (l : List α) : l.bagInter [] = [] 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l.bagInter [] = []
-- List.cons_bagInter_of_pos
@[simp]
theorem cons_bagInter_of_pos (l₁ : List α) (h : a ∈ l₂) :
    (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a) 
Arguments: {α : Type u_1} {l₂ : List α} {a : α} [DecidableEq α] (l₁ : List α) (h : a ∈ l₂)
Goal: (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)
-- List.cons_bagInter_of_neg
@[simp]
theorem cons_bagInter_of_neg (l₁ : List α) (h : a ∉ l₂) :
    (a :: l₁).bagInter l₂ = l₁.bagInter l₂ 
Arguments: {α : Type u_1} {l₂ : List α} {a : α} [DecidableEq α] (l₁ : List α) (h : ¬a ∈ l₂)
Goal: (a :: l₁).bagInter l₂ = l₁.bagInter l₂
-- List.mem_bagInter
@[simp]
theorem mem_bagInter {a : α} : ∀ {l₁ l₂ : List α}, a ∈ l₁.bagInter l₂ ↔ a ∈ l₁ ∧ a ∈ l₂
  
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l₁ l₂ : List α}
Goal: a ∈ l₁.bagInter l₂ ↔ a ∈ l₁ ∧ a ∈ l₂
-- List.count_bagInter
@[simp]
theorem count_bagInter {a : α} :
    ∀ {l₁ l₂ : List α}, count a (l₁.bagInter l₂) = min (count a l₁) (count a l₂)
  
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l₁ l₂ : List α}
Goal: List.count a (l₁.bagInter l₂) = min (List.count a l₁) (List.count a l₂)
-- List.bagInter_sublist_left
theorem bagInter_sublist_left : ∀ l₁ l₂ : List α, l₁.bagInter l₂ <+ l₁
  
Arguments: {α : Type u_1} [DecidableEq α] (l₁ l₂ : List α)
Goal: (l₁.bagInter l₂).Sublist l₁
-- List.bagInter_nil_iff_inter_nil
theorem bagInter_nil_iff_inter_nil : ∀ l₁ l₂ : List α, l₁.bagInter l₂ = [] ↔ l₁ ∩ l₂ = []
  
Arguments: {α : Type u_1} [DecidableEq α] (l₁ l₂ : List α)
Goal: l₁.bagInter l₂ = [] ↔ l₁ ∩ l₂ = []
-- List.map_coe_finRange
@[simp]
theorem map_coe_finRange (n : ℕ) : ((finRange n) : List (Fin n)).map (Fin.val) = List.range n 
Arguments: (n : ℕ)
Goal: List.map Fin.val (List.finRange n) = List.range n
-- List.finRange_succ_eq_map
theorem finRange_succ_eq_map (n : ℕ) : finRange n.succ = 0 :: (finRange n).map Fin.succ 
Arguments: (n : ℕ)
Goal: List.finRange n.succ = 0 :: List.map Fin.succ (List.finRange n)
-- List.finRange_succ
theorem finRange_succ (n : ℕ) :
    finRange n.succ = (finRange n |>.map Fin.castSucc |>.concat (.last _)) 
Arguments: (n : ℕ)
Goal: List.finRange n.succ = (List.map Fin.castSucc (List.finRange n)).concat (Fin.last n)
-- List.ofFn_eq_pmap
theorem ofFn_eq_pmap {n} {f : Fin n → α} :
    ofFn f = pmap (fun i hi => f ⟨i, hi⟩) (range n) fun _ => mem_range.1 
Arguments: {α : Type u} {n : ℕ} {f : Fin n → α}
Goal: List.ofFn f = List.pmap (fun i hi => f ⟨i, hi⟩) (List.range n) ⋯
-- List.ofFn_id
theorem ofFn_id (n) : ofFn id = finRange n 
Arguments: (n : ℕ)
Goal: List.ofFn id = List.finRange n
-- List.ofFn_eq_map
theorem ofFn_eq_map {n} {f : Fin n → α} : ofFn f = (finRange n).map f 
Arguments: {α : Type u} {n : ℕ} {f : Fin n → α}
Goal: List.ofFn f = List.map f (List.finRange n)
-- List.nodup_ofFn_ofInjective
theorem nodup_ofFn_ofInjective {n} {f : Fin n → α} (hf : Function.Injective f) :
    Nodup (ofFn f) 
Arguments: {α : Type u} {n : ℕ} {f : Fin n → α} (hf : Function.Injective f)
Goal: (List.ofFn f).Nodup
-- List.nodup_ofFn
theorem nodup_ofFn {n} {f : Fin n → α} : Nodup (ofFn f) ↔ Function.Injective f 
Arguments: {α : Type u} {n : ℕ} {f : Fin n → α}
Goal: (List.ofFn f).Nodup ↔ Function.Injective f
-- Equiv.Perm.map_finRange_perm
theorem Equiv.Perm.map_finRange_perm {n : ℕ} (σ : Equiv.Perm (Fin n)) :
    map σ (finRange n) ~ finRange n 
Arguments: {n : ℕ} (σ : Equiv.Perm (Fin n))
Goal: List.map (⇑σ) (List.finRange n) ~ List.finRange n
-- Equiv.Perm.ofFn_comp_perm
theorem Equiv.Perm.ofFn_comp_perm {n : ℕ} {α : Type u} (σ : Equiv.Perm (Fin n)) (f : Fin n → α) :
    ofFn (f ∘ σ) ~ ofFn f 
Arguments: {n : ℕ} {α : Type u} (σ : Equiv.Perm (Fin n)) (f : Fin n → α)
Goal: List.ofFn (f ∘ ⇑σ) ~ List.ofFn f
-- List.tfae_nil
theorem tfae_nil : TFAE [] 
Goal: [].TFAE
-- List.tfae_singleton
@[simp]
theorem tfae_singleton (p) : TFAE [p] 
Arguments: (p : Prop)
Goal: [p].TFAE
-- List.tfae_cons_of_mem
theorem tfae_cons_of_mem {a b} {l : List Prop} (h : b ∈ l) : TFAE (a :: l) ↔ (a ↔ b) ∧ TFAE l 
Arguments: {a b : Prop} {l : List Prop} (h : b ∈ l)
Goal: (a :: l).TFAE ↔ (a ↔ b) ∧ l.TFAE
-- List.tfae_cons_cons
theorem tfae_cons_cons {a b} {l : List Prop} : TFAE (a :: b :: l) ↔ (a ↔ b) ∧ TFAE (b :: l) 
Arguments: {a b : Prop} {l : List Prop}
Goal: (a :: b :: l).TFAE ↔ (a ↔ b) ∧ (b :: l).TFAE
-- List.tfae_cons_self
@[simp]
theorem tfae_cons_self {a} {l : List Prop} : TFAE (a :: a :: l) ↔ TFAE (a :: l) 
Arguments: {a : Prop} {l : List Prop}
Goal: (a :: a :: l).TFAE ↔ (a :: l).TFAE
-- List.tfae_of_forall
theorem tfae_of_forall (b : Prop) (l : List Prop) (h : ∀ a ∈ l, a ↔ b) : TFAE l 
Arguments: (b : Prop) (l : List Prop) (h : ∀ (a : Prop), a ∈ l → (a ↔ b))
Goal: l.TFAE
-- List.tfae_of_cycle
theorem tfae_of_cycle {a b} {l : List Prop} (h_chain : List.Chain (· → ·) a (b :: l))
    (h_last : getLastD l b → a) : TFAE (a :: b :: l) 
Arguments: {a b : Prop} {l : List Prop} (h_chain : List.Chain (fun x x_1 => x → x_1) a (b :: l)) (h_last : l.getLastD b → a)
Goal: (a :: b :: l).TFAE
-- List.TFAE.out
theorem TFAE.out {l} (h : TFAE l) (n₁ n₂) {a b} (h₁ : List.get? l n₁ = some a := by rfl)
    (h₂ : List.get? l n₂ = some b := by rfl) : a ↔ b 
Arguments: {l : List Prop} (h : l.TFAE) (n₁ n₂ : Nat) {a b : Prop} (h₁ : l.get? n₁ = some a := by rfl) (h₂ : l.get? n₂ = some b := by rfl)
Goal: a ↔ b
-- List.forall_tfae
theorem forall_tfae {α : Type*} (l : List (α → Prop)) (H : ∀ a : α, (l.map (fun p ↦ p a)).TFAE) :
    (l.map (fun p ↦ ∀ a, p a)).TFAE 
Arguments: {α : Type u_1} (l : List (α → Prop)) (H : ∀ (a : α), (List.map (fun p => p a) l).TFAE)
Goal: (List.map (fun p => ∀ (a : α), p a) l).TFAE
-- List.exists_tfae
theorem exists_tfae {α : Type*} (l : List (α → Prop)) (H : ∀ a : α, (l.map (fun p ↦ p a)).TFAE) :
    (l.map (fun p ↦ ∃ a, p a)).TFAE 
Arguments: {α : Type u_1} (l : List (α → Prop)) (H : ∀ (a : α), (List.map (fun p => p a) l).TFAE)
Goal: (List.map (fun p => ∃ a, p a) l).TFAE
-- List.tfae_not_iff
theorem tfae_not_iff {l : List Prop} : TFAE (l.map Not) ↔ TFAE l 
Arguments: {l : List Prop}
Goal: (List.map Not l).TFAE ↔ l.TFAE
-- Int.le_rfl
protected lemma le_rfl : a ≤ a 
Arguments: {a : ℤ}
Goal: a ≤ a
-- Int.lt_or_lt_of_ne
protected lemma lt_or_lt_of_ne : a ≠ b → a < b ∨ b < a 
Arguments: {a b : ℤ}
Goal: a ≠ b → a < b ∨ b < a
-- Int.lt_or_le
protected lemma lt_or_le (a b : ℤ) : a < b ∨ b ≤ a 
Arguments: (a b : ℤ)
Goal: a < b ∨ b ≤ a
-- Int.le_or_lt
protected lemma le_or_lt (a b : ℤ) : a ≤ b ∨ b < a 
Arguments: (a b : ℤ)
Goal: a ≤ b ∨ b < a
-- Int.lt_asymm
protected lemma lt_asymm : a < b → ¬ b < a 
Arguments: {a b : ℤ}
Goal: a < b → ¬b < a
-- Int.le_of_eq
protected lemma le_of_eq (hab : a = b) : a ≤ b 
Arguments: {a b : ℤ} (hab : a = b)
Goal: a ≤ b
-- Int.ge_of_eq
protected lemma ge_of_eq (hab : a = b) : b ≤ a 
Arguments: {a b : ℤ} (hab : a = b)
Goal: b ≤ a
-- Int.le_antisymm_iff
protected lemma le_antisymm_iff : a = b ↔ a ≤ b ∧ b ≤ a 
Arguments: {a b : ℤ}
Goal: a = b ↔ a ≤ b ∧ b ≤ a
-- Int.le_iff_eq_or_lt
protected lemma le_iff_eq_or_lt : a ≤ b ↔ a = b ∨ a < b 
Arguments: {a b : ℤ}
Goal: a ≤ b ↔ a = b ∨ a < b
-- Int.le_iff_lt_or_eq
protected lemma le_iff_lt_or_eq : a ≤ b ↔ a < b ∨ a = b 
Arguments: {a b : ℤ}
Goal: a ≤ b ↔ a < b ∨ a = b
-- Int.one_pos
protected lemma one_pos : 0 < (1 : Int) 
Goal: 0 < 1
-- Int.one_ne_zero
protected lemma one_ne_zero : (1 : ℤ) ≠ 0 
Goal: 1 ≠ 0
-- Int.one_nonneg
protected lemma one_nonneg : 0 ≤ (1 : ℤ) 
Goal: 0 ≤ 1
-- Int.zero_le_ofNat
lemma zero_le_ofNat (n : ℕ) : 0 ≤ ofNat n 
Arguments: (n : ℕ)
Goal: 0 ≤ Int.ofNat n
-- Int.neg_eq_neg
protected theorem neg_eq_neg {a b : ℤ} (h : -a = -b) : a = b 
Arguments: {a b : ℤ} (h : -a = -b)
Goal: a = b
-- Int.neg_pos
@[simp, nolint simpNF]
protected lemma neg_pos : 0 < -a ↔ a < 0 
Arguments: {a : ℤ}
Goal: 0 < -a ↔ a < 0
-- Int.neg_nonneg
@[simp, nolint simpNF]
protected lemma neg_nonneg : 0 ≤ -a ↔ a ≤ 0 
Arguments: {a : ℤ}
Goal: 0 ≤ -a ↔ a ≤ 0
-- Int.neg_neg_iff_pos
@[simp, nolint simpNF]
protected lemma neg_neg_iff_pos : -a < 0 ↔ 0 < a 
Arguments: {a : ℤ}
Goal: -a < 0 ↔ 0 < a
-- Int.neg_nonpos_iff_nonneg
@[simp, nolint simpNF]
protected lemma neg_nonpos_iff_nonneg : -a ≤ 0 ↔ 0 ≤ a 
Arguments: {a : ℤ}
Goal: -a ≤ 0 ↔ 0 ≤ a
-- Int.sub_pos
@[simp, nolint simpNF]
protected lemma sub_pos : 0 < a - b ↔ b < a 
Arguments: {a b : ℤ}
Goal: 0 < a - b ↔ b < a
-- Int.sub_nonneg
@[simp, nolint simpNF]
protected lemma sub_nonneg : 0 ≤ a - b ↔ b ≤ a 
Arguments: {a b : ℤ}
Goal: 0 ≤ a - b ↔ b ≤ a
-- Int.ofNat_add_out
protected theorem ofNat_add_out (m n : ℕ) : ↑m + ↑n = (↑(m + n) : ℤ) 
Arguments: (m n : ℕ)
Goal: ↑m + ↑n = ↑(m + n)
-- Int.ofNat_mul_out
protected theorem ofNat_mul_out (m n : ℕ) : ↑m * ↑n = (↑(m * n) : ℤ) 
Arguments: (m n : ℕ)
Goal: ↑m * ↑n = ↑(m * n)
-- Int.ofNat_add_one_out
protected theorem ofNat_add_one_out (n : ℕ) : ↑n + (1 : ℤ) = ↑(succ n) 
Arguments: (n : ℕ)
Goal: ↑n + 1 = ↑n.succ
-- Int.ofNat_injective
@[simp] lemma ofNat_injective : Function.Injective ofNat 
Goal: Function.Injective Int.ofNat
-- Int.ofNat_eq_natCast
@[simp] lemma ofNat_eq_natCast (n : ℕ) : Int.ofNat n = n 
Arguments: (n : ℕ)
Goal: Int.ofNat n = ↑n
-- Int.natCast_eq_ofNat
@[deprecated ofNat_eq_natCast (since := "2024-03-24")]
protected lemma natCast_eq_ofNat (n : ℕ) : ↑n = Int.ofNat n 
Arguments: (n : ℕ)
Goal: ↑n = Int.ofNat n
-- Int.natCast_inj
@[norm_cast] lemma natCast_inj {m n : ℕ} : (m : ℤ) = (n : ℤ) ↔ m = n 
Arguments: {m n : ℕ}
Goal: ↑m = ↑n ↔ m = n
-- Int.natAbs_cast
@[simp, norm_cast] lemma natAbs_cast (n : ℕ) : natAbs ↑n = n 
Arguments: (n : ℕ)
Goal: (↑n).natAbs = n
-- Int.natCast_sub
@[norm_cast]
protected lemma natCast_sub {n m : ℕ} : n ≤ m → (↑(m - n) : ℤ) = ↑m - ↑n 
Arguments: {n m : ℕ}
Goal: n ≤ m → ↑(m - n) = ↑m - ↑n
-- Int.natCast_eq_zero
@[simp, nolint simpNF] lemma natCast_eq_zero {n : ℕ} : (n : ℤ) = 0 ↔ n = 0 
Arguments: {n : ℕ}
Goal: ↑n = 0 ↔ n = 0
-- Int.natCast_ne_zero
lemma natCast_ne_zero {n : ℕ} : (n : ℤ) ≠ 0 ↔ n ≠ 0 
Arguments: {n : ℕ}
Goal: ↑n ≠ 0 ↔ n ≠ 0
-- Int.natCast_ne_zero_iff_pos
lemma natCast_ne_zero_iff_pos {n : ℕ} : (n : ℤ) ≠ 0 ↔ 0 < n 
Arguments: {n : ℕ}
Goal: ↑n ≠ 0 ↔ 0 < n
-- Int.natCast_pos
@[simp, nolint simpNF] lemma natCast_pos {n : ℕ} : (0 : ℤ) < n ↔ 0 < n 
Arguments: {n : ℕ}
Goal: 0 < ↑n ↔ 0 < n
-- Int.natCast_succ_pos
lemma natCast_succ_pos (n : ℕ) : 0 < (n.succ : ℤ) 
Arguments: (n : ℕ)
Goal: 0 < ↑n.succ
-- Int.natCast_nonpos_iff
@[simp] lemma natCast_nonpos_iff {n : ℕ} : (n : ℤ) ≤ 0 ↔ n = 0 
Arguments: {n : ℕ}
Goal: ↑n ≤ 0 ↔ n = 0
-- Int.natCast_nonneg
lemma natCast_nonneg (n : ℕ) : 0 ≤ (n : ℤ) 
Arguments: (n : ℕ)
Goal: 0 ≤ ↑n
-- Int.sign_natCast_add_one
@[simp] lemma sign_natCast_add_one (n : ℕ) : sign (n + 1) = 1 
Arguments: (n : ℕ)
Goal: (↑n + 1).sign = 1
-- Int.cast_id
@[simp, norm_cast] lemma cast_id {n : ℤ} : Int.cast n = n 
Arguments: {n : ℤ}
Goal: ↑n = n
-- Int.two_mul
protected lemma two_mul : ∀ n : ℤ, 2 * n = n + n
  
Arguments: (n : ℤ)
Goal: 2 * n = n + n
-- Int.mul_le_mul_iff_of_pos_right
protected lemma mul_le_mul_iff_of_pos_right (ha : 0 < a) : b * a ≤ c * a ↔ b ≤ c 
Arguments: {a b c : ℤ} (ha : 0 < a)
Goal: b * a ≤ c * a ↔ b ≤ c
-- Int.mul_nonneg_iff_of_pos_right
protected lemma mul_nonneg_iff_of_pos_right (hb : 0 < b) : 0 ≤ a * b ↔ 0 ≤ a 
Arguments: {a b : ℤ} (hb : 0 < b)
Goal: 0 ≤ a * b ↔ 0 ≤ a
-- Int.natCast_succ
lemma natCast_succ (n : ℕ) : (Nat.succ n : ℤ) = Int.succ n 
Arguments: (n : ℕ)
Goal: ↑n.succ = (↑n).succ
-- Int.pred_succ
lemma pred_succ (a : ℤ) : pred (succ a) = a 
Arguments: (a : ℤ)
Goal: a.succ.pred = a
-- Int.succ_pred
lemma succ_pred (a : ℤ) : succ (pred a) = a 
Arguments: (a : ℤ)
Goal: a.pred.succ = a
-- Int.neg_succ
lemma neg_succ (a : ℤ) : -succ a = pred (-a) 
Arguments: (a : ℤ)
Goal: -a.succ = (-a).pred
-- Int.succ_neg_succ
lemma succ_neg_succ (a : ℤ) : succ (-succ a) = -a 
Arguments: (a : ℤ)
Goal: (-a.succ).succ = -a
-- Int.neg_pred
lemma neg_pred (a : ℤ) : -pred a = succ (-a) 
Arguments: (a : ℤ)
Goal: -a.pred = (-a).succ
-- Int.pred_neg_pred
lemma pred_neg_pred (a : ℤ) : pred (-pred a) = -a 
Arguments: (a : ℤ)
Goal: (-a.pred).pred = -a
-- Int.pred_nat_succ
lemma pred_nat_succ (n : ℕ) : pred (Nat.succ n) = n 
Arguments: (n : ℕ)
Goal: (↑n.succ).pred = ↑n
-- Int.neg_nat_succ
lemma neg_nat_succ (n : ℕ) : -(Nat.succ n : ℤ) = pred (-n) 
Arguments: (n : ℕ)
Goal: -↑n.succ = (-↑n).pred
-- Int.succ_neg_natCast_succ
lemma succ_neg_natCast_succ (n : ℕ) : succ (-Nat.succ n) = -n 
Arguments: (n : ℕ)
Goal: (-↑n.succ).succ = -↑n
-- Int.natCast_pred_of_pos
@[norm_cast] lemma natCast_pred_of_pos {n : ℕ} (h : 0 < n) : ((n - 1 : ℕ) : ℤ) = (n : ℤ) - 1 
Arguments: {n : ℕ} (h : 0 < n)
Goal: ↑(n - 1) = ↑n - 1
-- Int.lt_succ_self
lemma lt_succ_self (a : ℤ) : a < succ a 
Arguments: (a : ℤ)
Goal: a < a.succ
-- Int.pred_self_lt
lemma pred_self_lt (a : ℤ) : pred a < a 
Arguments: (a : ℤ)
Goal: a.pred < a
-- Int.le_add_one_iff
lemma le_add_one_iff : m ≤ n + 1 ↔ m ≤ n ∨ m = n + 1 
Arguments: {m n : ℤ}
Goal: m ≤ n + 1 ↔ m ≤ n ∨ m = n + 1
-- Int.sub_one_lt_iff
lemma sub_one_lt_iff : m - 1 < n ↔ m ≤ n 
Arguments: {m n : ℤ}
Goal: m - 1 < n ↔ m ≤ n
-- Int.le_sub_one_iff
lemma le_sub_one_iff : m ≤ n - 1 ↔ m < n 
Arguments: {m n : ℤ}
Goal: m ≤ n - 1 ↔ m < n
-- Int.add_le_iff_le_sub
protected lemma add_le_iff_le_sub : a + b ≤ c ↔ a ≤ c - b 
Arguments: {a b c : ℤ}
Goal: a + b ≤ c ↔ a ≤ c - b
-- Int.le_add_iff_sub_le
protected lemma le_add_iff_sub_le : a ≤ b + c ↔ a - c ≤ b 
Arguments: {a b c : ℤ}
Goal: a ≤ b + c ↔ a - c ≤ b
-- Int.add_le_zero_iff_le_neg
protected lemma add_le_zero_iff_le_neg : a + b ≤ 0 ↔ a ≤ - b 
Arguments: {a b : ℤ}
Goal: a + b ≤ 0 ↔ a ≤ -b
-- Int.add_le_zero_iff_le_neg'
protected lemma add_le_zero_iff_le_neg' : a + b ≤ 0 ↔ b ≤ -a 
Arguments: {a b : ℤ}
Goal: a + b ≤ 0 ↔ b ≤ -a
-- Int.add_nonnneg_iff_neg_le
protected lemma add_nonnneg_iff_neg_le : 0 ≤ a + b ↔ -b ≤ a 
Arguments: {a b : ℤ}
Goal: 0 ≤ a + b ↔ -b ≤ a
-- Int.add_nonnneg_iff_neg_le'
protected lemma add_nonnneg_iff_neg_le' : 0 ≤ a + b ↔ -a ≤ b 
Arguments: {a b : ℤ}
Goal: 0 ≤ a + b ↔ -a ≤ b
-- Int.induction_on
@[elab_as_elim] protected lemma induction_on {p : ℤ → Prop} (i : ℤ)
    (hz : p 0) (hp : ∀ i : ℕ, p i → p (i + 1)) (hn : ∀ i : ℕ, p (-i) → p (-i - 1)) : p i 
Arguments: {p : ℤ → Prop} (i : ℤ) (hz : p 0) (hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)) (hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1))
Goal: p i
-- Int.inductionOn'_self
lemma inductionOn'_self : b.inductionOn' b H0 Hs Hp = H0 
Arguments: {C : ℤ → Sort u_1} {b : ℤ} {H0 : C b} {Hs : (k : ℤ) → b ≤ k → C k → C (k + 1)} {Hp : (k : ℤ) → k ≤ b → C k → C (k - 1)}
Goal: b.inductionOn' b H0 Hs Hp = H0
-- Int.inductionOn'_add_one
lemma inductionOn'_add_one (hz : b ≤ z) :
    (z + 1).inductionOn' b H0 Hs Hp = Hs z hz (z.inductionOn' b H0 Hs Hp) 
Arguments: {C : ℤ → Sort u_1} {z b : ℤ} {H0 : C b} {Hs : (k : ℤ) → b ≤ k → C k → C (k + 1)} {Hp : (k : ℤ) → k ≤ b → C k → C (k - 1)} (hz : b ≤ z)
Goal: (z + 1).inductionOn' b H0 Hs Hp = Hs z hz (z.inductionOn' b H0 Hs Hp)
-- Int.inductionOn'_sub_one
lemma inductionOn'_sub_one (hz : z ≤ b) :
    (z - 1).inductionOn' b H0 Hs Hp = Hp z hz (z.inductionOn' b H0 Hs Hp) 
Arguments: {C : ℤ → Sort u_1} {z b : ℤ} {H0 : C b} {Hs : (k : ℤ) → b ≤ k → C k → C (k + 1)} {Hp : (k : ℤ) → k ≤ b → C k → C (k - 1)} (hz : z ≤ b)
Goal: (z - 1).inductionOn' b H0 Hs Hp = Hp z hz (z.inductionOn' b H0 Hs Hp)
-- Int.le_induction
protected lemma le_induction {P : ℤ → Prop} {m : ℤ} (h0 : P m)
    (h1 : ∀ n : ℤ, m ≤ n → P n → P (n + 1)) (n : ℤ) : m ≤ n → P n 
Arguments: {P : ℤ → Prop} {m : ℤ} (h0 : P m) (h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)) (n : ℤ)
Goal: m ≤ n → P n
-- Int.le_induction_down
protected theorem le_induction_down {P : ℤ → Prop} {m : ℤ} (h0 : P m)
    (h1 : ∀ n : ℤ, n ≤ m → P n → P (n - 1)) (n : ℤ) : n ≤ m → P n 
Arguments: {P : ℤ → Prop} {m : ℤ} (h0 : P m) (h1 : ∀ (n : ℤ), n ≤ m → P n → P (n - 1)) (n : ℤ)
Goal: n ≤ m → P n
-- Int.strongRec_of_lt
lemma strongRec_of_lt (hn : n < m) : m.strongRec lt ge n = lt n hn 
Arguments: {m n : ℤ} {P : ℤ → Sort u_1} {lt : (n : ℤ) → n < m → P n} {ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n} (hn : n < m)
Goal: Int.strongRec lt ge n = lt n hn
-- Int.strongRec_of_ge
lemma strongRec_of_ge :
    ∀ hn : m ≤ n, m.strongRec lt ge n = ge n hn fun k _ ↦ m.strongRec lt ge k 
Arguments: {m n : ℤ} {P : ℤ → Sort u_1} {lt : (n : ℤ) → n < m → P n} {ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n} (hn : m ≤ n)
Goal: Int.strongRec lt ge n = ge n hn fun k x => Int.strongRec lt ge k
-- Int.natAbs_ofNat'
@[simp] lemma natAbs_ofNat' (n : ℕ) : natAbs (ofNat n) = n 
Arguments: (n : ℕ)
Goal: (Int.ofNat n).natAbs = n
-- Int.natAbs_add_of_nonneg
lemma natAbs_add_of_nonneg : ∀ {a b : Int}, 0 ≤ a → 0 ≤ b → natAbs (a + b) = natAbs a + natAbs b
  
Arguments: {a b : ℤ}
Goal: 0 ≤ a → 0 ≤ b → (a + b).natAbs = a.natAbs + b.natAbs
-- Int.natAbs_add_of_nonpos
lemma natAbs_add_of_nonpos {a b : Int} (ha : a ≤ 0) (hb : b ≤ 0) :
    natAbs (a + b) = natAbs a + natAbs b 
Arguments: {a b : ℤ} (ha : a ≤ 0) (hb : b ≤ 0)
Goal: (a + b).natAbs = a.natAbs + b.natAbs
-- Int.natAbs_surjective
lemma natAbs_surjective : natAbs.Surjective 
Goal: Function.Surjective Int.natAbs
-- Int.natAbs_pow
lemma natAbs_pow (n : ℤ) (k : ℕ) : Int.natAbs (n ^ k) = Int.natAbs n ^ k 
Arguments: (n : ℤ) (k : ℕ)
Goal: (n ^ k).natAbs = n.natAbs ^ k
-- Int.pow_right_injective
lemma pow_right_injective (h : 1 < a.natAbs) : ((a ^ ·) : ℕ → ℤ).Injective 
Arguments: {a : ℤ} (h : 1 < a.natAbs)
Goal: Function.Injective fun x => a ^ x
-- Int.natAbs_sq
lemma natAbs_sq (x : ℤ) : (x.natAbs : ℤ) ^ 2 = x ^ 2 
Arguments: (x : ℤ)
Goal: ↑x.natAbs ^ 2 = x ^ 2
-- Int.natCast_div
@[simp, norm_cast] lemma natCast_div (m n : ℕ) : ((m / n : ℕ) : ℤ) = m / n 
Arguments: (m n : ℕ)
Goal: ↑(m / n) = ↑m / ↑n
-- Int.natCast_ediv
lemma natCast_ediv (m n : ℕ) : ((m / n : ℕ) : ℤ) = ediv m n 
Arguments: (m n : ℕ)
Goal: ↑(m / n) = (↑m).ediv ↑n
-- Int.ediv_of_neg_of_pos
lemma ediv_of_neg_of_pos {a b : ℤ} (Ha : a < 0) (Hb : 0 < b) : ediv a b = -((-a - 1) / b + 1) 
Arguments: {a b : ℤ} (Ha : a < 0) (Hb : 0 < b)
Goal: a.ediv b = -((-a - 1) / b + 1)
-- Int.natCast_mod
@[simp, norm_cast] lemma natCast_mod (m n : ℕ) : (↑(m % n) : ℤ) = ↑m % ↑n 
Arguments: (m n : ℕ)
Goal: ↑(m % n) = ↑m % ↑n
-- Int.add_emod_eq_add_mod_right
lemma add_emod_eq_add_mod_right {m n k : ℤ} (i : ℤ) (H : m % n = k % n) :
    (m + i) % n = (k + i) % n 
Arguments: {m n k : ℤ} (i : ℤ) (H : m % n = k % n)
Goal: (m + i) % n = (k + i) % n
-- Int.neg_emod_two
@[simp] lemma neg_emod_two (i : ℤ) : -i % 2 = i % 2 
Arguments: (i : ℤ)
Goal: -i % 2 = i % 2
-- Int.emod_two_eq_zero_or_one
lemma emod_two_eq_zero_or_one (n : ℤ) : n % 2 = 0 ∨ n % 2 = 1 
Arguments: (n : ℤ)
Goal: n % 2 = 0 ∨ n % 2 = 1
-- Int.mul_dvd_mul
protected lemma mul_dvd_mul : a ∣ b → c ∣ d → a * c ∣ b * d
  
Arguments: {a b c d : ℤ}
Goal: a ∣ b → c ∣ d → a * c ∣ b * d
-- Int.mul_dvd_mul_left
protected lemma mul_dvd_mul_left (a : ℤ) (h : b ∣ c) : a * b ∣ a * c 
Arguments: {b c : ℤ} (a : ℤ) (h : b ∣ c)
Goal: a * b ∣ a * c
-- Int.mul_dvd_mul_right
protected lemma mul_dvd_mul_right (a : ℤ) (h : b ∣ c) : b * a ∣ c * a 
Arguments: {b c : ℤ} (a : ℤ) (h : b ∣ c)
Goal: b * a ∣ c * a
-- Int.dvd_mul_of_div_dvd
lemma dvd_mul_of_div_dvd (h : b ∣ a) (hdiv : a / b ∣ c) : a ∣ b * c 
Arguments: {a b c : ℤ} (h : b ∣ a) (hdiv : a / b ∣ c)
Goal: a ∣ b * c
-- Int.div_dvd_iff_dvd_mul
@[simp] lemma div_dvd_iff_dvd_mul (h : b ∣ a) (hb : b ≠ 0) : a / b ∣ c ↔ a ∣ b * c 
Arguments: {a b c : ℤ} (h : b ∣ a) (hb : b ≠ 0)
Goal: a / b ∣ c ↔ a ∣ b * c
-- Int.mul_dvd_of_dvd_div
lemma mul_dvd_of_dvd_div (hcb : c ∣ b) (h : a ∣ b / c) : c * a ∣ b 
Arguments: {a b c : ℤ} (hcb : c ∣ b) (h : a ∣ b / c)
Goal: c * a ∣ b
-- Int.dvd_div_of_mul_dvd
lemma dvd_div_of_mul_dvd (h : a * b ∣ c) : b ∣ c / a 
Arguments: {a b c : ℤ} (h : a * b ∣ c)
Goal: b ∣ c / a
-- Int.dvd_div_iff_mul_dvd
@[simp] lemma dvd_div_iff_mul_dvd (hbc : c ∣ b) : a ∣ b / c ↔ c * a ∣ b 
Arguments: {a b c : ℤ} (hbc : c ∣ b)
Goal: a ∣ b / c ↔ c * a ∣ b
-- Int.ediv_dvd_ediv
lemma ediv_dvd_ediv : ∀ {a b c : ℤ}, a ∣ b → b ∣ c → b / a ∣ c / a
  
Arguments: {a b c : ℤ}
Goal: a ∣ b → b ∣ c → b / a ∣ c / a
-- Int.exists_lt_and_lt_iff_not_dvd
lemma exists_lt_and_lt_iff_not_dvd (m : ℤ) (hn : 0 < n) :
    (∃ k, n * k < m ∧ m < n * (k + 1)) ↔ ¬n ∣ m 
Arguments: {n : ℤ} (m : ℤ) (hn : 0 < n)
Goal: (∃ k, n * k < m ∧ m < n * (k + 1)) ↔ ¬n ∣ m
-- Int.natCast_dvd_natCast
@[norm_cast] lemma natCast_dvd_natCast {m n : ℕ} : (↑m : ℤ) ∣ ↑n ↔ m ∣ n 
Arguments: {m n : ℕ}
Goal: ↑m ∣ ↑n ↔ m ∣ n
-- Int.natCast_dvd
lemma natCast_dvd {m : ℕ} : (m : ℤ) ∣ n ↔ m ∣ n.natAbs 
Arguments: {n : ℤ} {m : ℕ}
Goal: ↑m ∣ n ↔ m ∣ n.natAbs
-- Int.dvd_natCast
lemma dvd_natCast {n : ℕ} : m ∣ (n : ℤ) ↔ m.natAbs ∣ n 
Arguments: {m : ℤ} {n : ℕ}
Goal: m ∣ ↑n ↔ m.natAbs ∣ n
-- Int.natAbs_ediv
lemma natAbs_ediv (a b : ℤ) (H : b ∣ a) : natAbs (a / b) = natAbs a / natAbs b 
Arguments: (a b : ℤ) (H : b ∣ a)
Goal: (a / b).natAbs = a.natAbs / b.natAbs
-- Int.dvd_of_mul_dvd_mul_left
lemma dvd_of_mul_dvd_mul_left (ha : a ≠ 0) (h : a * m ∣ a * n) : m ∣ n 
Arguments: {a m n : ℤ} (ha : a ≠ 0) (h : a * m ∣ a * n)
Goal: m ∣ n
-- Int.dvd_of_mul_dvd_mul_right
lemma dvd_of_mul_dvd_mul_right (ha : a ≠ 0) (h : m * a ∣ n * a) : m ∣ n 
Arguments: {a m n : ℤ} (ha : a ≠ 0) (h : m * a ∣ n * a)
Goal: m ∣ n
-- Int.eq_mul_div_of_mul_eq_mul_of_dvd_left
lemma eq_mul_div_of_mul_eq_mul_of_dvd_left (hb : b ≠ 0) (hbc : b ∣ c) (h : b * a = c * d) :
    a = c / b * d 
Arguments: {a b c d : ℤ} (hb : b ≠ 0) (hbc : b ∣ c) (h : b * a = c * d)
Goal: a = c / b * d
-- Int.eq_zero_of_dvd_of_natAbs_lt_natAbs
lemma eq_zero_of_dvd_of_natAbs_lt_natAbs (hmn : m ∣ n) (hnm : natAbs n < natAbs m) : n = 0 
Arguments: {m n : ℤ} (hmn : m ∣ n) (hnm : n.natAbs < m.natAbs)
Goal: n = 0
-- Int.eq_zero_of_dvd_of_nonneg_of_lt
lemma eq_zero_of_dvd_of_nonneg_of_lt (hm : 0 ≤ m) (hmn : m < n) (hnm : n ∣ m) : m = 0 
Arguments: {m n : ℤ} (hm : 0 ≤ m) (hmn : m < n) (hnm : n ∣ m)
Goal: m = 0
-- Int.eq_of_mod_eq_of_natAbs_sub_lt_natAbs
lemma eq_of_mod_eq_of_natAbs_sub_lt_natAbs {a b c : ℤ} (h1 : a % b = c)
    (h2 : natAbs (a - c) < natAbs b) : a = c 
Arguments: {a b c : ℤ} (h1 : a % b = c) (h2 : (a - c).natAbs < b.natAbs)
Goal: a = c
-- Int.ofNat_add_negSucc_of_ge
lemma ofNat_add_negSucc_of_ge {m n : ℕ} (h : n.succ ≤ m) :
    ofNat m + -[n+1] = ofNat (m - n.succ) 
Arguments: {m n : ℕ} (h : n.succ ≤ m)
Goal: Int.ofNat m + -[n+1] = Int.ofNat (m - n.succ)
-- Int.natAbs_le_of_dvd_ne_zero
lemma natAbs_le_of_dvd_ne_zero (hmn : m ∣ n) (hn : n ≠ 0) : natAbs m ≤ natAbs n 
Arguments: {m n : ℤ} (hmn : m ∣ n) (hn : n ≠ 0)
Goal: m.natAbs ≤ n.natAbs