ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.map_div_left_divisors
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
⊢ map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors = n.divisorsAntidiagonal
state_after: case a
n : ℕ
⊢ map (Equiv.prodComm ℕ ℕ).toEmbedding (map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors) =
    map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal
tactic: apply Finset.map_injective (Equiv.prodComm _ _).toEmbedding
state_before: case a
n : ℕ
⊢ map (Equiv.prodComm ℕ ℕ).toEmbedding (map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors) =
    map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal
state_after: case a.a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding (map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors) ↔
    a✝ ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal
tactic: ext
state_before: case a.a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding (map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors) ↔
    a✝ ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal
state_after: case a.a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ map ({ toFun := fun d => (n / d, d), inj' := ⋯ }.trans (Equiv.prodComm ℕ ℕ).toEmbedding) n.divisors ↔
    a✝ ∈ map { toFun := fun d => (d, n / d), inj' := ⋯ } n.divisors
tactic: rw [map_swap_divisorsAntidiagonal, ← map_div_right_divisors, Finset.map_map]
state_before: case a.a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ map ({ toFun := fun d => (n / d, d), inj' := ⋯ }.trans (Equiv.prodComm ℕ ℕ).toEmbedding) n.divisors ↔
    a✝ ∈ map { toFun := fun d => (d, n / d), inj' := ⋯ } n.divisors
state_after: no goals
tactic: simp
Theorem: ZMod.toCircle_intCast
File: Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean

Proof steps:
state_before: N : ℕ
inst✝ : NeZero N
j : ℤ
⊢ ↑(toCircle ↑j) = cexp (2 * ↑π * I * ↑j / ↑N)
state_after: N : ℕ
inst✝ : NeZero N
j : ℤ
⊢ cexp (↑(2 * π / 1 * (↑j / ↑N)) * I) = cexp (2 * ↑π * I * ↑j / ↑N)
tactic: rw [toCircle, AddChar.coe_mk, AddCircle.toCircle, toAddCircle_intCast,
    Function.Periodic.lift_coe, expMapCircle_apply]
state_before: N : ℕ
inst✝ : NeZero N
j : ℤ
⊢ cexp (↑(2 * π / 1 * (↑j / ↑N)) * I) = cexp (2 * ↑π * I * ↑j / ↑N)
state_after: N : ℕ
inst✝ : NeZero N
j : ℤ
⊢ cexp (2 * ↑π / 1 * (↑j / ↑N) * I) = cexp (2 * ↑π * I * ↑j / ↑N)
tactic: push_cast
state_before: N : ℕ
inst✝ : NeZero N
j : ℤ
⊢ cexp (2 * ↑π / 1 * (↑j / ↑N) * I) = cexp (2 * ↑π * I * ↑j / ↑N)
state_after: no goals
tactic: ring_nf
Theorem: neg_smul
File: Mathlib/Algebra/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
k : Type u_3
S : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
r s : R
x y : M
⊢ -r • x + r • x = 0
state_after: no goals
tactic: rw [← add_smul, add_left_neg, zero_smul]
Theorem: IsClosed.intrinsicClosure
File: Mathlib/Analysis/Convex/Intrinsic.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x : P
hs : IsClosed (Subtype.val ⁻¹' s)
⊢ intrinsicClosure 𝕜 s = s
state_after: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x : P
hs : IsClosed (Subtype.val ⁻¹' s)
⊢ s ⊆ range Subtype.val
tactic: rw [intrinsicClosure, hs.closure_eq, image_preimage_eq_of_subset]
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x : P
hs : IsClosed (Subtype.val ⁻¹' s)
⊢ s ⊆ range Subtype.val
state_after: no goals
tactic: exact (subset_affineSpan _ _).trans Subtype.range_coe.superset
Theorem: Complex.abs_arg_inv
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x : ℂ
⊢ |x⁻¹.arg| = |x.arg|
state_after: a x✝ z x : ℂ
⊢ |if x.arg = π then π else -x.arg| = |x.arg|
tactic: rw [arg_inv]
state_before: a x✝ z x : ℂ
⊢ |if x.arg = π then π else -x.arg| = |x.arg|
state_after: no goals
tactic: split_ifs <;> simp [*]
Theorem: eventuallyConst_of_isNoetherian
File: Mathlib/RingTheory/Noetherian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : AddCommMonoid P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : ℕ →o Submodule R M
⊢ EventuallyConst (⇑f) atTop
state_after: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : AddCommMonoid P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : ℕ →o Submodule R M
⊢ ∃ i, ∀ (j : ℕ), i ≤ j → f i = f j
tactic: simp_rw [eventuallyConst_atTop, eq_comm]
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : AddCommMonoid P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : ℕ →o Submodule R M
⊢ ∃ i, ∀ (j : ℕ), i ≤ j → f i = f j
state_after: no goals
tactic: exact (monotone_stabilizes_iff_noetherian.mpr inferInstance) f
Theorem: Function.support_mul
File: Mathlib/Algebra/GroupWithZero/Indicator.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝¹ : MulZeroClass M₀
inst✝ : NoZeroDivisors M₀
f g : ι → M₀
x : ι
⊢ (x ∈ support fun x => f x * g x) ↔ x ∈ support f ∩ support g
state_after: no goals
tactic: simp [not_or]
Theorem: CategoryTheory.Limits.pushoutCoconeOfRightIso_ι_app_none
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ (pushoutCoconeOfRightIso f g).ι.app none = f
state_after: no goals
tactic: simp
Theorem: Commute.div_eq_div_iff_of_isUnit
File: Mathlib/Algebra/Group/Commute/Units.lean

Proof steps:
state_before: M : Type u_1
inst✝ : DivisionMonoid M
a b c d : M
hbd : Commute b d
hb : IsUnit b
hd : IsUnit d
⊢ a / b = c / d ↔ a * d = c * b
state_after: no goals
tactic: rw [← (hb.mul hd).mul_left_inj, ← mul_assoc, hb.div_mul_cancel, ← mul_assoc, hbd.right_comm,
    hd.div_mul_cancel]
Theorem: ENNReal.toNNReal_strict_mono
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
h : a < b
⊢ a.toNNReal < b.toNNReal
state_after: no goals
tactic: simpa [← ENNReal.coe_lt_coe, hb, h.ne_top]
Theorem: CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_right
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 C).map (point.map η) ≫
      ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := X.hom.app [0] }) Y✝).hom =
    ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := X.hom.app [0] }) X✝).hom ≫
      (𝟭 C).map ((drop.map η).app [0])
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = X✝.hom.app [0] ≫ η.right.app [0]
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = X✝.hom.app [0] ≫ η.right.app [0]
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = (X✝.hom ≫ η.right).app [0]
tactic: rw [← NatTrans.comp_app]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = (X✝.hom ≫ η.right).app [0]
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = ((const C).map η.left ≫ Y✝.hom).app [0]
tactic: erw [← η.w]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = ((const C).map η.left ≫ Y✝.hom).app [0]
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.SimpleFunc.restrict_apply
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α
K : Type u_5
inst✝ : Zero β
f : α →ₛ β
s : Set α
hs : MeasurableSet s
a : α
⊢ ↑(f.restrict s) a = s.indicator (↑f) a
state_after: no goals
tactic: simp only [f.coe_restrict hs]
Theorem: Zsqrtd.smul_re
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d a : ℤ
b : ℤ√d
⊢ (↑a * b).re = a * b.re
state_after: no goals
tactic: simp
Theorem: Complex.summable_one_div_nat_cpow
File: Mathlib/Analysis/PSeriesComplex.lean

Proof steps:
state_before: p : ℂ
⊢ (Summable fun n => 1 / ↑n ^ p) ↔ 1 < p.re
state_after: p : ℂ
⊢ (Summable fun x => ‖1 / ↑(x + 1) ^ p‖) ↔ Summable fun n => 1 / ↑(n + 1) ^ p.re
tactic: rw [← Real.summable_one_div_nat_rpow, ← summable_nat_add_iff 1 (G := ℝ),
    ← summable_nat_add_iff 1 (G := ℂ), ← summable_norm_iff]
state_before: p : ℂ
⊢ (Summable fun x => ‖1 / ↑(x + 1) ^ p‖) ↔ Summable fun n => 1 / ↑(n + 1) ^ p.re
state_after: no goals
tactic: simp only [norm_div, norm_one, norm_eq_abs, ← ofReal_natCast, abs_cpow_eq_rpow_re_of_pos
    (Nat.cast_pos.mpr <| Nat.succ_pos _)]
Theorem: Filter.Tendsto.atTop_mul_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : OrderedSemiring α
l : Filter β
f g : β → α
hf : Tendsto f l atTop
hg : Tendsto g l atTop
⊢ Tendsto (fun x => f x * g x) l atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : OrderedSemiring α
l : Filter β
f g : β → α
hf : Tendsto f l atTop
hg : Tendsto g l atTop
⊢ g ≤ᶠ[l] fun x => f x * g x
tactic: refine tendsto_atTop_mono' _ ?_ hg
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : OrderedSemiring α
l : Filter β
f g : β → α
hf : Tendsto f l atTop
hg : Tendsto g l atTop
⊢ g ≤ᶠ[l] fun x => f x * g x
state_after: no goals
tactic: filter_upwards [hg.eventually (eventually_ge_atTop 0),
    hf.eventually (eventually_ge_atTop 1)] with _ using le_mul_of_one_le_left
Theorem: IsUnit.mul_liftRight_inv
File: Mathlib/Algebra/Group/Units/Hom.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x : M
⊢ ∀ (x : M), ↑⋯.unit = f x
state_after: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x x✝ : M
⊢ ↑⋯.unit = f x✝
tactic: intro
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x x✝ : M
⊢ ↑⋯.unit = f x✝
state_after: no goals
tactic: rfl
Theorem: Cardinal.mk_list_eq_mk
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α : Type u
inst✝ : Infinite α
H1 : ℵ₀ ≤ #α
x✝ : α
⊢ ∀ ⦃a₂ : α⦄, (fun a => [a]) x✝ = (fun a => [a]) a₂ → x✝ = a₂
state_after: no goals
tactic: simp
state_before: α : Type u
inst✝ : Infinite α
H1 : ℵ₀ ≤ #α
⊢ (sum fun x => #α) = #α
state_after: no goals
tactic: simp [H1]
Theorem: SimpleGraph.map_adj_apply
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G' : SimpleGraph W
u v : V
G : SimpleGraph V
f : V ↪ W
a b : V
⊢ (SimpleGraph.map f G).Adj (f a) (f b) ↔ G.Adj a b
state_after: no goals
tactic: simp
Theorem: Finmap.induction_on
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
C : Finmap β → Prop
s : Finmap β
H : ∀ (a : AList β), C ⟦a⟧
⊢ C s
state_after: case mk.mk
α : Type u
β : α → Type v
C : Finmap β → Prop
H : ∀ (a : AList β), C ⟦a⟧
entries✝ : Multiset (Sigma β)
a : List (Sigma β)
h : Multiset.NodupKeys (Quot.mk Setoid.r a)
⊢ C { entries := Quot.mk Setoid.r a, nodupKeys := h }
tactic: rcases s with ⟨⟨a⟩, h⟩
state_before: case mk.mk
α : Type u
β : α → Type v
C : Finmap β → Prop
H : ∀ (a : AList β), C ⟦a⟧
entries✝ : Multiset (Sigma β)
a : List (Sigma β)
h : Multiset.NodupKeys (Quot.mk Setoid.r a)
⊢ C { entries := Quot.mk Setoid.r a, nodupKeys := h }
state_after: no goals
tactic: exact H ⟨a, h⟩
Theorem: Real.arccos_eq_of_eq_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x y : ℝ
hy₀ : 0 ≤ y
hy₁ : y ≤ π
hxy : x = cos y
⊢ arccos x = y
state_after: no goals
tactic: rw [hxy, arccos_cos hy₀ hy₁]
Theorem: isRegular_mul_iff
File: Mathlib/Algebra/Regular/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemigroup R
a b : R
⊢ IsRegular (a * b) ↔ IsRegular a ∧ IsRegular b
state_after: R : Type u_1
inst✝ : CommSemigroup R
a b : R
⊢ IsRegular (a * b) ↔ IsRegular (a * b) ∧ IsRegular (b * a)
tactic: refine Iff.trans ?_ isRegular_mul_and_mul_iff
state_before: R : Type u_1
inst✝ : CommSemigroup R
a b : R
⊢ IsRegular (a * b) ↔ IsRegular (a * b) ∧ IsRegular (b * a)
state_after: no goals
tactic: exact ⟨fun ab => ⟨ab, by rwa [mul_comm]⟩, fun rab => rab.1⟩
Theorem: finsum_mem_eq_sum
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
hf : (s ∩ mulSupport f).Finite
⊢ s ∩ mulSupport f = ↑hf.toFinset ∩ mulSupport f
state_after: no goals
tactic: simp [inter_assoc]
Theorem: MeasureTheory.Conservative.ae_forall_image_mem_imp_frequently_image_mem
File: Mathlib/Dynamics/Ergodic/Conservative.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
⊢ ∀ᵐ (x : α) ∂μ, ∀ (k : ℕ), f^[k] x ∈ s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ s
state_after: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
k : ℕ
⊢ ∀ᵐ (a : α) ∂μ, f^[k] a ∈ s → ∃ᶠ (n : ℕ) in atTop, f^[n] a ∈ s
tactic: refine ae_all_iff.2 fun k => ?_
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
k : ℕ
⊢ ∀ᵐ (a : α) ∂μ, f^[k] a ∈ s → ∃ᶠ (n : ℕ) in atTop, f^[n] a ∈ s
state_after: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
⊢ ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ s
tactic: refine (hf.ae_mem_imp_frequently_image_mem
    (hs.preimage <| hf.toQuasiMeasurePreserving.iterate k)).mono fun x hx hk => ?_
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
⊢ ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ s
state_after: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
⊢ ∃ᶠ (a : ℕ) in atTop, f^[a + k] x ∈ s
tactic: rw [← map_add_atTop_eq_nat k, frequently_map]
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
⊢ ∃ᶠ (a : ℕ) in atTop, f^[a + k] x ∈ s
state_after: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
n : ℕ
hn : f^[n] x ∈ f^[k] ⁻¹' s
⊢ f^[n + k] x ∈ s
tactic: refine (hx hk).mono fun n hn => ?_
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : NullMeasurableSet s μ
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ f^[k] ⁻¹' s
hk : f^[k] x ∈ s
n : ℕ
hn : f^[n] x ∈ f^[k] ⁻¹' s
⊢ f^[n + k] x ∈ s
state_after: no goals
tactic: rwa [add_comm, iterate_add_apply]
Theorem: Filter.map₂_mk_eq_prod
File: Mathlib/Order/Filter/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
f : Filter α
g : Filter β
⊢ map₂ Prod.mk f g = f ×ˢ g
state_after: no goals
tactic: simp only [← map_prod_eq_map₂, map_id']
Theorem: LSeries.term_smul
File: Mathlib/NumberTheory/LSeries/Linearity.lean

Proof steps:
state_before: f : ℕ → ℂ
c s : ℂ
⊢ term (c • f) s = c • term f s
state_after: case h.zero
f : ℕ → ℂ
c s : ℂ
⊢ term (c • f) s 0 = (c • term f s) 0

case h.succ
f : ℕ → ℂ
c s : ℂ
n✝ : ℕ
⊢ term (c • f) s (n✝ + 1) = (c • term f s) (n✝ + 1)
tactic: ext ⟨- | n⟩
Theorem: CategoryTheory.ShortComplex.leftHomologyFunctorOpNatIso_hom_app
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{?u.203992, u_1} C
inst✝⁴ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝³ : HasKernels C
inst✝² : HasCokernels C
inst✝¹ : HasKernels Cᵒᵖ
inst✝ : HasCokernels Cᵒᵖ
⊢ ∀ {X Y : (ShortComplex C)ᵒᵖ} (f : X ⟶ Y),
    (leftHomologyFunctor C).op.map f ≫ ((fun S => (Opposite.unop S).rightHomologyOpIso.symm) Y).hom =
      ((fun S => (Opposite.unop S).rightHomologyOpIso.symm) X).hom ≫ (opFunctor C ⋙ rightHomologyFunctor Cᵒᵖ).map f
state_after: no goals
tactic: simp [leftHomologyMap_op]
Theorem: MeasurableEquiv.image_symm
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
e : α ≃ᵐ β
s : Set β
⊢ ⇑e.symm '' s = ⇑e ⁻¹' s
state_after: no goals
tactic: rw [← symm_symm e, preimage_symm, symm_symm]
Theorem: Function.Commute.minimalPeriod_of_comp_dvd_lcm
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Function.Commute f g
⊢ minimalPeriod (f ∘ g) x ∣ (minimalPeriod f x).lcm (minimalPeriod g x)
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Function.Commute f g
⊢ IsPeriodicPt (f ∘ g) ((minimalPeriod f x).lcm (minimalPeriod g x)) x
tactic: rw [← isPeriodicPt_iff_minimalPeriod_dvd]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Function.Commute f g
⊢ IsPeriodicPt (f ∘ g) ((minimalPeriod f x).lcm (minimalPeriod g x)) x
state_after: no goals
tactic: exact (isPeriodicPt_minimalPeriod f x).comp_lcm h (isPeriodicPt_minimalPeriod g x)
Theorem: Basis.card_le_card_of_linearIndependent
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι✝ : Type w
ι'✝ : Type w'
inst✝² : StrongRankCondition R
ι : Type u_1
inst✝¹ : Fintype ι
b : Basis ι R M
ι' : Type u_2
inst✝ : Fintype ι'
v : ι' → M
hv : LinearIndependent R v
⊢ Fintype.card ι' ≤ Fintype.card ι
state_after: R : Type u
M : Type v
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι✝ : Type w
ι'✝ : Type w'
inst✝² : StrongRankCondition R
ι : Type u_1
inst✝¹ : Fintype ι
b : Basis ι R M
ι' : Type u_2
inst✝ : Fintype ι'
v : ι' → M
hv : LinearIndependent R v
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
⊢ Fintype.card ι' ≤ Fintype.card ι
tactic: letI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M : Type v
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι✝ : Type w
ι'✝ : Type w'
inst✝² : StrongRankCondition R
ι : Type u_1
inst✝¹ : Fintype ι
b : Basis ι R M
ι' : Type u_2
inst✝ : Fintype ι'
v : ι' → M
hv : LinearIndependent R v
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
⊢ Fintype.card ι' ≤ Fintype.card ι
state_after: no goals
tactic: simpa [rank_eq_card_basis b, Cardinal.mk_fintype] using hv.cardinal_lift_le_rank
Theorem: upperCentralSeries.map
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
h : Function.Surjective ⇑f
n : ℕ
⊢ Subgroup.map f (upperCentralSeries G n) ≤ upperCentralSeries H n
state_after: case zero
G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
h : Function.Surjective ⇑f
⊢ Subgroup.map f (upperCentralSeries G 0) ≤ upperCentralSeries H 0

case succ
G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
h : Function.Surjective ⇑f
d : ℕ
hd : Subgroup.map f (upperCentralSeries G d) ≤ upperCentralSeries H d
⊢ Subgroup.map f (upperCentralSeries G (d + 1)) ≤ upperCentralSeries H (d + 1)
tactic: induction' n with d hd
Theorem: Nat.minSqFac_prime
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
⊢ Prime d
state_after: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp n.minSqFac
⊢ Prime d
tactic: have := minSqFac_has_prop n
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp n.minSqFac
⊢ Prime d
state_after: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp (some d)
⊢ Prime d
tactic: rw [h] at this
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp (some d)
⊢ Prime d
state_after: no goals
tactic: exact this.1
Theorem: Filter.EventuallyLE.congr
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : LE β
l : Filter α
f f' g g' : α → β
H✝ : f ≤ᶠ[l] g
hf✝ : f =ᶠ[l] f'
hg✝ : g =ᶠ[l] g'
x : α
hf : f x = f' x
hg : g x = g' x
H : f x ≤ g x
⊢ f' x ≤ g' x
state_after: no goals
tactic: rwa [hf, hg] at H
Theorem: CategoryTheory.Endofunctor.Adjunction.Coalgebra.homEquiv_naturality_str_symm
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ C
adj : F ⊣ G
V₁ V₂ : Coalgebra G
f : V₁ ⟶ V₂
⊢ F.map f.f ≫ (adj.homEquiv V₂.V V₂.V).symm V₂.str = (adj.homEquiv V₁.V V₁.V).symm V₁.str ≫ f.f
state_after: no goals
tactic: rw [← Adjunction.homEquiv_naturality_left_symm, ← Adjunction.homEquiv_naturality_right_symm,
    f.h]