ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.Ioc_inter_Iic
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : SemilatticeInf α
a b c : α
⊢ Ioc a b ∩ Iic c = Ioc a (b ⊓ c)
state_after: no goals
tactic: rw [← Ioi_inter_Iic, ← Ioi_inter_Iic, inter_assoc, Iic_inter_Iic]
Theorem: HurwitzZeta.hasSum_nat_hurwitzZetaOdd
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => (↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s - ↑(SignType.sign (↑n + 1 - a)) / ↑|↑n + 1 - a| ^ s) / 2)
    (hurwitzZetaOdd (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ (↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s - ↑(SignType.sign (↑n + 1 - a)) / ↑|↑n + 1 - a| ^ s) / 2 =
    ↑(SignType.sign (↑↑n + a)) / ↑|↑↑n + a| ^ s / 2 + ↑(SignType.sign (↑(-(↑n + 1)) + a)) / ↑|↑(-(↑n + 1)) + a| ^ s / 2
tactic: refine (hasSum_int_hurwitzZetaOdd a hs).nat_add_neg_add_one.congr_fun fun n ↦ ?_
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ (↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s - ↑(SignType.sign (↑n + 1 - a)) / ↑|↑n + 1 - a| ^ s) / 2 =
    ↑(SignType.sign (↑↑n + a)) / ↑|↑↑n + a| ^ s / 2 + ↑(SignType.sign (↑(-(↑n + 1)) + a)) / ↑|↑(-(↑n + 1)) + a| ^ s / 2
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 + -(↑(SignType.sign (↑n + 1 - a)) / ↑|↑n + 1 - a| ^ s / 2) =
    ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 + ↑(SignType.sign (-(↑n + 1) + a)) / ↑|-(↑n + 1) + a| ^ s / 2
tactic: rw [Int.cast_neg, Int.cast_add, Int.cast_one, sub_div, sub_eq_add_neg, Int.cast_natCast]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 + -(↑(SignType.sign (↑n + 1 - a)) / ↑|↑n + 1 - a| ^ s / 2) =
    ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 + ↑(SignType.sign (-(↑n + 1) + a)) / ↑|-(↑n + 1) + a| ^ s / 2
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
this : -(↑n + 1) + a = -(↑n + 1 - a)
⊢ ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 + -(↑(SignType.sign (↑n + 1 - a)) / ↑|↑n + 1 - a| ^ s / 2) =
    ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 + ↑(SignType.sign (-(↑n + 1) + a)) / ↑|-(↑n + 1) + a| ^ s / 2
tactic: have : -(n + 1) + a = -(n + 1 - a) := by ring_nf
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
this : -(↑n + 1) + a = -(↑n + 1 - a)
⊢ ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 + -(↑(SignType.sign (↑n + 1 - a)) / ↑|↑n + 1 - a| ^ s / 2) =
    ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 + ↑(SignType.sign (-(↑n + 1) + a)) / ↑|-(↑n + 1) + a| ^ s / 2
state_after: no goals
tactic: rw [this, Left.sign_neg, abs_neg, SignType.coe_neg, neg_div, neg_div]
Theorem: Function.HasTemperateGrowth.zero
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
⊢ Function.HasTemperateGrowth fun x => 0
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
n : ℕ
x : E
⊢ ‖iteratedFDeriv ℝ n (fun x => 0) x‖ ≤ 0 * (1 + ‖x‖) ^ 0
tactic: refine ⟨contDiff_const, fun n ↦ ⟨0, 0, fun x ↦ ?_⟩⟩
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
n : ℕ
x : E
⊢ ‖iteratedFDeriv ℝ n (fun x => 0) x‖ ≤ 0 * (1 + ‖x‖) ^ 0
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
n : ℕ
x : E
⊢ 0 ≤ 0 * (1 + ‖x‖) ^ 0
tactic: simp only [iteratedFDeriv_zero_fun, Pi.zero_apply, norm_zero, forall_const]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
n : ℕ
x : E
⊢ 0 ≤ 0 * (1 + ‖x‖) ^ 0
state_after: no goals
tactic: positivity
Theorem: Finmap.insert_insert_of_ne
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
b' : β a'
s✝ : Finmap β
h : a ≠ a'
s : AList β
⊢ insert a' b' (insert a b ⟦s⟧) = insert a b (insert a' b' ⟦s⟧)
state_after: no goals
tactic: simp only [insert_toFinmap, AList.toFinmap_eq, AList.insert_insert_of_ne _ h]
Theorem: Fin.insertNth_comp_succAbove
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : β
p : Fin n → β
⊢ ∀ (x_1 : Fin n), (i.insertNth x p ∘ i.succAbove) x_1 = p x_1
state_after: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : β
p : Fin n → β
⊢ ∀ (x_1 : Fin n), i.insertNth x p (i.succAbove x_1) = p x_1
tactic: unfold comp
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : β
p : Fin n → β
⊢ ∀ (x_1 : Fin n), i.insertNth x p (i.succAbove x_1) = p x_1
state_after: no goals
tactic: exact insertNth_apply_succAbove i _ _
Theorem: LinearMap.dualAnnihilator_ker_eq_range_flip
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : IsReflexive K V₂
⊢ (ker B).dualAnnihilator = range B.flip
state_after: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : IsReflexive K V₂
⊢ (ker B).dualAnnihilator = range (B.dualMap ∘ₗ ↑(evalEquiv K V₂))
tactic: change _ = range (B.dualMap.comp (Module.evalEquiv K V₂).toLinearMap)
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : IsReflexive K V₂
⊢ (ker B).dualAnnihilator = range (B.dualMap ∘ₗ ↑(evalEquiv K V₂))
state_after: no goals
tactic: rw [← range_dualMap_eq_dualAnnihilator_ker, range_comp_of_range_eq_top _ (LinearEquiv.range _)]
Theorem: CategoryTheory.Presheaf.isLocallyInjective_forget_iff
File: Mathlib/CategoryTheory/Sites/LocallyInjective.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ F₃ : Cᵒᵖ ⥤ D
φ : F₁ ⟶ F₂
ψ : F₂ ⟶ F₃
⊢ IsLocallyInjective J (whiskerRight φ (forget D)) ↔ IsLocallyInjective J φ
state_after: case mp
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ F₃ : Cᵒᵖ ⥤ D
φ : F₁ ⟶ F₂
ψ : F₂ ⟶ F₃
⊢ IsLocallyInjective J (whiskerRight φ (forget D)) → IsLocallyInjective J φ

case mpr
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ F₃ : Cᵒᵖ ⥤ D
φ : F₁ ⟶ F₂
ψ : F₂ ⟶ F₃
⊢ IsLocallyInjective J φ → IsLocallyInjective J (whiskerRight φ (forget D))
tactic: constructor
Theorem: cfc_apply_zero
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : CommSemiring R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalSemiring R
inst✝⁶ : ContinuousStar R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f✝ (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
inst✝ : UniqueContinuousFunctionalCalculus R A
f : R → R
⊢ cfc f 0 = (algebraMap R A) (f 0)
state_after: no goals
tactic: simpa using cfc_algebraMap (A := A) 0 f
Theorem: RegularExpression.map_id
File: Mathlib/Computability/RegularExpressions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
R S : RegularExpression α
⊢ map id (R + S) = R + S
state_after: no goals
tactic: simp_rw [map, map_id]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
R S : RegularExpression α
⊢ map id (R.comp S) = R.comp S
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
R S : RegularExpression α
⊢ R * S = R.comp S
tactic: simp_rw [map, map_id]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
R S : RegularExpression α
⊢ R * S = R.comp S
state_after: no goals
tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
R : RegularExpression α
⊢ map id R.star = R.star
state_after: no goals
tactic: simp_rw [map, map_id]
Theorem: MvPolynomial.eval₂Hom_zero
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝³ : CommSemiring R
inst✝² : CommSemiring S₁
p q : MvPolynomial σ R
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f✝ : σ → S₁
f : R →+* S₂
⊢ eval₂Hom f 0 = f.comp constantCoeff
state_after: no goals
tactic: ext <;> simp
Theorem: Multipliable.multipliable_of_eq_one_or_self
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : CompleteSpace α
hf : Multipliable f
h : ∀ (b : β), g b = 1 ∨ g b = f b
⊢ Multipliable g
state_after: no goals
tactic: classical
  exact multipliable_iff_vanishing.2 fun e he ↦
    let ⟨s, hs⟩ := multipliable_iff_vanishing.1 hf e he
    ⟨s, fun t ht ↦
      have eq : ∏ b ∈ t.filter fun b ↦ g b = f b, f b = ∏ b ∈ t, g b :=
        calc
          ∏ b ∈ t.filter fun b ↦ g b = f b, f b = ∏ b ∈ t.filter fun b ↦ g b = f b, g b :=
            Finset.prod_congr rfl fun b hb ↦ (Finset.mem_filter.1 hb).2.symm
          _ = ∏ b ∈ t, g b := by
           {refine Finset.prod_subset (Finset.filter_subset _ _) ?_
            intro b hbt hb
            simp only [Finset.mem_filter, and_iff_right hbt] at hb
            exact (h b).resolve_right hb}
      eq ▸ hs _ <| Finset.disjoint_of_subset_left (Finset.filter_subset _ _) ht⟩
Theorem: generateFrom_pi_eq
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsCountablySpanning (C i)
⊢ MeasurableSpace.pi = generateFrom (univ.pi '' univ.pi C)
state_after: case intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsCountablySpanning (C i)
val✝ : Encodable ι
⊢ MeasurableSpace.pi = generateFrom (univ.pi '' univ.pi C)
tactic: cases nonempty_encodable ι
state_before: case intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsCountablySpanning (C i)
val✝ : Encodable ι
⊢ MeasurableSpace.pi = generateFrom (univ.pi '' univ.pi C)
state_after: case intro.a
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsCountablySpanning (C i)
val✝ : Encodable ι
⊢ MeasurableSpace.pi ≤ generateFrom (univ.pi '' univ.pi C)

case intro.a
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsCountablySpanning (C i)
val✝ : Encodable ι
⊢ generateFrom (univ.pi '' univ.pi C) ≤ MeasurableSpace.pi
tactic: apply le_antisymm
Theorem: map_comp_zpow'
File: Mathlib/Algebra/Group/Hom/Defs.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), f x⁻¹ = (f x)⁻¹
g : ι → G
n : ℤ
⊢ ⇑f ∘ (g ^ n) = ⇑f ∘ g ^ n
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), f x⁻¹ = (f x)⁻¹
g : ι → G
n : ℤ
x✝ : ι
⊢ (⇑f ∘ (g ^ n)) x✝ = (⇑f ∘ g ^ n) x✝
tactic: ext
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), f x⁻¹ = (f x)⁻¹
g : ι → G
n : ℤ
x✝ : ι
⊢ (⇑f ∘ (g ^ n)) x✝ = (⇑f ∘ g ^ n) x✝
state_after: no goals
tactic: simp [map_zpow' f hf]
Theorem: ENNReal.tsum_coe_ne_top_iff_summable_coe
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0
⊢ ∑' (a : α), ↑(f a) ≠ ⊤ ↔ Summable fun a => ↑(f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0
⊢ ∑' (a : α), ↑(f a) ≠ ⊤ ↔ Summable f
tactic: rw [NNReal.summable_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0
⊢ ∑' (a : α), ↑(f a) ≠ ⊤ ↔ Summable f
state_after: no goals
tactic: exact tsum_coe_ne_top_iff_summable
Theorem: AlgebraicGeometry.isNoetherian_iff_of_finite_iSup_eq_top
File: Mathlib/AlgebraicGeometry/Noetherian.lean

Proof steps:
state_before: X : Scheme
ι : Sort u_1
inst✝ : Finite ι
S : ι → ↑X.affineOpens
hS : ⨆ i, ↑(S i) = ⊤
⊢ IsNoetherian X ↔ ∀ (i : ι), IsNoetherianRing ↑Γ(X, ↑(S i))
state_after: case mp
X : Scheme
ι : Sort u_1
inst✝ : Finite ι
S : ι → ↑X.affineOpens
hS : ⨆ i, ↑(S i) = ⊤
⊢ IsNoetherian X → ∀ (i : ι), IsNoetherianRing ↑Γ(X, ↑(S i))

case mpr
X : Scheme
ι : Sort u_1
inst✝ : Finite ι
S : ι → ↑X.affineOpens
hS : ⨆ i, ↑(S i) = ⊤
⊢ (∀ (i : ι), IsNoetherianRing ↑Γ(X, ↑(S i))) → IsNoetherian X
tactic: constructor
Theorem: Real.mem_closure_iff
File: Mathlib/Topology/Instances/Real.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Set ℝ
x : ℝ
⊢ x ∈ closure s ↔ ∀ ε > 0, ∃ y ∈ s, |y - x| < ε
state_after: no goals
tactic: simp [mem_closure_iff_nhds_basis nhds_basis_ball, Real.dist_eq]
Theorem: Function.minimalPeriod_eq_prime_pow
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n p k : ℕ
hp : Fact (Nat.Prime p)
hk : ¬IsPeriodicPt f (p ^ k) x
hk1 : IsPeriodicPt f (p ^ (k + 1)) x
⊢ minimalPeriod f x = p ^ (k + 1)
state_after: no goals
tactic: apply Nat.eq_prime_pow_of_dvd_least_prime_pow hp.out <;>
    rwa [← isPeriodicPt_iff_minimalPeriod_dvd]
Theorem: Fin.le_pred_iff
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
j : Fin n
i : Fin (n + 1)
hi : i ≠ 0
⊢ j ≤ i.pred hi ↔ j.succ ≤ i
state_after: no goals
tactic: rw [← succ_le_succ_iff, succ_pred]
Theorem: Finset.image_toFinset
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f g : α → β
s✝ : Finset α
t : Finset β
a : α
b c : β
inst✝ : DecidableEq α
s : Multiset α
x✝ : β
⊢ x✝ ∈ image f s.toFinset ↔ x✝ ∈ (Multiset.map f s).toFinset
state_after: no goals
tactic: simp only [mem_image, Multiset.mem_toFinset, exists_prop, Multiset.mem_map]
Theorem: MeasureTheory.AEEqFun.pair_eq_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : α →ₘ[μ] γ
⊢ f.pair g = mk (fun x => (↑f x, ↑g x)) ⋯
state_after: no goals
tactic: simp only [← pair_mk_mk, mk_coeFn, f.aestronglyMeasurable, g.aestronglyMeasurable]
Theorem: ProbabilityTheory.Kernel.bind_smul
File: Mathlib/Probability/Kernel/Invariance.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
μ : Measure α
r : ℝ≥0∞
⊢ (r • μ).bind ⇑κ = r • μ.bind ⇑κ
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
μ : Measure α
r : ℝ≥0∞
s : Set β
hs : MeasurableSet s
⊢ ((r • μ).bind ⇑κ) s = (r • μ.bind ⇑κ) s
tactic: ext1 s hs
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
μ : Measure α
r : ℝ≥0∞
s : Set β
hs : MeasurableSet s
⊢ ((r • μ).bind ⇑κ) s = (r • μ.bind ⇑κ) s
state_after: no goals
tactic: rw [Measure.bind_apply hs (Kernel.measurable _), lintegral_smul_measure, Measure.coe_smul,
    Pi.smul_apply, Measure.bind_apply hs (Kernel.measurable _), smul_eq_mul]
Theorem: Submodule.exists_isInternal_prime_power_torsion_of_pid
File: Mathlib/Algebra/Module/PID.lean

Proof steps:
state_before: R : Type u
inst✝⁷ : CommRing R
inst✝⁶ : IsDomain R
inst✝⁵ : IsPrincipalIdealRing R
M : Type v
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : Type (max u v)
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
⊢ ∃ ι x x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, DirectSum.IsInternal fun i => torsionBy R M (p i ^ e i)
state_after: case refine_1
R : Type u
inst✝⁷ : CommRing R
inst✝⁶ : IsDomain R
inst✝⁵ : IsPrincipalIdealRing R
M : Type v
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : Type (max u v)
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
⊢ Fintype { x // x ∈ (factors ⊤.annihilator).toFinset }

case refine_2
R : Type u
inst✝⁷ : CommRing R
inst✝⁶ : IsDomain R
inst✝⁵ : IsPrincipalIdealRing R
M : Type v
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : Type (max u v)
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
⊢ ∀ (i : { x // x ∈ (factors ⊤.annihilator).toFinset }), Irreducible (IsPrincipal.generator ↑i)
tactic: refine ⟨_, ?_, _, _, ?_, _, Submodule.isInternal_prime_power_torsion_of_pid hM⟩
Theorem: map_mem_perfectClosure_iff
File: Mathlib/FieldTheory/PurelyInseparable.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
x : E
⊢ i x ∈ perfectClosure F K ↔ x ∈ perfectClosure F E
state_after: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
x : E
⊢ (∃ n, i x ^ ringExpChar F ^ n ∈ (algebraMap F K).range) ↔ ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F E).range
tactic: simp_rw [mem_perfectClosure_iff]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
x : E
⊢ (∃ n, i x ^ ringExpChar F ^ n ∈ (algebraMap F K).range) ↔ ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F E).range
state_after: case refine_1
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
x : E
x✝ : ∃ n, i x ^ ringExpChar F ^ n ∈ (algebraMap F K).range
n : ℕ
y : F
h : (algebraMap F K) y = i x ^ ringExpChar F ^ n
⊢ (algebraMap F E) y = x ^ ringExpChar F ^ n

case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
x : E
x✝ : ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F E).range
n : ℕ
y : F
h : (algebraMap F E) y = x ^ ringExpChar F ^ n
⊢ (algebraMap F K) y = i x ^ ringExpChar F ^ n
tactic: refine ⟨fun ⟨n, y, h⟩ ↦ ⟨n, y, ?_⟩, fun ⟨n, y, h⟩ ↦ ⟨n, y, ?_⟩⟩
state_before: case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
x : E
x✝ : ∃ n, x ^ ringExpChar F ^ n ∈ (algebraMap F E).range
n : ℕ
y : F
h : (algebraMap F E) y = x ^ ringExpChar F ^ n
⊢ (algebraMap F K) y = i x ^ ringExpChar F ^ n
state_after: no goals
tactic: simpa only [AlgHom.commutes, map_pow] using congr_arg i h
Theorem: CategoryTheory.Limits.ImageMap.map_uniq
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
F G : ImageMap sq
⊢ F.map = G.map
state_after: no goals
tactic: apply ImageMap.map_uniq_aux _ F.map_ι _ G.map_ι
Theorem: MonoidAlgebra.single_mul_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
a₁ a₂ : G
b₁ b₂ : k
⊢ single a₁ b₁ * single a₂ b₂ = single (a₁ * a₂) (b₁ * b₂)
state_after: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
a₁ a₂ : G
b₁ b₂ : k
⊢ (sum (single a₁ b₁) fun a₁ b₁ => sum (single a₂ b₂) fun a₂ b₂ => single (a₁ * a₂) (b₁ * b₂)) =
    single (a₁ * a₂) (b₁ * b₂)
tactic: rw [mul_def]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
a₁ a₂ : G
b₁ b₂ : k
⊢ (sum (single a₁ b₁) fun a₁ b₁ => sum (single a₂ b₂) fun a₂ b₂ => single (a₁ * a₂) (b₁ * b₂)) =
    single (a₁ * a₂) (b₁ * b₂)
state_after: no goals
tactic: exact (sum_single_index (by simp only [zero_mul, single_zero, sum_zero])).trans
    (sum_single_index (by rw [mul_zero, single_zero]))
Theorem: div_eq_one
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = b
⊢ a / b = 1
state_after: no goals
tactic: rw [h, div_self']
Theorem: CategoryTheory.SmallObject.functorMap_π
File: Mathlib/CategoryTheory/SmallObject/Construction.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
I : Type w
A B : I → C
f : (i : I) → A i ⟶ B i
S X Y Z : C
πX : X ⟶ S
πY : Y ⟶ S
φ : X ⟶ Y
inst✝³ : HasColimitsOfShape (Discrete (FunctorObjIndex f πX)) C
inst✝² : HasColimitsOfShape (Discrete (FunctorObjIndex f πY)) C
hφ : φ ≫ πY = πX
inst✝¹ : HasPushout (functorObjTop f πX) (functorObjLeft f πX)
inst✝ : HasPushout (functorObjTop f πY) (functorObjLeft f πY)
⊢ functorMap f πX πY φ hφ ≫ πFunctorObj f πY = πFunctorObj f πX
state_after: case h₀
C : Type u
inst✝⁴ : Category.{v, u} C
I : Type w
A B : I → C
f : (i : I) → A i ⟶ B i
S X Y Z : C
πX : X ⟶ S
πY : Y ⟶ S
φ : X ⟶ Y
inst✝³ : HasColimitsOfShape (Discrete (FunctorObjIndex f πX)) C
inst✝² : HasColimitsOfShape (Discrete (FunctorObjIndex f πY)) C
hφ : φ ≫ πY = πX
inst✝¹ : HasPushout (functorObjTop f πX) (functorObjLeft f πX)
inst✝ : HasPushout (functorObjTop f πY) (functorObjLeft f πY)
⊢ pushout.inl (functorObjTop f πX) (functorObjLeft f πX) ≫ functorMap f πX πY φ hφ ≫ πFunctorObj f πY =
    pushout.inl (functorObjTop f πX) (functorObjLeft f πX) ≫ πFunctorObj f πX

case h₁.h.mk
C : Type u
inst✝⁴ : Category.{v, u} C
I : Type w
A B : I → C
f : (i : I) → A i ⟶ B i
S X Y Z : C
πX : X ⟶ S
πY : Y ⟶ S
φ : X ⟶ Y
inst✝³ : HasColimitsOfShape (Discrete (FunctorObjIndex f πX)) C
inst✝² : HasColimitsOfShape (Discrete (FunctorObjIndex f πY)) C
hφ : φ ≫ πY = πX
inst✝¹ : HasPushout (functorObjTop f πX) (functorObjLeft f πX)
inst✝ : HasPushout (functorObjTop f πY) (functorObjLeft f πY)
i : I
t : A i ⟶ X
b : B i ⟶ S
w : t ≫ πX = f i ≫ b
⊢ Sigma.ι (functorObjTgtFamily f πX) { i := i, t := t, b := b, w := w } ≫
      pushout.inr (functorObjTop f πX) (functorObjLeft f πX) ≫ functorMap f πX πY φ hφ ≫ πFunctorObj f πY =
    Sigma.ι (functorObjTgtFamily f πX) { i := i, t := t, b := b, w := w } ≫
      pushout.inr (functorObjTop f πX) (functorObjLeft f πX) ≫ πFunctorObj f πX
tactic: ext ⟨i, t, b, w⟩