ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.Ici_mul_Ici_subset'
@[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' [LocallyFiniteOrderTop α] (a b : α) : Ici a * Ici b ⊆ Ici (a * b) 
Arguments: {α : Type u_1} [Mul α] [Preorder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap HMul.hMul) LE.le] [LocallyFiniteOrderTop α] (a b : α)
Goal: Finset.Ici a * Finset.Ici b ⊆ Finset.Ici (a * b)
-- Finset.Ici_add_Ici_subset
@[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' [LocallyFiniteOrderTop α] (a b : α) : Ici a * Ici b ⊆ Ici (a * b) 
Arguments: {α : Type u_1} [Add α] [Preorder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LE.le] [LocallyFiniteOrderTop α] (a b : α)
Goal: Finset.Ici a + Finset.Ici b ⊆ Finset.Ici (a + b)
-- Finset.Icc_add_Ico_subset
@[to_additive Icc_add_Ico_subset]
theorem Icc_mul_Ico_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Icc a b * Ico c d ⊆ Ico (a * c) (b * d) 
Arguments: {α : Type u_1} [Add α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LT.lt] [LocallyFiniteOrder α] (a b c d : α)
Goal: Finset.Icc a b + Finset.Ico c d ⊆ Finset.Ico (a + c) (b + d)
-- Finset.Icc_mul_Ico_subset'
@[to_additive Icc_add_Ico_subset]
theorem Icc_mul_Ico_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Icc a b * Ico c d ⊆ Ico (a * c) (b * d) 
Arguments: {α : Type u_1} [Mul α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HMul.hMul) LT.lt] [LocallyFiniteOrder α] (a b c d : α)
Goal: Finset.Icc a b * Finset.Ico c d ⊆ Finset.Ico (a * c) (b * d)
-- Finset.Ico_add_Icc_subset
@[to_additive Ico_add_Icc_subset]
theorem Ico_mul_Icc_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ico a b * Icc c d ⊆ Ico (a * c) (b * d) 
Arguments: {α : Type u_1} [Add α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LT.lt] [LocallyFiniteOrder α] (a b c d : α)
Goal: Finset.Ico a b + Finset.Icc c d ⊆ Finset.Ico (a + c) (b + d)
-- Finset.Ico_mul_Icc_subset'
@[to_additive Ico_add_Icc_subset]
theorem Ico_mul_Icc_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ico a b * Icc c d ⊆ Ico (a * c) (b * d) 
Arguments: {α : Type u_1} [Mul α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HMul.hMul) LT.lt] [LocallyFiniteOrder α] (a b c d : α)
Goal: Finset.Ico a b * Finset.Icc c d ⊆ Finset.Ico (a * c) (b * d)
-- Finset.Ioc_mul_Ico_subset'
@[to_additive Ioc_add_Ico_subset]
theorem Ioc_mul_Ico_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ioc a b * Ico c d ⊆ Ioo (a * c) (b * d) 
Arguments: {α : Type u_1} [Mul α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HMul.hMul) LT.lt] [LocallyFiniteOrder α] (a b c d : α)
Goal: Finset.Ioc a b * Finset.Ico c d ⊆ Finset.Ioo (a * c) (b * d)
-- Finset.Ioc_add_Ico_subset
@[to_additive Ioc_add_Ico_subset]
theorem Ioc_mul_Ico_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ioc a b * Ico c d ⊆ Ioo (a * c) (b * d) 
Arguments: {α : Type u_1} [Add α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LT.lt] [LocallyFiniteOrder α] (a b c d : α)
Goal: Finset.Ioc a b + Finset.Ico c d ⊆ Finset.Ioo (a + c) (b + d)
-- Finset.Ico_mul_Ioc_subset'
@[to_additive Ico_add_Ioc_subset]
theorem Ico_mul_Ioc_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d) 
Arguments: {α : Type u_1} [Mul α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HMul.hMul) LT.lt] [LocallyFiniteOrder α] (a b c d : α)
Goal: Finset.Ico a b * Finset.Ioc c d ⊆ Finset.Ioo (a * c) (b * d)
-- Finset.Ico_add_Ioc_subset
@[to_additive Ico_add_Ioc_subset]
theorem Ico_mul_Ioc_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d) 
Arguments: {α : Type u_1} [Add α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LT.lt] [LocallyFiniteOrder α] (a b c d : α)
Goal: Finset.Ico a b + Finset.Ioc c d ⊆ Finset.Ioo (a + c) (b + d)
-- Finset.Iic_add_Iio_subset
@[to_additive Iic_add_Iio_subset]
theorem Iic_mul_Iio_subset' [LocallyFiniteOrderBot α] (a b : α) : Iic a * Iio b ⊆ Iio (a * b) 
Arguments: {α : Type u_1} [Add α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LT.lt] [LocallyFiniteOrderBot α] (a b : α)
Goal: Finset.Iic a + Finset.Iio b ⊆ Finset.Iio (a + b)
-- Finset.Iic_mul_Iio_subset'
@[to_additive Iic_add_Iio_subset]
theorem Iic_mul_Iio_subset' [LocallyFiniteOrderBot α] (a b : α) : Iic a * Iio b ⊆ Iio (a * b) 
Arguments: {α : Type u_1} [Mul α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HMul.hMul) LT.lt] [LocallyFiniteOrderBot α] (a b : α)
Goal: Finset.Iic a * Finset.Iio b ⊆ Finset.Iio (a * b)
-- Finset.Iio_add_Iic_subset
@[to_additive Iio_add_Iic_subset]
theorem Iio_mul_Iic_subset' [LocallyFiniteOrderBot α] (a b : α) : Iio a * Iic b ⊆ Iio (a * b) 
Arguments: {α : Type u_1} [Add α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LT.lt] [LocallyFiniteOrderBot α] (a b : α)
Goal: Finset.Iio a + Finset.Iic b ⊆ Finset.Iio (a + b)
-- Finset.Iio_mul_Iic_subset'
@[to_additive Iio_add_Iic_subset]
theorem Iio_mul_Iic_subset' [LocallyFiniteOrderBot α] (a b : α) : Iio a * Iic b ⊆ Iio (a * b) 
Arguments: {α : Type u_1} [Mul α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HMul.hMul) LT.lt] [LocallyFiniteOrderBot α] (a b : α)
Goal: Finset.Iio a * Finset.Iic b ⊆ Finset.Iio (a * b)
-- Finset.Ioi_add_Ici_subset
@[to_additive Ioi_add_Ici_subset]
theorem Ioi_mul_Ici_subset' [LocallyFiniteOrderTop α] (a b : α) : Ioi a * Ici b ⊆ Ioi (a * b) 
Arguments: {α : Type u_1} [Add α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LT.lt] [LocallyFiniteOrderTop α] (a b : α)
Goal: Finset.Ioi a + Finset.Ici b ⊆ Finset.Ioi (a + b)
-- Finset.Ioi_mul_Ici_subset'
@[to_additive Ioi_add_Ici_subset]
theorem Ioi_mul_Ici_subset' [LocallyFiniteOrderTop α] (a b : α) : Ioi a * Ici b ⊆ Ioi (a * b) 
Arguments: {α : Type u_1} [Mul α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HMul.hMul) LT.lt] [LocallyFiniteOrderTop α] (a b : α)
Goal: Finset.Ioi a * Finset.Ici b ⊆ Finset.Ioi (a * b)
-- Finset.Ici_mul_Ioi_subset'
@[to_additive Ici_add_Ioi_subset]
theorem Ici_mul_Ioi_subset' [LocallyFiniteOrderTop α] (a b : α) : Ici a * Ioi b ⊆ Ioi (a * b) 
Arguments: {α : Type u_1} [Mul α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HMul.hMul) LT.lt] [LocallyFiniteOrderTop α] (a b : α)
Goal: Finset.Ici a * Finset.Ioi b ⊆ Finset.Ioi (a * b)
-- Finset.Ici_add_Ioi_subset
@[to_additive Ici_add_Ioi_subset]
theorem Ici_mul_Ioi_subset' [LocallyFiniteOrderTop α] (a b : α) : Ici a * Ioi b ⊆ Ioi (a * b) 
Arguments: {α : Type u_1} [Add α] [PartialOrder α] [DecidableEq α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LT.lt] [LocallyFiniteOrderTop α] (a b : α)
Goal: Finset.Ici a + Finset.Ioi b ⊆ Finset.Ioi (a + b)
-- Finset.val_disjSum
@[simp]
theorem val_disjSum : (s.disjSum t).1 = s.1.disjSum t.1 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β)
Goal: (s.disjSum t).val = s.val.disjSum t.val
-- Finset.empty_disjSum
@[simp]
theorem empty_disjSum : (∅ : Finset α).disjSum t = t.map Embedding.inr 
Arguments: {α : Type u_1} {β : Type u_2} (t : Finset β)
Goal: ∅.disjSum t = Finset.map Function.Embedding.inr t
-- Finset.disjSum_empty
@[simp]
theorem disjSum_empty : s.disjSum (∅ : Finset β) = s.map Embedding.inl 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α)
Goal: s.disjSum ∅ = Finset.map Function.Embedding.inl s
-- Finset.card_disjSum
@[simp]
theorem card_disjSum : (s.disjSum t).card = s.card + t.card 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β)
Goal: (s.disjSum t).card = s.card + t.card
-- Finset.disjoint_map_inl_map_inr
theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embedding.inr) 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β)
Goal: Disjoint (Finset.map Function.Embedding.inl s) (Finset.map Function.Embedding.inr t)
-- Finset.map_inl_disjUnion_map_inr
@[simp]
theorem map_inl_disjUnion_map_inr :
    (s.map Embedding.inl).disjUnion (t.map Embedding.inr) (disjoint_map_inl_map_inr _ _) =
      s.disjSum t 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β)
Goal: (Finset.map Function.Embedding.inl s).disjUnion (Finset.map Function.Embedding.inr t) ⋯ = s.disjSum t
-- Finset.mem_disjSum
theorem mem_disjSum : x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {x : α ⊕ β}
Goal: x ∈ s.disjSum t ↔ (∃ a ∈ s, Sum.inl a = x) ∨ ∃ b ∈ t, Sum.inr b = x
-- Finset.inl_mem_disjSum
@[simp]
theorem inl_mem_disjSum : inl a ∈ s.disjSum t ↔ a ∈ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {a : α}
Goal: Sum.inl a ∈ s.disjSum t ↔ a ∈ s
-- Finset.inr_mem_disjSum
@[simp]
theorem inr_mem_disjSum : inr b ∈ s.disjSum t ↔ b ∈ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {b : β}
Goal: Sum.inr b ∈ s.disjSum t ↔ b ∈ t
-- Finset.disjSum_eq_empty
@[simp]
theorem disjSum_eq_empty : s.disjSum t = ∅ ↔ s = ∅ ∧ t = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}
Goal: s.disjSum t = ∅ ↔ s = ∅ ∧ t = ∅
-- Finset.disjSum_mono
theorem disjSum_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁.disjSum t₁ ⊆ s₂.disjSum t₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} {t₁ t₂ : Finset β} (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂)
Goal: s₁.disjSum t₁ ⊆ s₂.disjSum t₂
-- Finset.disjSum_mono_left
theorem disjSum_mono_left (t : Finset β) : Monotone fun s : Finset α => s.disjSum t 
Arguments: {α : Type u_1} {β : Type u_2} (t : Finset β)
Goal: Monotone fun s => s.disjSum t
-- Finset.disjSum_mono_right
theorem disjSum_mono_right (s : Finset α) : Monotone (s.disjSum : Finset β → Finset (α ⊕ β)) 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α)
Goal: Monotone s.disjSum
-- Finset.disjSum_ssubset_disjSum_of_ssubset_of_subset
theorem disjSum_ssubset_disjSum_of_ssubset_of_subset (hs : s₁ ⊂ s₂) (ht : t₁ ⊆ t₂) :
    s₁.disjSum t₁ ⊂ s₂.disjSum t₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} {t₁ t₂ : Finset β} (hs : s₁ ⊂ s₂) (ht : t₁ ⊆ t₂)
Goal: s₁.disjSum t₁ ⊂ s₂.disjSum t₂
-- Finset.disjSum_ssubset_disjSum_of_subset_of_ssubset
theorem disjSum_ssubset_disjSum_of_subset_of_ssubset (hs : s₁ ⊆ s₂) (ht : t₁ ⊂ t₂) :
    s₁.disjSum t₁ ⊂ s₂.disjSum t₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} {t₁ t₂ : Finset β} (hs : s₁ ⊆ s₂) (ht : t₁ ⊂ t₂)
Goal: s₁.disjSum t₁ ⊂ s₂.disjSum t₂
-- Finset.disjSum_strictMono_left
theorem disjSum_strictMono_left (t : Finset β) : StrictMono fun s : Finset α => s.disjSum t 
Arguments: {α : Type u_1} {β : Type u_2} (t : Finset β)
Goal: StrictMono fun s => s.disjSum t
-- Finset.disj_sum_strictMono_right
theorem disj_sum_strictMono_right (s : Finset α) :
    StrictMono (s.disjSum : Finset β → Finset (α ⊕ β)) 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α)
Goal: StrictMono s.disjSum
-- Finset.mem_attachFin
@[simp]
theorem mem_attachFin {n : ℕ} {s : Finset ℕ} (h : ∀ m ∈ s, m < n) {a : Fin n} :
    a ∈ s.attachFin h ↔ (a : ℕ) ∈ s 
Arguments: {n : ℕ} {s : Finset ℕ} (h : ∀ m ∈ s, m < n) {a : Fin n}
Goal: a ∈ s.attachFin h ↔ ↑a ∈ s
-- Finset.card_attachFin
@[simp]
theorem card_attachFin {n : ℕ} (s : Finset ℕ) (h : ∀ m ∈ s, m < n) :
    (s.attachFin h).card = s.card 
Arguments: {n : ℕ} (s : Finset ℕ) (h : ∀ m ∈ s, m < n)
Goal: (s.attachFin h).card = s.card
-- ZMod.unitsMap_def
lemma unitsMap_def (hm : n ∣ m) : unitsMap hm = Units.map (castHom hm (ZMod n)) 
Arguments: {n m : ℕ} (hm : n ∣ m)
Goal: ZMod.unitsMap hm = Units.map ↑(ZMod.castHom hm (ZMod n))
-- ZMod.unitsMap_comp
lemma unitsMap_comp {d : ℕ} (hm : n ∣ m) (hd : m ∣ d) :
    (unitsMap hm).comp (unitsMap hd) = unitsMap (dvd_trans hm hd) 
Arguments: {n m d : ℕ} (hm : n ∣ m) (hd : m ∣ d)
Goal: (ZMod.unitsMap hm).comp (ZMod.unitsMap hd) = ZMod.unitsMap ⋯
-- ZMod.unitsMap_self
@[simp]
lemma unitsMap_self (n : ℕ) : unitsMap (dvd_refl n) = MonoidHom.id _ 
Arguments: (n : ℕ)
Goal: ZMod.unitsMap ⋯ = MonoidHom.id (ZMod n)ˣ
-- ZMod.IsUnit_cast_of_dvd
lemma IsUnit_cast_of_dvd (hm : n ∣ m) (a : Units (ZMod m)) : IsUnit (cast (a : ZMod m) : ZMod n) 
Arguments: {n m : ℕ} (hm : n ∣ m) (a : (ZMod m)ˣ)
Goal: IsUnit (↑a).cast
-- ZMod.unitsMap_surjective
theorem unitsMap_surjective [hm : NeZero m] (h : n ∣ m) :
    Function.Surjective (unitsMap h) 
Arguments: {n m : ℕ} [hm : NeZero m] (h : n ∣ m)
Goal: Function.Surjective ⇑(ZMod.unitsMap h)
-- ZMod.not_isUnit_of_mem_primeFactors
lemma not_isUnit_of_mem_primeFactors {n p : ℕ} (h : p ∈ n.primeFactors) :
    ¬ IsUnit (p : ZMod n) 
Arguments: {n p : ℕ} (h : p ∈ n.primeFactors)
Goal: ¬IsUnit ↑p
-- ZMod.eq_unit_mul_divisor
lemma eq_unit_mul_divisor {N : ℕ} (a : ZMod N) :
    ∃ d : ℕ, d ∣ N ∧ ∃ (u : ZMod N), IsUnit u ∧ a = u * d 
Arguments: {N : ℕ} (a : ZMod N)
Goal: ∃ d, d ∣ N ∧ ∃ u, IsUnit u ∧ a = u * ↑d
-- _private.Mathlib.Data.ZMod.Defs.0.Fin.left_distrib_aux
private theorem left_distrib_aux (n : ℕ) : ∀ a b c : Fin n, a * (b + c) = a * b + a * c 
Arguments: (n : ℕ) (a b c : Fin n)
Goal: a * (b + c) = a * b + a * c
-- ZMod.card
@[simp]
theorem card (n : ℕ) [Fintype (ZMod n)] : Fintype.card (ZMod n) = n 
Arguments: (n : ℕ) [Fintype (ZMod n)]
Goal: Fintype.card (ZMod n) = n
-- Finset.mem_preimage
@[simp]
theorem mem_preimage {f : α → β} {s : Finset β} {hf : Set.InjOn f (f ⁻¹' ↑s)} {x : α} :
    x ∈ preimage s f hf ↔ f x ∈ s 
Arguments: {α : Type u} {β : Type v} {f : α → β} {s : Finset β} {hf : Set.InjOn f (f ⁻¹' ↑s)} {x : α}
Goal: x ∈ s.preimage f hf ↔ f x ∈ s
-- Finset.coe_preimage
@[simp, norm_cast]
theorem coe_preimage {f : α → β} (s : Finset β) (hf : Set.InjOn f (f ⁻¹' ↑s)) :
    (↑(preimage s f hf) : Set α) = f ⁻¹' ↑s 
Arguments: {α : Type u} {β : Type v} {f : α → β} (s : Finset β) (hf : Set.InjOn f (f ⁻¹' ↑s))
Goal: ↑(s.preimage f hf) = f ⁻¹' ↑s
-- Finset.preimage_empty
@[simp]
theorem preimage_empty {f : α → β} : preimage ∅ f (by simp [InjOn]) = ∅ 
Arguments: {α : Type u} {β : Type v} {f : α → β}
Goal: ∅.preimage f ⋯ = ∅
-- Finset.preimage_univ
@[simp]
theorem preimage_univ {f : α → β} [Fintype α] [Fintype β] (hf) : preimage univ f hf = univ 
Arguments: {α : Type u} {β : Type v} {f : α → β} [Fintype α] [Fintype β] (hf : Set.InjOn f (f ⁻¹' ↑Finset.univ))
Goal: Finset.univ.preimage f hf = Finset.univ
-- Finset.preimage_inter
@[simp]
theorem preimage_inter [DecidableEq α] [DecidableEq β] {f : α → β} {s t : Finset β}
    (hs : Set.InjOn f (f ⁻¹' ↑s)) (ht : Set.InjOn f (f ⁻¹' ↑t)) :
    (preimage (s ∩ t) f fun x₁ hx₁ x₂ hx₂ =>
        hs (mem_of_mem_inter_left hx₁) (mem_of_mem_inter_left hx₂)) =
      preimage s f hs ∩ preimage t f ht 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] {f : α → β} {s t : Finset β} (hs : Set.InjOn f (f ⁻¹' ↑s)) (ht : Set.InjOn f (f ⁻¹' ↑t))
Goal: (s ∩ t).preimage f ⋯ = s.preimage f hs ∩ t.preimage f ht
-- Finset.preimage_union
@[simp]
theorem preimage_union [DecidableEq α] [DecidableEq β] {f : α → β} {s t : Finset β} (hst) :
    preimage (s ∪ t) f hst =
      (preimage s f fun x₁ hx₁ x₂ hx₂ => hst (mem_union_left _ hx₁) (mem_union_left _ hx₂)) ∪
        preimage t f fun x₁ hx₁ x₂ hx₂ => hst (mem_union_right _ hx₁) (mem_union_right _ hx₂) 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] {f : α → β} {s t : Finset β} (hst : Set.InjOn f (f ⁻¹' ↑(s ∪ t)))
Goal: (s ∪ t).preimage f hst = s.preimage f ⋯ ∪ t.preimage f ⋯
-- Finset.preimage_compl
@[simp, nolint simpNF] -- Porting note: linter complains that LHS doesn't simplify
theorem preimage_compl [DecidableEq α] [DecidableEq β] [Fintype α] [Fintype β] {f : α → β}
    (s : Finset β) (hf : Function.Injective f) :
    preimage sᶜ f hf.injOn = (preimage s f hf.injOn)ᶜ 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] [Fintype α] [Fintype β] {f : α → β} (s : Finset β) (hf : Function.Injective f)
Goal: sᶜ.preimage f ⋯ = (s.preimage f ⋯)ᶜ
-- Finset.preimage_map
@[simp]
lemma preimage_map (f : α ↪ β) (s : Finset α) : (s.map f).preimage f f.injective.injOn = s 
Arguments: {α : Type u} {β : Type v} (f : α ↪ β) (s : Finset α)
Goal: (Finset.map f s).preimage ⇑f ⋯ = s
-- Finset.monotone_preimage
theorem monotone_preimage {f : α → β} (h : Injective f) :
    Monotone fun s => preimage s f h.injOn 
Arguments: {α : Type u} {β : Type v} {f : α → β} (h : Function.Injective f)
Goal: Monotone fun s => s.preimage f ⋯
-- Finset.image_subset_iff_subset_preimage
theorem image_subset_iff_subset_preimage [DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β}
    (hf : Set.InjOn f (f ⁻¹' ↑t)) : s.image f ⊆ t ↔ s ⊆ t.preimage f hf 
Arguments: {α : Type u} {β : Type v} [DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β} (hf : Set.InjOn f (f ⁻¹' ↑t))
Goal: Finset.image f s ⊆ t ↔ s ⊆ t.preimage f hf
-- Finset.map_subset_iff_subset_preimage
theorem map_subset_iff_subset_preimage {f : α ↪ β} {s : Finset α} {t : Finset β} :
    s.map f ⊆ t ↔ s ⊆ t.preimage f f.injective.injOn 
Arguments: {α : Type u} {β : Type v} {f : α ↪ β} {s : Finset α} {t : Finset β}
Goal: Finset.map f s ⊆ t ↔ s ⊆ t.preimage ⇑f ⋯
-- Finset.image_preimage
theorem image_preimage [DecidableEq β] (f : α → β) (s : Finset β) [∀ x, Decidable (x ∈ Set.range f)]
    (hf : Set.InjOn f (f ⁻¹' ↑s)) : image f (preimage s f hf) = s.filter fun x => x ∈ Set.range f 
Arguments: {α : Type u} {β : Type v} [DecidableEq β] (f : α → β) (s : Finset β) [(x : β) → Decidable (x ∈ Set.range f)] (hf : Set.InjOn f (f ⁻¹' ↑s))
Goal: Finset.image f (s.preimage f hf) = Finset.filter (fun x => x ∈ Set.range f) s
-- Finset.image_preimage_of_bij
theorem image_preimage_of_bij [DecidableEq β] (f : α → β) (s : Finset β)
    (hf : Set.BijOn f (f ⁻¹' ↑s) ↑s) : image f (preimage s f hf.injOn) = s 
Arguments: {α : Type u} {β : Type v} [DecidableEq β] (f : α → β) (s : Finset β) (hf : Set.BijOn f (f ⁻¹' ↑s) ↑s)
Goal: Finset.image f (s.preimage f ⋯) = s
-- Finset.preimage_subset
theorem preimage_subset {f : α ↪ β} {s : Finset β} {t : Finset α} (hs : s ⊆ t.map f) :
    s.preimage f f.injective.injOn ⊆ t 
Arguments: {α : Type u} {β : Type v} {f : α ↪ β} {s : Finset β} {t : Finset α} (hs : s ⊆ Finset.map f t)
Goal: s.preimage ⇑f ⋯ ⊆ t
-- Finset.subset_map_iff
theorem subset_map_iff {f : α ↪ β} {s : Finset β} {t : Finset α} :
    s ⊆ t.map f ↔ ∃ u ⊆ t, s = u.map f 
Arguments: {α : Type u} {β : Type v} {f : α ↪ β} {s : Finset β} {t : Finset α}
Goal: s ⊆ Finset.map f t ↔ ∃ u ⊆ t, s = Finset.map f u
-- Finset.sigma_preimage_mk
theorem sigma_preimage_mk {β : α → Type*} [DecidableEq α] (s : Finset (Σa, β a)) (t : Finset α) :
    (t.sigma fun a => s.preimage (Sigma.mk a) sigma_mk_injective.injOn) =
      s.filter fun a => a.1 ∈ t 
Arguments: {α : Type u} {β : α → Type u_1} [DecidableEq α] (s : Finset ((a : α) × β a)) (t : Finset α)
Goal: (t.sigma fun a => s.preimage (Sigma.mk a) ⋯) = Finset.filter (fun a => a.fst ∈ t) s
-- Finset.sigma_preimage_mk_of_subset
theorem sigma_preimage_mk_of_subset {β : α → Type*} [DecidableEq α] (s : Finset (Σa, β a))
    {t : Finset α} (ht : s.image Sigma.fst ⊆ t) :
    (t.sigma fun a => s.preimage (Sigma.mk a) sigma_mk_injective.injOn) = s 
Arguments: {α : Type u} {β : α → Type u_1} [DecidableEq α] (s : Finset ((a : α) × β a)) {t : Finset α} (ht : Finset.image Sigma.fst s ⊆ t)
Goal: (t.sigma fun a => s.preimage (Sigma.mk a) ⋯) = s
-- Finset.sigma_image_fst_preimage_mk
theorem sigma_image_fst_preimage_mk {β : α → Type*} [DecidableEq α] (s : Finset (Σa, β a)) :
    ((s.image Sigma.fst).sigma fun a => s.preimage (Sigma.mk a) sigma_mk_injective.injOn) =
      s 
Arguments: {α : Type u} {β : α → Type u_1} [DecidableEq α] (s : Finset ((a : α) × β a))
Goal: ((Finset.image Sigma.fst s).sigma fun a => s.preimage (Sigma.mk a) ⋯) = s
-- AddAction.zmultiplesQuotientStabilizerEquiv_symm_apply
theorem zmultiplesQuotientStabilizerEquiv_symm_apply (n : ZMod (minimalPeriod (a +ᵥ ·) b)) :
    (zmultiplesQuotientStabilizerEquiv a b).symm n =
      (cast n : ℤ) • (⟨a, mem_zmultiples a⟩ : zmultiples a) 
Arguments: {α : Type u_3} {β : Type u_4} [AddGroup α] (a : α) [AddAction α β] (b : β) (n : ZMod (Function.minimalPeriod (fun x => a +ᵥ x) b))
Goal: (AddAction.zmultiplesQuotientStabilizerEquiv a b).symm n = n.cast • ↑⟨a, ⋯⟩
-- MulAction.zpowersQuotientStabilizerEquiv_symm_apply
theorem zpowersQuotientStabilizerEquiv_symm_apply (n : ZMod (minimalPeriod (a • ·) b)) :
    (zpowersQuotientStabilizerEquiv a b).symm n = (⟨a, mem_zpowers a⟩ : zpowers a) ^ (cast n : ℤ) 
Arguments: {α : Type u_3} {β : Type u_4} [Group α] (a : α) [MulAction α β] (b : β) (n : ZMod (Function.minimalPeriod (fun x => a • x) b))
Goal: (MulAction.zpowersQuotientStabilizerEquiv a b).symm n = ↑⟨a, ⋯⟩ ^ n.cast
-- MulAction.orbitZPowersEquiv_symm_apply
@[to_additive]
theorem orbitZPowersEquiv_symm_apply (k : ZMod (minimalPeriod (a • ·) b)) :
    (orbitZPowersEquiv a b).symm k =
      (⟨a, mem_zpowers a⟩ : zpowers a) ^ (cast k : ℤ) • ⟨b, mem_orbit_self b⟩ 
Arguments: {α : Type u_3} {β : Type u_4} [Group α] (a : α) [MulAction α β] (b : β) (k : ZMod (Function.minimalPeriod (fun x => a • x) b))
Goal: (MulAction.orbitZPowersEquiv a b).symm k = ⟨a, ⋯⟩ ^ k.cast • ⟨b, ⋯⟩
-- AddAction.orbitZMultiplesEquiv_symm_apply
@[to_additive]
theorem orbitZPowersEquiv_symm_apply (k : ZMod (minimalPeriod (a • ·) b)) :
    (orbitZPowersEquiv a b).symm k =
      (⟨a, mem_zpowers a⟩ : zpowers a) ^ (cast k : ℤ) • ⟨b, mem_orbit_self b⟩ 
Arguments: {α : Type u_3} {β : Type u_4} [AddGroup α] (a : α) [AddAction α β] (b : β) (k : ZMod (Function.minimalPeriod (fun x => a +ᵥ x) b))
Goal: (AddAction.orbitZMultiplesEquiv a b).symm k = k.cast • ⟨a, ⋯⟩ +ᵥ ⟨b, ⋯⟩
-- MulAction.orbitZPowersEquiv_symm_apply'
theorem orbitZPowersEquiv_symm_apply' (k : ℤ) :
    (orbitZPowersEquiv a b).symm k =
      (⟨a, mem_zpowers a⟩ : zpowers a) ^ k • ⟨b, mem_orbit_self b⟩ 
Arguments: {α : Type u_3} {β : Type u_4} [Group α] (a : α) [MulAction α β] (b : β) (k : ℤ)
Goal: (MulAction.orbitZPowersEquiv a b).symm ↑k = ⟨a, ⋯⟩ ^ k • ⟨b, ⋯⟩
-- AddAction.orbitZMultiplesEquiv_symm_apply'
theorem _root_.AddAction.orbitZMultiplesEquiv_symm_apply' {α β : Type*} [AddGroup α] (a : α)
    [AddAction α β] (b : β) (k : ℤ) :
    (AddAction.orbitZMultiplesEquiv a b).symm k =
      k • (⟨a, mem_zmultiples a⟩ : zmultiples a) +ᵥ ⟨b, AddAction.mem_orbit_self b⟩ 
Arguments: {α : Type u_5} {β : Type u_6} [AddGroup α] (a : α) [AddAction α β] (b : β) (k : ℤ)
Goal: (AddAction.orbitZMultiplesEquiv a b).symm ↑k = k • ⟨a, ⋯⟩ +ᵥ ⟨b, ⋯⟩
-- AddAction.minimalPeriod_eq_card
@[to_additive]
theorem minimalPeriod_eq_card [Fintype (orbit (zpowers a) b)] :
    minimalPeriod (a • ·) b = Fintype.card (orbit (zpowers a) b) 
Arguments: {α : Type u_3} {β : Type u_4} [AddGroup α] (a : α) [AddAction α β] (b : β) [Fintype ↑(AddAction.orbit (↥(AddSubgroup.zmultiples a)) b)]
Goal: Function.minimalPeriod (fun x => a +ᵥ x) b = Fintype.card ↑(AddAction.orbit (↥(AddSubgroup.zmultiples a)) b)