tasksource/leandojo huggingface dataset:
Theorem: Filter.HasBasis.uniformEquicontinuous_iff
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [uniformEquicontinuous_iff_uniformContinuous, UniformContinuous,
  hβ.tendsto_iff (UniformFun.hasBasis_uniformity_of_basis ι α hα)]
state_before: ι : Type u_5
κ : Type ?u.127632
X : Type ?u.127635
Y : Type ?u.127638
Z : Type ?u.127641
α : Type u_4
β : Type u_3
γ : Type ?u.127650
𝓕 : Type ?u.127653
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ₁ : Type u_1
κ₂ : Type u_2
p₁ : κ₁ → Prop
s₁ : κ₁ → Set (β × β)
p₂ : κ₂ → Prop
s₂ : κ₂ → Set (α × α)
F : ι → β → α
hβ : HasBasis (𝓤 β) p₁ s₁
hα : HasBasis (𝓤 α) p₂ s₂
⊢ UniformEquicontinuous F ↔
    ∀ (k₂ : κ₂), p₂ k₂ → ∃ k₁, p₁ k₁ ∧ ∀ (x y : β), (x, y) ∈ s₁ k₁ → ∀ (i : ι), (F i x, F i y) ∈ s₂ k₂

tactic: simp only [Prod.forall, Function.comp_apply, mem_setOf_eq, exists_prop]
state_before: ι : Type u_5
κ : Type ?u.127632
X : Type ?u.127635
Y : Type ?u.127638
Z : Type ?u.127641
α : Type u_4
β : Type u_3
γ : Type ?u.127650
𝓕 : Type ?u.127653
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ₁ : Type u_1
κ₂ : Type u_2
p₁ : κ₁ → Prop
s₁ : κ₁ → Set (β × β)
p₂ : κ₂ → Prop
s₂ : κ₂ → Set (α × α)
F : ι → β → α
hβ : HasBasis (𝓤 β) p₁ s₁
hα : HasBasis (𝓤 α) p₂ s₂
⊢ (∀ (ib : κ₂),
      p₂ ib →
        ∃ ia,
          p₁ ia ∧
            ∀ (x : β × β),
              x ∈ s₁ ia →
                ((↑UniformFun.ofFun ∘ Function.swap F) x.fst, (↑UniformFun.ofFun ∘ Function.swap F) x.snd) ∈
                  (UniformFun.gen ι α ∘ s₂) ib) ↔
    ∀ (k₂ : κ₂), p₂ k₂ → ∃ k₁, p₁ k₁ ∧ ∀ (x y : β), (x, y) ∈ s₁ k₁ → ∀ (i : ι), (F i x, F i y) ∈ s₂ k₂

tactic: rfl
state_before: ι : Type u_5
κ : Type ?u.127632
X : Type ?u.127635
Y : Type ?u.127638
Z : Type ?u.127641
α : Type u_4
β : Type u_3
γ : Type ?u.127650
𝓕 : Type ?u.127653
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ₁ : Type u_1
κ₂ : Type u_2
p₁ : κ₁ → Prop
s₁ : κ₁ → Set (β × β)
p₂ : κ₂ → Prop
s₂ : κ₂ → Set (α × α)
F : ι → β → α
hβ : HasBasis (𝓤 β) p₁ s₁
hα : HasBasis (𝓤 α) p₂ s₂
⊢ (∀ (ib : κ₂),
      p₂ ib →
        ∃ ia,
          p₁ ia ∧
            ∀ (a b : β),
              (a, b) ∈ s₁ ia →
                (↑UniformFun.ofFun (Function.swap F a), ↑UniformFun.ofFun (Function.swap F b)) ∈
                  UniformFun.gen ι α (s₂ ib)) ↔
    ∀ (k₂ : κ₂), p₂ k₂ → ∃ k₁, p₁ k₁ ∧ ∀ (x y : β), (x, y) ∈ s₁ k₁ → ∀ (i : ι), (F i x, F i y) ∈ s₂ k₂
Theorem: Fin.val_add_one_of_lt
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n✝ m n : ℕ
i : Fin (Nat.succ n)
h : i < last n
⊢ ↑(i + 1) = ↑i + 1

tactic: rw [Fin.val_add, Fin.val_one, Nat.mod_eq_of_lt (Nat.succ_lt_succ _)]
state_before: case succ
n m n✝ : ℕ
i : Fin (Nat.succ (Nat.succ n✝))
h : i < last (Nat.succ n✝)
⊢ ↑(i + 1) = ↑i + 1

tactic: exact h
state_before: n m n✝ : ℕ
i : Fin (Nat.succ (Nat.succ n✝))
h : i < last (Nat.succ n✝)
⊢ ↑i < n✝ + 1

tactic: cases h
state_before: case zero
n m : ℕ
i : Fin (Nat.succ zero)
h : i < last zero
⊢ ↑(i + 1) = ↑i + 1
Theorem: List.Chain.imp'
File: Std/Data/List/Lemmas.lean

tactic: constructor
state_before: case nil
α : Type u_1
R S : α → α → Prop
HRS : ∀ ⦃a b : α⦄, R a b → S a b
a : α
l : List α
a✝ b : α
Hab : ∀ ⦃c : α⦄, R a✝ c → S b c
⊢ Chain S b []

tactic: constructor
state_before: case cons
α : Type u_1
R S : α → α → Prop
HRS : ∀ ⦃a b : α⦄, R a b → S a b
a : α
l : List α
a✝¹ b✝ : α
l✝ : List α
r : R a✝¹ b✝
a✝ : Chain R b✝ l✝
ih : ∀ {b : α}, (∀ ⦃c : α⦄, R b✝ c → S b c) → Chain S b l✝
b : α
Hab : ∀ ⦃c : α⦄, R a✝¹ c → S b c
⊢ Chain S b (b✝ :: l✝)

tactic: exact Hab r
state_before: case cons.a
α : Type u_1
R S : α → α → Prop
HRS : ∀ ⦃a b : α⦄, R a b → S a b
a : α
l : List α
a✝¹ b✝ : α
l✝ : List α
r : R a✝¹ b✝
a✝ : Chain R b✝ l✝
ih : ∀ {b : α}, (∀ ⦃c : α⦄, R b✝ c → S b c) → Chain S b l✝
b : α
Hab : ∀ ⦃c : α⦄, R a✝¹ c → S b c
⊢ S b b✝

tactic: exact ih (@HRS _)
state_before: case cons.a
α : Type u_1
R S : α → α → Prop
HRS : ∀ ⦃a b : α⦄, R a b → S a b
a : α
l : List α
a✝¹ b✝ : α
l✝ : List α
r : R a✝¹ b✝
a✝ : Chain R b✝ l✝
ih : ∀ {b : α}, (∀ ⦃c : α⦄, R b✝ c → S b c) → Chain S b l✝
b : α
Hab : ∀ ⦃c : α⦄, R a✝¹ c → S b c
⊢ Chain S b✝ l✝
Theorem: CategoryTheory.Limits.Types.FilteredColimit.colimit_eq_iff_aux
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: change Quot.mk _ _ = Quot.mk _ _ ↔ _
state_before: J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ TypeMax
inst✝ : IsFilteredOrEmpty J
i j : J
xi : F.obj i
xj : F.obj j
⊢ (colimitCocone F).ι.app i xi = (colimitCocone F).ι.app j xj ↔
    FilteredColimit.Rel F { fst := i, snd := xi } { fst := j, snd := xj }

tactic: rw [Quot.eq, FilteredColimit.rel_eq_eqvGen_quot_rel]
state_before: J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ TypeMax
inst✝ : IsFilteredOrEmpty J
i j : J
xi : F.obj i
xj : F.obj j
⊢ Quot.mk (Quot.Rel F) { fst := i, snd := xi } = Quot.mk (Quot.Rel F) { fst := j, snd := xj } ↔
    FilteredColimit.Rel F { fst := i, snd := xi } { fst := j, snd := xj }
Theorem: hnot_hnot_sup_distrib
File: Mathlib/Order/Heyting/Basic.lean

tactic: refine' ((hnot_inf_distrib _ _).ge.trans <| hnot_anti le_hnot_inf_hnot).antisymm' _
state_before: ι : Type ?u.178832
α : Type u_1
β : Type ?u.178838
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢(a ⊔ b) = ￢￢a ⊔ ￢￢b

tactic: rw [hnot_le_iff_codisjoint_left, codisjoint_assoc, codisjoint_hnot_hnot_left_iff,
  codisjoint_left_comm, codisjoint_hnot_hnot_left_iff, ← codisjoint_assoc, sup_comm]
state_before: ι : Type ?u.178832
α : Type u_1
β : Type ?u.178838
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢(a ⊔ b) ≤ ￢￢a ⊔ ￢￢b

tactic: exact codisjoint_hnot_right
state_before: ι : Type ?u.178832
α : Type u_1
β : Type ?u.178838
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ Codisjoint (a ⊔ b) (￢(a ⊔ b))
Theorem: Ordinal.nfpBFamily_lt_ord_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [mk_ordinal_out]
state_before: α : Type ?u.34204
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : Cardinal.lift (card o) < cof c
hf : ∀ (i : Ordinal) (hi : i < o) (b : Ordinal), b < c → f i hi b < c
a : Ordinal
⊢ Cardinal.lift (#(Quotient.out o).α) < cof c
Theorem: Besicovitch.isEmpty_satelliteConfig_multiplicity
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

tactic: intro a
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ SatelliteConfig E (multiplicity E) (goodτ E) → False

tactic: let b := a.centerAndRescale
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
⊢ False

tactic: rcases b.exists_normalized a.centerAndRescale_center a.centerAndRescale_radius
    (one_lt_goodτ E).le (goodδ E) le_rfl (goodδ_lt_one E).le with
  ⟨c', c'_le_two, hc'⟩
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
b : SatelliteConfig E (multiplicity E) (goodτ E) := SatelliteConfig.centerAndRescale a
⊢ False

tactic: exact
  lt_irrefl _ ((Nat.lt_succ_self _).trans_le (le_multiplicity_of_δ_of_fin c' c'_le_two hc'))
state_before: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
b : SatelliteConfig E (multiplicity E) (goodτ E) := SatelliteConfig.centerAndRescale a
c' : Fin (Nat.succ (multiplicity E)) → E
c'_le_two : ∀ (n : Fin (Nat.succ (multiplicity E))), ‖c' n‖ ≤ 2
hc' : ∀ (i j : Fin (Nat.succ (multiplicity E))), i ≠ j → 1 - goodδ E ≤ ‖c' i - c' j‖
⊢ False
Theorem: MeasureTheory.Measure.restrict_apply₀'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← restrict_congr_set hs.toMeasurable_ae_eq,
  restrict_apply' (measurableSet_toMeasurable _ _),
  measure_congr ((ae_eq_refl t).inter hs.toMeasurable_ae_eq)]
state_before: α : Type u_1
β : Type ?u.283441
γ : Type ?u.283444
δ : Type ?u.283447
ι : Type ?u.283450
R : Type ?u.283453
R' : Type ?u.283456
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : NullMeasurableSet s
⊢ ↑↑(restrict μ s) t = ↑↑μ (t ∩ s)
Theorem: Real.cos_eq_one_iff_of_lt_of_lt
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rcases(cos_eq_one_iff _).1 h with ⟨n, rfl⟩
state_before: x : ℝ
hx₁ : -(2 * π) < x
hx₂ : x < 2 * π
h : cos x = 1
⊢ x = 0

tactic: rw [mul_lt_iff_lt_one_left two_pi_pos] at hx₂
state_before: case intro
n : ℤ
hx₁ : -(2 * π) < ↑n * (2 * π)
hx₂ : ↑n * (2 * π) < 2 * π
h : cos (↑n * (2 * π)) = 1
⊢ ↑n * (2 * π) = 0

tactic: rw [neg_lt, neg_mul_eq_neg_mul, mul_lt_iff_lt_one_left two_pi_pos] at hx₁
state_before: case intro
n : ℤ
hx₁ : -(2 * π) < ↑n * (2 * π)
hx₂ : ↑n < 1
h : cos (↑n * (2 * π)) = 1
⊢ ↑n * (2 * π) = 0

tactic: norm_cast  at hx₁ hx₂
state_before: case intro
n : ℤ
hx₁ : -↑n < 1
hx₂ : ↑n < 1
h : cos (↑n * (2 * π)) = 1
⊢ ↑n * (2 * π) = 0

tactic: obtain rfl : n = 0 := le_antisymm (by linarith) (by linarith)
state_before: case intro
n : ℤ
h : cos (↑n * (2 * π)) = 1
hx₁ : -n < 1
hx₂ : n < 1
⊢ ↑n * (2 * π) = 0

tactic: simp
state_before: case intro
h : cos (↑0 * (2 * π)) = 1
hx₁ : -0 < 1
hx₂ : 0 < 1
⊢ ↑0 * (2 * π) = 0

tactic: linarith
state_before: n : ℤ
h : cos (↑n * (2 * π)) = 1
hx₁ : -n < 1
hx₂ : n < 1
⊢ n ≤ 0

tactic: linarith
state_before: n : ℤ
h : cos (↑n * (2 * π)) = 1
hx₁ : -n < 1
hx₂ : n < 1
⊢ 0 ≤ n

tactic: simp [h]
state_before: x : ℝ
hx₁ : -(2 * π) < x
hx₂ : x < 2 * π
h : x = 0
⊢ cos x = 1
Theorem: Finset.dvd_gcd_iff
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: apply Iff.trans Multiset.dvd_gcd
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12267
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ a ∣ gcd s f ↔ ∀ (b : β), b ∈ s → a ∣ f b

tactic: simp only [Multiset.mem_map, and_imp, exists_imp]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12267
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∀ (b : α), b ∈ Multiset.map f s.val → a ∣ b) ↔ ∀ (b : β), b ∈ s → a ∣ f b

tactic: exact ⟨fun k b hb ↦ k _ _ hb rfl, fun k a' b hb h ↦ h ▸ k _ hb⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12267
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∀ (b : α) (x : β), x ∈ s.val → f x = b → a ∣ b) ↔ ∀ (b : β), b ∈ s → a ∣ f b
Theorem: MeasureTheory.measurePreserving_div_prod
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: apply measurePreserving_prod_div_swap μ ν
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
⊢ MeasurePreserving ?m.559954
Theorem: Sigma.ext_iff
File: Mathlib/Data/Sigma/Basic.lean

tactic: cases x₀
state_before: α : Type u_1
α₁ : Type ?u.3081
α₂ : Type ?u.3084
β : α → Type u_2
β₁ : α₁ → Type ?u.3094
β₂ : α₂ → Type ?u.3099
x₀ x₁ : Sigma β
⊢ x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd

tactic: cases x₁
state_before: case mk
α : Type u_1
α₁ : Type ?u.3081
α₂ : Type ?u.3084
β : α → Type u_2
β₁ : α₁ → Type ?u.3094
β₂ : α₂ → Type ?u.3099
x₁ : Sigma β
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝, snd := snd✝ } = x₁ ↔
    { fst := fst✝, snd := snd✝ }.fst = x₁.fst ∧ HEq { fst := fst✝, snd := snd✝ }.snd x₁.snd

tactic: exact Sigma.mk.inj_iff
state_before: case mk.mk
α : Type u_1
α₁ : Type ?u.3081
α₂ : Type ?u.3084
β : α → Type u_2
β₁ : α₁ → Type ?u.3094
β₂ : α₂ → Type ?u.3099
fst✝¹ : α
snd✝¹ : β fst✝¹
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝¹, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ } ↔
    { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst ∧
      HEq { fst := fst✝¹, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
Theorem: Finset.Ico_insert_right
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_insert, coe_Icc, coe_Ico, Set.insert_eq, Set.union_comm, Set.Ico_union_right h]
state_before: ι : Type ?u.92797
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a ≤ b
⊢ insert b (Ico a b) = Icc a b
Theorem: Equiv.Perm.sign_surjective
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp [h]
state_before: α : Type u
β : Type v
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : Nontrivial α
a : ℤˣ
h : a = 1
⊢ ↑sign 1 = a

tactic: rw [sign_swap hxy, h]
state_before: α : Type u
β : Type v
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : Nontrivial α
a : ℤˣ
h : a = -1
x y : α
hxy : x ≠ y
⊢ ↑sign (swap x y) = a
Theorem: Turing.Tape.map_write
File: Mathlib/Computability/TuringMachine.lean

tactic: rintro ⟨⟩
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
b : Γ
⊢ ∀ (T : Tape Γ), map f (write b T) = write (PointedMap.f f b) (map f T)

tactic: rfl
state_before: case mk
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
b head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ map f (write b { head := head✝, left := left✝, right := right✝ }) =
    write (PointedMap.f f b) (map f { head := head✝, left := left✝, right := right✝ })
Theorem: BoundedContinuousFunction.exists_forall_mem_restrict_eq_of_closed
File: Mathlib/Topology/TietzeExtension.lean

tactic: rcases exists_extension_forall_mem_of_closedEmbedding f hf hne
    (closedEmbedding_subtype_val hs) with
  ⟨g, hg, hgf⟩
state_before: X : Type ?u.107579
Y : Type u_1
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : NormalSpace Y
s : Set Y
f : ↑s →ᵇ ℝ
hs : IsClosed s
t : Set ℝ
inst✝ : OrdConnected t
hf : ∀ (x : ↑s), ↑f x ∈ t
hne : Set.Nonempty t
⊢ ∃ g, (∀ (y : Y), ↑g y ∈ t) ∧ restrict g s = f

tactic: exact ⟨g, hg, FunLike.coe_injective hgf⟩
state_before: case intro.intro
X : Type ?u.107579
Y : Type u_1
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : NormalSpace Y
s : Set Y
f : ↑s →ᵇ ℝ
hs : IsClosed s
t : Set ℝ
inst✝ : OrdConnected t
hf : ∀ (x : ↑s), ↑f x ∈ t
hne : Set.Nonempty t
g : Y →ᵇ ℝ
hg : ∀ (y : Y), ↑g y ∈ t
hgf : ↑g ∘ Subtype.val = ↑f
⊢ ∃ g, (∀ (y : Y), ↑g y ∈ t) ∧ restrict g s = f
Theorem: Submodule.isInternal_prime_power_torsion
File: Mathlib/Algebra/Module/DedekindDomain.lean

tactic: have hM' := Module.isTorsionBySet_annihilator_top R M
state_before: R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsDedekindDomain R
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
⊢ DirectSum.IsInternal fun p => torsionBySet R M ↑(↑p ^ Multiset.count (↑p) (factors (annihilator ⊤)))

tactic: have hI := Submodule.annihilator_top_inter_nonZeroDivisors hM
state_before: R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsDedekindDomain R
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
hM' : Module.IsTorsionBySet R M ↑(annihilator ⊤)
⊢ DirectSum.IsInternal fun p => torsionBySet R M ↑(↑p ^ Multiset.count (↑p) (factors (annihilator ⊤)))

tactic: refine' isInternal_prime_power_torsion_of_is_torsion_by_ideal _ hM'
state_before: R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsDedekindDomain R
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
hM' : Module.IsTorsionBySet R M ↑(annihilator ⊤)
hI : ↑(annihilator ⊤) ∩ ↑(nonZeroDivisors R) ≠ ∅
⊢ DirectSum.IsInternal fun p => torsionBySet R M ↑(↑p ^ Multiset.count (↑p) (factors (annihilator ⊤)))

tactic: rw [← Set.nonempty_iff_ne_empty] at hI
state_before: R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsDedekindDomain R
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
hM' : Module.IsTorsionBySet R M ↑(annihilator ⊤)
hI : ↑(annihilator ⊤) ∩ ↑(nonZeroDivisors R) ≠ ∅
⊢ annihilator ⊤ ≠ ⊥

tactic: rw [Submodule.ne_bot_iff]
state_before: R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsDedekindDomain R
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
hM' : Module.IsTorsionBySet R M ↑(annihilator ⊤)
hI : Set.Nonempty (↑(annihilator ⊤) ∩ ↑(nonZeroDivisors R))
⊢ annihilator ⊤ ≠ ⊥

tactic: obtain ⟨x, H, hx⟩ := hI
state_before: R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsDedekindDomain R
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
hM' : Module.IsTorsionBySet R M ↑(annihilator ⊤)
hI : Set.Nonempty (↑(annihilator ⊤) ∩ ↑(nonZeroDivisors R))
⊢ ∃ x, x ∈ annihilator ⊤ ∧ x ≠ 0

tactic: exact ⟨x, H, nonZeroDivisors.ne_zero hx⟩
state_before: case intro.intro
R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsDedekindDomain R
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
hM' : Module.IsTorsionBySet R M ↑(annihilator ⊤)
x : R
H : x ∈ ↑(annihilator ⊤)
hx : x ∈ ↑(nonZeroDivisors R)
⊢ ∃ x, x ∈ annihilator ⊤ ∧ x ≠ 0
Theorem: Set.iUnion_Ioc_eq_Ioi_self_iff
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp [← Ioi_inter_Iic, ← inter_iUnion, subset_def]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ : α
f : ι → α
a : α
⊢ (⋃ (i : ι), Ioc a (f i)) = Ioi a ↔ ∀ (x : α), a < x → ∃ i, x ≤ f i
Theorem: Multiset.nsmul_cons
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← singleton_add, nsmul_add]
state_before: α : Type u_1
β : Type ?u.48063
γ : Type ?u.48066
s : Multiset α
n : ℕ
a : α
⊢ n • (a ::ₘ s) = n • {a} + n • s
Theorem: geom_series_mul_neg
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: have := (NormedRing.summable_geometric_of_norm_lt_1 x h).hasSum.mul_right (1 - x)
state_before: α : Type ?u.1244932
β : Type ?u.1244935
ι : Type ?u.1244938
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
⊢ (∑' (i : ℕ), x ^ i) * (1 - x) = 1

tactic: refine' tendsto_nhds_unique this.tendsto_sum_nat _
state_before: α : Type ?u.1244932
β : Type ?u.1244935
ι : Type ?u.1244938
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
this : HasSum (fun i => x ^ i * (1 - x)) ((∑' (b : ℕ), x ^ b) * (1 - x))
⊢ (∑' (i : ℕ), x ^ i) * (1 - x) = 1

tactic: have : Tendsto (fun n : ℕ ↦ 1 - x ^ n) atTop (𝓝 1) := by
  simpa using tendsto_const_nhds.sub (tendsto_pow_atTop_nhds_0_of_norm_lt_1 h)
state_before: α : Type ?u.1244932
β : Type ?u.1244935
ι : Type ?u.1244938
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
this : HasSum (fun i => x ^ i * (1 - x)) ((∑' (b : ℕ), x ^ b) * (1 - x))
⊢ Tendsto (fun n => ∑ i in Finset.range n, x ^ i * (1 - x)) atTop (𝓝 1)

tactic: convert← this
state_before: α : Type ?u.1244932
β : Type ?u.1244935
ι : Type ?u.1244938
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
this✝ : HasSum (fun i => x ^ i * (1 - x)) ((∑' (b : ℕ), x ^ b) * (1 - x))
this : Tendsto (fun n => 1 - x ^ n) atTop (𝓝 1)
⊢ Tendsto (fun n => ∑ i in Finset.range n, x ^ i * (1 - x)) atTop (𝓝 1)

tactic: rw [← geom_sum_mul_neg, Finset.sum_mul]
state_before: case h.e'_3.h
α : Type ?u.1244932
β : Type ?u.1244935
ι : Type ?u.1244938
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
this✝ : HasSum (fun i => x ^ i * (1 - x)) ((∑' (b : ℕ), x ^ b) * (1 - x))
this : Tendsto (fun n => 1 - x ^ n) atTop (𝓝 1)
x✝ : ℕ
⊢ 1 - x ^ x✝ = ∑ i in Finset.range x✝, x ^ i * (1 - x)

tactic: simpa using tendsto_const_nhds.sub (tendsto_pow_atTop_nhds_0_of_norm_lt_1 h)
state_before: α : Type ?u.1244932
β : Type ?u.1244935
ι : Type ?u.1244938
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
this : HasSum (fun i => x ^ i * (1 - x)) ((∑' (b : ℕ), x ^ b) * (1 - x))
⊢ Tendsto (fun n => 1 - x ^ n) atTop (𝓝 1)
Theorem: EuclideanDomain.xgcdAux_val
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [xgcd, ← xgcdAux_fst x y 1 0 0 1, Prod.mk.eta]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
⊢ xgcdAux x 1 0 y 0 1 = (gcd x y, xgcd x y)
Theorem: Part.some_ne_none
File: Mathlib/Data/Part.lean

tactic: intro h
state_before: α : Type u_1
β : Type ?u.5463
γ : Type ?u.5466
x : α
⊢ some x ≠ none

tactic: exact true_ne_false (congr_arg Dom h)
state_before: α : Type u_1
β : Type ?u.5463
γ : Type ?u.5466
x : α
h : some x = none
⊢ False
Theorem: Real.le_arcsin_iff_sin_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [← neg_le_neg_iff, ← arcsin_neg,
  arcsin_le_iff_le_sin ⟨neg_le_neg hy.2, neg_le.2 hy.1⟩ ⟨neg_le_neg hx.2, neg_le.2 hx.1⟩, sin_neg,
  neg_le_neg_iff]
state_before: x y : ℝ
hx : x ∈ Icc (-(π / 2)) (π / 2)
hy : y ∈ Icc (-1) 1
⊢ x ≤ arcsin y ↔ sin x ≤ y
Theorem: Multiset.exists_smul_of_dvd_count
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: use ∑ a in s.toFinset, (s.count a / k) • {a}
state_before: ι : Type ?u.938329
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq α
s : Multiset α
k : ℕ
h : ∀ (a : α), a ∈ s → k ∣ count a s
⊢ ∃ u, s = k • u

tactic: have h₂ :
  (∑ x : α in s.toFinset, k • (count x s / k) • ({x} : Multiset α)) =
    ∑ x : α in s.toFinset, count x s • {x} := by
  apply Finset.sum_congr rfl
  intro x hx
  rw [← mul_nsmul', Nat.mul_div_cancel' (h x (mem_toFinset.mp hx))]
state_before: ι : Type ?u.938329
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq α
s : Multiset α
k : ℕ
h : ∀ (a : α), a ∈ s → k ∣ count a s
⊢ s = k • ∑ a in toFinset s, (count a s / k) • {a}

tactic: rw [← Finset.sum_nsmul, h₂, toFinset_sum_count_nsmul_eq]
state_before: ι : Type ?u.938329
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq α
s : Multiset α
k : ℕ
h : ∀ (a : α), a ∈ s → k ∣ count a s
h₂ : ∑ x in toFinset s, k • (count x s / k) • {x} = ∑ x in toFinset s, count x s • {x}
⊢ s = k • ∑ a in toFinset s, (count a s / k) • {a}

tactic: apply Finset.sum_congr rfl
state_before: ι : Type ?u.938329
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq α
s : Multiset α
k : ℕ
h : ∀ (a : α), a ∈ s → k ∣ count a s
⊢ ∑ x in toFinset s, k • (count x s / k) • {x} = ∑ x in toFinset s, count x s • {x}

tactic: intro x hx
state_before: ι : Type ?u.938329
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq α
s : Multiset α
k : ℕ
h : ∀ (a : α), a ∈ s → k ∣ count a s
⊢ ∀ (x : α), x ∈ toFinset s → k • (count x s / k) • {x} = count x s • {x}

tactic: rw [← mul_nsmul', Nat.mul_div_cancel' (h x (mem_toFinset.mp hx))]
state_before: ι : Type ?u.938329
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq α
s : Multiset α
k : ℕ
h : ∀ (a : α), a ∈ s → k ∣ count a s
x : α
hx : x ∈ toFinset s
⊢ k • (count x s / k) • {x} = count x s • {x}
Theorem: integral_sin
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: rw [integral_deriv_eq_sub' fun x => -cos x]
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x) = cos a - cos b

tactic: ring
state_before: a b : ℝ
n : ℕ
⊢ -cos b - -cos a = cos a - cos b

tactic: norm_num
state_before: case hderiv
a b : ℝ
n : ℕ
⊢ (deriv fun x => -cos x) = fun x => sin x

tactic: simp only [differentiableAt_neg_iff, differentiableAt_cos, implies_true]
state_before: case hdiff
a b : ℝ
n : ℕ
⊢ ∀ (x : ℝ), x ∈ [[a, b]] → DifferentiableAt ℝ (fun x => -cos x) x

tactic: exact continuousOn_sin
state_before: case hcont
a b : ℝ
n : ℕ
⊢ ContinuousOn (fun x => sin x) [[a, b]]
Theorem: Equiv.symm_trans_self
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simp
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
⊢ ∀ (x : β), ↑(e.symm.trans e) x = ↑(Equiv.refl β) x