ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.shiftLeft_coe_nat
@[simp]
theorem shiftLeft_coe_nat (m n : ℕ) : (m : ℤ) <<< (n : ℤ) = ↑(m <<< n) 
Arguments: (m n : ℕ)
Goal: ↑m <<< ↑n = ↑(m <<< n)
-- Int.shiftRight_coe_nat
@[simp]
theorem shiftRight_coe_nat (m n : ℕ) : (m : ℤ) >>> (n : ℤ) = m >>> n 
Arguments: (m n : ℕ)
Goal: ↑m >>> ↑n = ↑(m >>> n)
-- Int.shiftLeft_negSucc
@[simp]
theorem shiftLeft_negSucc (m n : ℕ) : -[m+1] <<< (n : ℤ) = -[Nat.shiftLeft' true m n+1] 
Arguments: (m n : ℕ)
Goal: Int.negSucc m <<< ↑n = Int.negSucc (Nat.shiftLeft' true m n)
-- Int.shiftRight_negSucc
@[simp]
theorem shiftRight_negSucc (m n : ℕ) : -[m+1] >>> (n : ℤ) = -[m >>> n+1] 
Arguments: (m n : ℕ)
Goal: Int.negSucc m >>> ↑n = Int.negSucc (m >>> n)
-- Int.shiftRight_add'
theorem shiftRight_add' : ∀ (m : ℤ) (n k : ℕ), m >>> (n + k : ℤ) = (m >>> (n : ℤ)) >>> (k : ℤ)
  
Arguments: (m : ℤ) (n k : ℕ)
Goal: m >>> (↑n + ↑k) = m >>> ↑n >>> ↑k
-- Int.shiftLeft_add
theorem shiftLeft_add : ∀ (m : ℤ) (n : ℕ) (k : ℤ), m <<< (n + k) = (m <<< (n : ℤ)) <<< k
  
Arguments: (m : ℤ) (n : ℕ) (k : ℤ)
Goal: m <<< (↑n + k) = m <<< ↑n <<< k
-- Int.shiftLeft_sub
theorem shiftLeft_sub (m : ℤ) (n : ℕ) (k : ℤ) : m <<< (n - k) = (m <<< (n : ℤ)) >>> k 
Arguments: (m : ℤ) (n : ℕ) (k : ℤ)
Goal: m <<< (↑n - k) = m <<< ↑n >>> k
-- Int.shiftLeft_eq_mul_pow
theorem shiftLeft_eq_mul_pow : ∀ (m : ℤ) (n : ℕ), m <<< (n : ℤ) = m * (2 ^ n : ℕ)
  
Arguments: (m : ℤ) (n : ℕ)
Goal: m <<< ↑n = m * ↑(2 ^ n)
-- Int.one_shiftLeft
theorem one_shiftLeft (n : ℕ) : 1 <<< (n : ℤ) = (2 ^ n : ℕ) 
Arguments: (n : ℕ)
Goal: 1 <<< ↑n = ↑(2 ^ n)
-- Int.zero_shiftLeft
@[simp]
theorem zero_shiftLeft : ∀ n : ℤ, 0 <<< n = 0
  
Arguments: (n : ℤ)
Goal: 0 <<< n = 0
-- Int.zero_shiftRight'
@[simp]
theorem zero_shiftRight' (n : ℤ) : 0 >>> n = 0 
Arguments: (n : ℤ)
Goal: 0 >>> n = 0
-- List.range'_one
@[simp] theorem range'_one {s step : ℕ} : range' s 1 step = [s] 
Arguments: {s step : ℕ}
Goal: List.range' s 1 step = [s]
-- List.pairwise_lt_range'
theorem pairwise_lt_range' : ∀ s n (step := 1) (_ : 0 < step := by simp),
  Pairwise (· < ·) (range' s n step)
  
Arguments: (s n : ℕ) (step : ℕ := 1)
Goal: autoParam (0 < step) _auto✝ → List.Pairwise (fun x x_1 => x < x_1) (List.range' s n step)
-- List.nodup_range'
theorem nodup_range' (s n : ℕ) (step := 1) (h : 0 < step := by simp) : Nodup (range' s n step) 
Arguments: (s n : ℕ) (step : ℕ := 1) (h : 0 < step := by simp)
Goal: (List.range' s n step).Nodup
-- List.nthLe_range'
@[simp]
theorem nthLe_range' {n m step} (i) (H : i < (range' n m step).length) :
    nthLe (range' n m step) i H = n + step * i 
Arguments: {n m step : ℕ} (i : ℕ) (H : i < (List.range' n m step).length)
Goal: (List.range' n m step).nthLe i H = n + step * i
-- List.nthLe_range'_1
theorem nthLe_range'_1 {n m} (i) (H : i < (range' n m).length) :
    nthLe (range' n m) i H = n + i 
Arguments: {n m : ℕ} (i : ℕ) (H : i < (List.range' n m).length)
Goal: (List.range' n m).nthLe i H = n + i
-- List.pairwise_lt_range
theorem pairwise_lt_range (n : ℕ) : Pairwise (· < ·) (range n) 
Arguments: (n : ℕ)
Goal: List.Pairwise (fun x x_1 => x < x_1) (List.range n)
-- List.pairwise_le_range
theorem pairwise_le_range (n : ℕ) : Pairwise (· ≤ ·) (range n) 
Arguments: (n : ℕ)
Goal: List.Pairwise (fun x x_1 => x ≤ x_1) (List.range n)
-- List.take_range
theorem take_range (m n : ℕ) : take m (range n) = range (min m n) 
Arguments: (m n : ℕ)
Goal: List.take m (List.range n) = List.range (min m n)
-- List.nodup_range
theorem nodup_range (n : ℕ) : Nodup (range n) 
Arguments: (n : ℕ)
Goal: (List.range n).Nodup
-- List.chain'_range_succ
theorem chain'_range_succ (r : ℕ → ℕ → Prop) (n : ℕ) :
    Chain' r (range n.succ) ↔ ∀ m < n, r m m.succ 
Arguments: (r : ℕ → ℕ → Prop) (n : ℕ)
Goal: List.Chain' r (List.range n.succ) ↔ ∀ m < n, r m m.succ
-- List.chain_range_succ
theorem chain_range_succ (r : ℕ → ℕ → Prop) (n a : ℕ) :
    Chain r a (range n.succ) ↔ r a 0 ∧ ∀ m < n, r m m.succ 
Arguments: (r : ℕ → ℕ → Prop) (n a : ℕ)
Goal: List.Chain r a (List.range n.succ) ↔ r a 0 ∧ ∀ m < n, r m m.succ
-- List.pairwise_gt_iota
theorem pairwise_gt_iota (n : ℕ) : Pairwise (· > ·) (iota n) 
Arguments: (n : ℕ)
Goal: List.Pairwise (fun x x_1 => x > x_1) (List.iota n)
-- List.nodup_iota
theorem nodup_iota (n : ℕ) : Nodup (iota n) 
Arguments: (n : ℕ)
Goal: (List.iota n).Nodup
-- List.finRange_zero
@[simp]
theorem finRange_zero : finRange 0 = [] 
Goal: List.finRange 0 = []
-- List.mem_finRange
@[simp]
theorem mem_finRange {n : ℕ} (a : Fin n) : a ∈ finRange n 
Arguments: {n : ℕ} (a : Fin n)
Goal: a ∈ List.finRange n
-- List.nodup_finRange
theorem nodup_finRange (n : ℕ) : (finRange n).Nodup 
Arguments: (n : ℕ)
Goal: (List.finRange n).Nodup
-- List.length_finRange
@[simp]
theorem length_finRange (n : ℕ) : (finRange n).length = n 
Arguments: (n : ℕ)
Goal: (List.finRange n).length = n
-- List.finRange_eq_nil
@[simp]
theorem finRange_eq_nil {n : ℕ} : finRange n = [] ↔ n = 0 
Arguments: {n : ℕ}
Goal: List.finRange n = [] ↔ n = 0
-- List.pairwise_lt_finRange
theorem pairwise_lt_finRange (n : ℕ) : Pairwise (· < ·) (finRange n) 
Arguments: (n : ℕ)
Goal: List.Pairwise (fun x x_1 => x < x_1) (List.finRange n)
-- List.pairwise_le_finRange
theorem pairwise_le_finRange (n : ℕ) : Pairwise (· ≤ ·) (finRange n) 
Arguments: (n : ℕ)
Goal: List.Pairwise (fun x x_1 => x ≤ x_1) (List.finRange n)
-- List.enum_eq_zip_range
theorem enum_eq_zip_range (l : List α) : l.enum = (range l.length).zip l 
Arguments: {α : Type u} (l : List α)
Goal: l.enum = (List.range l.length).zip l
-- List.unzip_enum_eq_prod
@[simp]
theorem unzip_enum_eq_prod (l : List α) : l.enum.unzip = (range l.length, l) 
Arguments: {α : Type u} (l : List α)
Goal: l.enum.unzip = (List.range l.length, l)
-- List.enumFrom_eq_zip_range'
theorem enumFrom_eq_zip_range' (l : List α) {n : ℕ} : l.enumFrom n = (range' n l.length).zip l 
Arguments: {α : Type u} (l : List α) {n : ℕ}
Goal: List.enumFrom n l = (List.range' n l.length).zip l
-- List.unzip_enumFrom_eq_prod
@[simp]
theorem unzip_enumFrom_eq_prod (l : List α) {n : ℕ} :
    (l.enumFrom n).unzip = (range' n l.length, l) 
Arguments: {α : Type u} (l : List α) {n : ℕ}
Goal: (List.enumFrom n l).unzip = (List.range' n l.length, l)
-- List.nthLe_range
@[simp]
theorem nthLe_range {n} (i) (H : i < (range n).length) : nthLe (range n) i H = i 
Arguments: {n : ℕ} (i : ℕ) (H : i < (List.range n).length)
Goal: (List.range n).nthLe i H = i
-- List.getElem_finRange
@[simp]
theorem getElem_finRange {n : ℕ} {i : ℕ} (h) :
    (finRange n)[i] = ⟨i, length_finRange n ▸ h⟩ 
Arguments: {n i : ℕ} (h : i < (List.finRange n).length)
Goal: (List.finRange n)[i] = ⟨i, ⋯⟩
-- List.get_finRange
theorem get_finRange {n : ℕ} {i : ℕ} (h) :
    (finRange n).get ⟨i, h⟩ = ⟨i, length_finRange n ▸ h⟩ 
Arguments: {n i : ℕ} (h : i < (List.finRange n).length)
Goal: (List.finRange n).get ⟨i, h⟩ = ⟨i, ⋯⟩
-- List.finRange_map_get
@[simp]
theorem finRange_map_get (l : List α) : (finRange l.length).map l.get = l 
Arguments: {α : Type u} (l : List α)
Goal: List.map l.get (List.finRange l.length) = l
-- List.nthLe_finRange
@[simp]
theorem nthLe_finRange {n : ℕ} {i : ℕ} (h) :
    (finRange n).nthLe i h = ⟨i, length_finRange n ▸ h⟩ 
Arguments: {n i : ℕ} (h : i < (List.finRange n).length)
Goal: (List.finRange n).nthLe i h = ⟨i, ⋯⟩
-- List.indexOf_finRange
@[simp] theorem indexOf_finRange {k : ℕ} (i : Fin k) : (finRange k).indexOf i = i 
Arguments: {k : ℕ} (i : Fin k)
Goal: List.indexOf i (List.finRange k) = ↑i
-- List.ranges_disjoint
theorem ranges_disjoint (l : List ℕ) :
    Pairwise Disjoint (ranges l) 
Arguments: (l : List ℕ)
Goal: List.Pairwise List.Disjoint l.ranges
-- List.ranges_length
theorem ranges_length (l : List ℕ) :
    l.ranges.map length = l 
Arguments: (l : List ℕ)
Goal: List.map List.length l.ranges = l
-- List.ranges_join'
lemma ranges_join' : ∀ l : List ℕ, l.ranges.join = range (Nat.sum l)
  
Arguments: (l : List ℕ)
Goal: l.ranges.join = List.range (Nat.sum l)
-- List.mem_mem_ranges_iff_lt_natSum
lemma mem_mem_ranges_iff_lt_natSum (l : List ℕ) {n : ℕ} :
    (∃ s ∈ l.ranges, n ∈ s) ↔ n < Nat.sum l 
Arguments: (l : List ℕ) {n : ℕ}
Goal: (∃ s ∈ l.ranges, n ∈ s) ↔ n < Nat.sum l
-- List.ranges_nodup
theorem ranges_nodup {l s : List ℕ} (hs : s ∈ ranges l) : s.Nodup 
Arguments: {l s : List ℕ} (hs : s ∈ l.ranges)
Goal: s.Nodup
-- List.injOn_insertNth_index_of_not_mem
theorem injOn_insertNth_index_of_not_mem (l : List α) (x : α) (hx : x ∉ l) :
    Set.InjOn (fun k => insertNth k x l) { n | n ≤ l.length } 
Arguments: {α : Type u_1} (l : List α) (x : α) (hx : x ∉ l)
Goal: Set.InjOn (fun k => List.insertNth k x l) {n | n ≤ l.length}
-- List.foldr_range_subset_of_range_subset
theorem foldr_range_subset_of_range_subset {f : β → α → α} {g : γ → α → α}
    (hfg : Set.range f ⊆ Set.range g) (a : α) : Set.range (foldr f a) ⊆ Set.range (foldr g a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → α → α} {g : γ → α → α} (hfg : Set.range f ⊆ Set.range g) (a : α)
Goal: Set.range (List.foldr f a) ⊆ Set.range (List.foldr g a)
-- List.foldl_range_subset_of_range_subset
theorem foldl_range_subset_of_range_subset {f : α → β → α} {g : α → γ → α}
    (hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b) (a : α) :
    Set.range (foldl f a) ⊆ Set.range (foldl g a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → α} {g : α → γ → α} (hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b) (a : α)
Goal: Set.range (List.foldl f a) ⊆ Set.range (List.foldl g a)
-- List.foldr_range_eq_of_range_eq
theorem foldr_range_eq_of_range_eq {f : β → α → α} {g : γ → α → α} (hfg : Set.range f = Set.range g)
    (a : α) : Set.range (foldr f a) = Set.range (foldr g a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → α → α} {g : γ → α → α} (hfg : Set.range f = Set.range g) (a : α)
Goal: Set.range (List.foldr f a) = Set.range (List.foldr g a)
-- List.foldl_range_eq_of_range_eq
theorem foldl_range_eq_of_range_eq {f : α → β → α} {g : α → γ → α}
    (hfg : (Set.range fun a c => f c a) = Set.range fun b c => g c b) (a : α) :
    Set.range (foldl f a) = Set.range (foldl g a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → α} {g : α → γ → α} (hfg : (Set.range fun a c => f c a) = Set.range fun b c => g c b) (a : α)
Goal: Set.range (List.foldl f a) = Set.range (List.foldl g a)
-- List.mapAccumr_eq_foldr
theorem mapAccumr_eq_foldr {σ : Type*} (f : α → σ → σ × β) : ∀ (as : List α) (s : σ),
    mapAccumr f as s = List.foldr (fun a s =>
                                    let r := f a s.1
                                    (r.1, r.2 :: s.2)
                                  ) (s, []) as
  
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} (f : α → σ → σ × β) (as : List α) (s : σ)
Goal: List.mapAccumr f as s =
  List.foldr
    (fun a s =>
      let r := f a s.1;
      (r.1, r.2 :: s.2))
    (s, []) as
-- List.mapAccumr₂_eq_foldr
theorem mapAccumr₂_eq_foldr {σ φ : Type*} (f : α → β → σ → σ × φ) :
    ∀ (as : List α) (bs : List β) (s : σ),
    mapAccumr₂ f as bs s = foldr (fun ab s =>
                              let r := f ab.1 ab.2 s.1
                              (r.1, r.2 :: s.2)
                            ) (s, []) (as.zip bs)
  
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} {φ : Type u_5} (f : α → β → σ → σ × φ) (as : List α) (bs : List β) (s : σ)
Goal: List.mapAccumr₂ f as bs s =
  List.foldr
    (fun ab s =>
      let r := f ab.1 ab.2 s.1;
      (r.1, r.2 :: s.2))
    (s, []) (as.zip bs)
-- List.Mem.duplicate_cons_self
theorem Mem.duplicate_cons_self (h : x ∈ l) : x ∈+ x :: l 
Arguments: {α : Type u_1} {l : List α} {x : α} (h : x ∈ l)
Goal: List.Duplicate x (x :: l)
-- List.Duplicate.duplicate_cons
theorem Duplicate.duplicate_cons (h : x ∈+ l) (y : α) : x ∈+ y :: l 
Arguments: {α : Type u_1} {l : List α} {x : α} (h : List.Duplicate x l) (y : α)
Goal: List.Duplicate x (y :: l)
-- List.Duplicate.mem
theorem Duplicate.mem (h : x ∈+ l) : x ∈ l 
Arguments: {α : Type u_1} {l : List α} {x : α} (h : List.Duplicate x l)
Goal: x ∈ l
-- List.Duplicate.mem_cons_self
theorem Duplicate.mem_cons_self (h : x ∈+ x :: l) : x ∈ l 
Arguments: {α : Type u_1} {l : List α} {x : α} (h : List.Duplicate x (x :: l))
Goal: x ∈ l
-- List.duplicate_cons_self_iff
@[simp]
theorem duplicate_cons_self_iff : x ∈+ x :: l ↔ x ∈ l 
Arguments: {α : Type u_1} {l : List α} {x : α}
Goal: List.Duplicate x (x :: l) ↔ x ∈ l
-- List.Duplicate.ne_nil
theorem Duplicate.ne_nil (h : x ∈+ l) : l ≠ [] 
Arguments: {α : Type u_1} {l : List α} {x : α} (h : List.Duplicate x l)
Goal: l ≠ []
-- List.not_duplicate_nil
@[simp]
theorem not_duplicate_nil (x : α) : ¬x ∈+ [] 
Arguments: {α : Type u_1} (x : α)
Goal: ¬List.Duplicate x []
-- List.Duplicate.ne_singleton
theorem Duplicate.ne_singleton (h : x ∈+ l) (y : α) : l ≠ [y] 
Arguments: {α : Type u_1} {l : List α} {x : α} (h : List.Duplicate x l) (y : α)
Goal: l ≠ [y]
-- List.not_duplicate_singleton
@[simp]
theorem not_duplicate_singleton (x y : α) : ¬x ∈+ [y] 
Arguments: {α : Type u_1} (x y : α)
Goal: ¬List.Duplicate x [y]
-- List.Duplicate.elim_nil
theorem Duplicate.elim_nil (h : x ∈+ []) : False 
Arguments: {α : Type u_1} {x : α} (h : List.Duplicate x [])
Goal: False
-- List.Duplicate.elim_singleton
theorem Duplicate.elim_singleton {y : α} (h : x ∈+ [y]) : False 
Arguments: {α : Type u_1} {x y : α} (h : List.Duplicate x [y])
Goal: False
-- List.duplicate_cons_iff
theorem duplicate_cons_iff {y : α} : x ∈+ y :: l ↔ y = x ∧ x ∈ l ∨ x ∈+ l 
Arguments: {α : Type u_1} {l : List α} {x y : α}
Goal: List.Duplicate x (y :: l) ↔ y = x ∧ x ∈ l ∨ List.Duplicate x l
-- List.Duplicate.of_duplicate_cons
theorem Duplicate.of_duplicate_cons {y : α} (h : x ∈+ y :: l) (hx : x ≠ y) : x ∈+ l 
Arguments: {α : Type u_1} {l : List α} {x y : α} (h : List.Duplicate x (y :: l)) (hx : x ≠ y)
Goal: List.Duplicate x l
-- List.duplicate_cons_iff_of_ne
theorem duplicate_cons_iff_of_ne {y : α} (hne : x ≠ y) : x ∈+ y :: l ↔ x ∈+ l 
Arguments: {α : Type u_1} {l : List α} {x y : α} (hne : x ≠ y)
Goal: List.Duplicate x (y :: l) ↔ List.Duplicate x l
-- List.Duplicate.mono_sublist
theorem Duplicate.mono_sublist {l' : List α} (hx : x ∈+ l) (h : l <+ l') : x ∈+ l' 
Arguments: {α : Type u_1} {l : List α} {x : α} {l' : List α} (hx : List.Duplicate x l) (h : l.Sublist l')
Goal: List.Duplicate x l'
-- List.duplicate_iff_sublist
theorem duplicate_iff_sublist : x ∈+ l ↔ [x, x] <+ l 
Arguments: {α : Type u_1} {l : List α} {x : α}
Goal: List.Duplicate x l ↔ [x, x].Sublist l
-- List.nodup_iff_forall_not_duplicate
theorem nodup_iff_forall_not_duplicate : Nodup l ↔ ∀ x : α, ¬x ∈+ l 
Arguments: {α : Type u_1} {l : List α}
Goal: l.Nodup ↔ ∀ (x : α), ¬List.Duplicate x l
-- List.exists_duplicate_iff_not_nodup
theorem exists_duplicate_iff_not_nodup : (∃ x : α, x ∈+ l) ↔ ¬Nodup l 
Arguments: {α : Type u_1} {l : List α}
Goal: (∃ x, List.Duplicate x l) ↔ ¬l.Nodup
-- List.Duplicate.not_nodup
theorem Duplicate.not_nodup (h : x ∈+ l) : ¬Nodup l 
Arguments: {α : Type u_1} {l : List α} {x : α} (h : List.Duplicate x l)
Goal: ¬l.Nodup
-- List.duplicate_iff_two_le_count
theorem duplicate_iff_two_le_count [DecidableEq α] : x ∈+ l ↔ 2 ≤ count x l 
Arguments: {α : Type u_1} {l : List α} {x : α} [DecidableEq α]
Goal: List.Duplicate x l ↔ 2 ≤ List.count x l
-- Int.Icc_eq_finset_map
theorem Icc_eq_finset_map :
    Icc a b =
      (Finset.range (b + 1 - a).toNat).map (Nat.castEmbedding.trans <| addLeftEmbedding a) 
Arguments: (a b : ℤ)
Goal: Finset.Icc a b = Finset.map (Nat.castEmbedding.trans (addLeftEmbedding a)) (Finset.range (b + 1 - a).toNat)
-- Int.Ico_eq_finset_map
theorem Ico_eq_finset_map :
    Ico a b = (Finset.range (b - a).toNat).map (Nat.castEmbedding.trans <| addLeftEmbedding a) 
Arguments: (a b : ℤ)
Goal: Finset.Ico a b = Finset.map (Nat.castEmbedding.trans (addLeftEmbedding a)) (Finset.range (b - a).toNat)
-- Int.Ioc_eq_finset_map
theorem Ioc_eq_finset_map :
    Ioc a b =
      (Finset.range (b - a).toNat).map (Nat.castEmbedding.trans <| addLeftEmbedding (a + 1)) 
Arguments: (a b : ℤ)
Goal: Finset.Ioc a b = Finset.map (Nat.castEmbedding.trans (addLeftEmbedding (a + 1))) (Finset.range (b - a).toNat)
-- Int.Ioo_eq_finset_map
theorem Ioo_eq_finset_map :
    Ioo a b =
      (Finset.range (b - a - 1).toNat).map (Nat.castEmbedding.trans <| addLeftEmbedding (a + 1)) 
Arguments: (a b : ℤ)
Goal: Finset.Ioo a b = Finset.map (Nat.castEmbedding.trans (addLeftEmbedding (a + 1))) (Finset.range (b - a - 1).toNat)
-- Int.uIcc_eq_finset_map
theorem uIcc_eq_finset_map :
    uIcc a b = (range (max a b + 1 - min a b).toNat).map
      (Nat.castEmbedding.trans <| addLeftEmbedding <| min a b) 
Arguments: (a b : ℤ)
Goal: Finset.uIcc a b =
  Finset.map (Nat.castEmbedding.trans (addLeftEmbedding (min a b))) (Finset.range (max a b + 1 - min a b).toNat)
-- Int.card_Icc
@[simp]
theorem card_Icc : (Icc a b).card = (b + 1 - a).toNat 
Arguments: (a b : ℤ)
Goal: (Finset.Icc a b).card = (b + 1 - a).toNat
-- Int.card_Ico
@[simp]
theorem card_Ico : (Ico a b).card = (b - a).toNat 
Arguments: (a b : ℤ)
Goal: (Finset.Ico a b).card = (b - a).toNat
-- Int.card_Ioc
@[simp]
theorem card_Ioc : (Ioc a b).card = (b - a).toNat 
Arguments: (a b : ℤ)
Goal: (Finset.Ioc a b).card = (b - a).toNat
-- Int.card_Ioo
@[simp]
theorem card_Ioo : (Ioo a b).card = (b - a - 1).toNat 
Arguments: (a b : ℤ)
Goal: (Finset.Ioo a b).card = (b - a - 1).toNat
-- Int.card_uIcc
@[simp]
theorem card_uIcc : (uIcc a b).card = (b - a).natAbs + 1 
Arguments: (a b : ℤ)
Goal: (Finset.uIcc a b).card = (b - a).natAbs + 1
-- Int.card_Icc_of_le
theorem card_Icc_of_le (h : a ≤ b + 1) : ((Icc a b).card : ℤ) = b + 1 - a 
Arguments: (a b : ℤ) (h : a ≤ b + 1)
Goal: ↑(Finset.Icc a b).card = b + 1 - a
-- Int.card_Ico_of_le
theorem card_Ico_of_le (h : a ≤ b) : ((Ico a b).card : ℤ) = b - a 
Arguments: (a b : ℤ) (h : a ≤ b)
Goal: ↑(Finset.Ico a b).card = b - a
-- Int.card_Ioc_of_le
theorem card_Ioc_of_le (h : a ≤ b) : ((Ioc a b).card : ℤ) = b - a 
Arguments: (a b : ℤ) (h : a ≤ b)
Goal: ↑(Finset.Ioc a b).card = b - a
-- Int.card_Ioo_of_lt
theorem card_Ioo_of_lt (h : a < b) : ((Ioo a b).card : ℤ) = b - a - 1 
Arguments: (a b : ℤ) (h : a < b)
Goal: ↑(Finset.Ioo a b).card = b - a - 1
-- Int.card_fintype_Icc
theorem card_fintype_Icc : Fintype.card (Set.Icc a b) = (b + 1 - a).toNat 
Arguments: (a b : ℤ)
Goal: Fintype.card ↑(Set.Icc a b) = (b + 1 - a).toNat
-- Int.card_fintype_Ico
theorem card_fintype_Ico : Fintype.card (Set.Ico a b) = (b - a).toNat 
Arguments: (a b : ℤ)
Goal: Fintype.card ↑(Set.Ico a b) = (b - a).toNat
-- Int.card_fintype_Ioc
theorem card_fintype_Ioc : Fintype.card (Set.Ioc a b) = (b - a).toNat 
Arguments: (a b : ℤ)
Goal: Fintype.card ↑(Set.Ioc a b) = (b - a).toNat
-- Int.card_fintype_Ioo
theorem card_fintype_Ioo : Fintype.card (Set.Ioo a b) = (b - a - 1).toNat 
Arguments: (a b : ℤ)
Goal: Fintype.card ↑(Set.Ioo a b) = (b - a - 1).toNat
-- Int.card_fintype_uIcc
theorem card_fintype_uIcc : Fintype.card (Set.uIcc a b) = (b - a).natAbs + 1 
Arguments: (a b : ℤ)
Goal: Fintype.card ↑(Set.uIcc a b) = (b - a).natAbs + 1
-- Int.card_fintype_Icc_of_le
theorem card_fintype_Icc_of_le (h : a ≤ b + 1) : (Fintype.card (Set.Icc a b) : ℤ) = b + 1 - a 
Arguments: (a b : ℤ) (h : a ≤ b + 1)
Goal: ↑(Fintype.card ↑(Set.Icc a b)) = b + 1 - a
-- Int.card_fintype_Ico_of_le
theorem card_fintype_Ico_of_le (h : a ≤ b) : (Fintype.card (Set.Ico a b) : ℤ) = b - a 
Arguments: (a b : ℤ) (h : a ≤ b)
Goal: ↑(Fintype.card ↑(Set.Ico a b)) = b - a
-- Int.card_fintype_Ioc_of_le
theorem card_fintype_Ioc_of_le (h : a ≤ b) : (Fintype.card (Set.Ioc a b) : ℤ) = b - a 
Arguments: (a b : ℤ) (h : a ≤ b)
Goal: ↑(Fintype.card ↑(Set.Ioc a b)) = b - a
-- Int.card_fintype_Ioo_of_lt
theorem card_fintype_Ioo_of_lt (h : a < b) : (Fintype.card (Set.Ioo a b) : ℤ) = b - a - 1 
Arguments: (a b : ℤ) (h : a < b)
Goal: ↑(Fintype.card ↑(Set.Ioo a b)) = b - a - 1
-- Int.image_Ico_emod
theorem image_Ico_emod (n a : ℤ) (h : 0 ≤ a) : (Ico n (n + a)).image (· % a) = Ico 0 a 
Arguments: (n a : ℤ) (h : 0 ≤ a)
Goal: Finset.image (fun x => x % a) (Finset.Ico n (n + a)) = Finset.Ico 0 a
-- Int.ModEq.refl
@[refl, simp]
protected theorem refl (a : ℤ) : a ≡ a [ZMOD n] 
Arguments: {n : ℤ} (a : ℤ)
Goal: a ≡ a [ZMOD n]
-- Int.ModEq.rfl
protected theorem rfl : a ≡ a [ZMOD n] 
Arguments: {n a : ℤ}
Goal: a ≡ a [ZMOD n]
-- Int.ModEq.symm
@[symm]
protected theorem symm : a ≡ b [ZMOD n] → b ≡ a [ZMOD n] 
Arguments: {n a b : ℤ}
Goal: a ≡ b [ZMOD n] → b ≡ a [ZMOD n]
-- Int.ModEq.trans
@[trans]
protected theorem trans : a ≡ b [ZMOD n] → b ≡ c [ZMOD n] → a ≡ c [ZMOD n] 
Arguments: {n a b c : ℤ}
Goal: a ≡ b [ZMOD n] → b ≡ c [ZMOD n] → a ≡ c [ZMOD n]
-- Int.ModEq.eq
protected theorem eq : a ≡ b [ZMOD n] → a % n = b % n 
Arguments: {n a b : ℤ}
Goal: a ≡ b [ZMOD n] → a % n = b % n
-- Int.modEq_comm
theorem modEq_comm : a ≡ b [ZMOD n] ↔ b ≡ a [ZMOD n] 
Arguments: {n a b : ℤ}
Goal: a ≡ b [ZMOD n] ↔ b ≡ a [ZMOD n]
-- Int.natCast_modEq_iff
theorem natCast_modEq_iff {a b n : ℕ} : a ≡ b [ZMOD n] ↔ a ≡ b [MOD n] 
Arguments: {a b n : ℕ}
Goal: ↑a ≡ ↑b [ZMOD ↑n] ↔ a ≡ b [MOD n]
-- Int.modEq_zero_iff_dvd
theorem modEq_zero_iff_dvd : a ≡ 0 [ZMOD n] ↔ n ∣ a 
Arguments: {n a : ℤ}
Goal: a ≡ 0 [ZMOD n] ↔ n ∣ a
-- Dvd.dvd.modEq_zero_int
theorem _root_.Dvd.dvd.modEq_zero_int (h : n ∣ a) : a ≡ 0 [ZMOD n] 
Arguments: {n a : ℤ} (h : n ∣ a)
Goal: a ≡ 0 [ZMOD n]
-- Dvd.dvd.zero_modEq_int
theorem _root_.Dvd.dvd.zero_modEq_int (h : n ∣ a) : 0 ≡ a [ZMOD n] 
Arguments: {n a : ℤ} (h : n ∣ a)
Goal: 0 ≡ a [ZMOD n]
-- Int.modEq_iff_dvd
theorem modEq_iff_dvd : a ≡ b [ZMOD n] ↔ n ∣ b - a 
Arguments: {n a b : ℤ}
Goal: a ≡ b [ZMOD n] ↔ n ∣ b - a
-- Int.modEq_iff_add_fac
theorem modEq_iff_add_fac {a b n : ℤ} : a ≡ b [ZMOD n] ↔ ∃ t, b = a + n * t 
Arguments: {a b n : ℤ}
Goal: a ≡ b [ZMOD n] ↔ ∃ t, b = a + n * t
-- Int.mod_modEq
theorem mod_modEq (a n) : a % n ≡ a [ZMOD n] 
Arguments: (a n : ℤ)
Goal: a % n ≡ a [ZMOD n]
-- Int.neg_modEq_neg
@[simp]
theorem neg_modEq_neg : -a ≡ -b [ZMOD n] ↔ a ≡ b [ZMOD n] 
Arguments: {n a b : ℤ}
Goal: -a ≡ -b [ZMOD n] ↔ a ≡ b [ZMOD n]
-- Int.modEq_neg
@[simp]
theorem modEq_neg : a ≡ b [ZMOD -n] ↔ a ≡ b [ZMOD n] 
Arguments: {n a b : ℤ}
Goal: a ≡ b [ZMOD -n] ↔ a ≡ b [ZMOD n]
-- Int.ModEq.of_dvd
protected theorem of_dvd (d : m ∣ n) (h : a ≡ b [ZMOD n]) : a ≡ b [ZMOD m] 
Arguments: {m n a b : ℤ} (d : m ∣ n) (h : a ≡ b [ZMOD n])
Goal: a ≡ b [ZMOD m]
-- Int.ModEq.mul_left'
protected theorem mul_left' (h : a ≡ b [ZMOD n]) : c * a ≡ c * b [ZMOD c * n] 
Arguments: {n a b c : ℤ} (h : a ≡ b [ZMOD n])
Goal: c * a ≡ c * b [ZMOD c * n]
-- Int.ModEq.mul_right'
protected theorem mul_right' (h : a ≡ b [ZMOD n]) : a * c ≡ b * c [ZMOD n * c] 
Arguments: {n a b c : ℤ} (h : a ≡ b [ZMOD n])
Goal: a * c ≡ b * c [ZMOD n * c]
-- Int.ModEq.add
@[gcongr]
protected theorem add (h₁ : a ≡ b [ZMOD n]) (h₂ : c ≡ d [ZMOD n]) : a + c ≡ b + d [ZMOD n] 
Arguments: {n a b c d : ℤ} (h₁ : a ≡ b [ZMOD n]) (h₂ : c ≡ d [ZMOD n])
Goal: a + c ≡ b + d [ZMOD n]
-- Int.ModEq.add_left
@[gcongr] protected theorem add_left (c : ℤ) (h : a ≡ b [ZMOD n]) : c + a ≡ c + b [ZMOD n] 
Arguments: {n a b : ℤ} (c : ℤ) (h : a ≡ b [ZMOD n])
Goal: c + a ≡ c + b [ZMOD n]
-- Int.ModEq.add_right
@[gcongr] protected theorem add_right (c : ℤ) (h : a ≡ b [ZMOD n]) : a + c ≡ b + c [ZMOD n] 
Arguments: {n a b : ℤ} (c : ℤ) (h : a ≡ b [ZMOD n])
Goal: a + c ≡ b + c [ZMOD n]
-- Int.ModEq.add_left_cancel
protected theorem add_left_cancel (h₁ : a ≡ b [ZMOD n]) (h₂ : a + c ≡ b + d [ZMOD n]) :
    c ≡ d [ZMOD n] 
Arguments: {n a b c d : ℤ} (h₁ : a ≡ b [ZMOD n]) (h₂ : a + c ≡ b + d [ZMOD n])
Goal: c ≡ d [ZMOD n]
-- Int.ModEq.add_left_cancel'
protected theorem add_left_cancel' (c : ℤ) (h : c + a ≡ c + b [ZMOD n]) : a ≡ b [ZMOD n] 
Arguments: {n a b : ℤ} (c : ℤ) (h : c + a ≡ c + b [ZMOD n])
Goal: a ≡ b [ZMOD n]
-- Int.ModEq.add_right_cancel
protected theorem add_right_cancel (h₁ : c ≡ d [ZMOD n]) (h₂ : a + c ≡ b + d [ZMOD n]) :
    a ≡ b [ZMOD n] 
Arguments: {n a b c d : ℤ} (h₁ : c ≡ d [ZMOD n]) (h₂ : a + c ≡ b + d [ZMOD n])
Goal: a ≡ b [ZMOD n]
-- Int.ModEq.add_right_cancel'
protected theorem add_right_cancel' (c : ℤ) (h : a + c ≡ b + c [ZMOD n]) : a ≡ b [ZMOD n] 
Arguments: {n a b : ℤ} (c : ℤ) (h : a + c ≡ b + c [ZMOD n])
Goal: a ≡ b [ZMOD n]
-- Int.ModEq.neg
@[gcongr] protected theorem neg (h : a ≡ b [ZMOD n]) : -a ≡ -b [ZMOD n] 
Arguments: {n a b : ℤ} (h : a ≡ b [ZMOD n])
Goal: -a ≡ -b [ZMOD n]