ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsLocalization.AtPrime.prime_unique_of_minimal
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : CommSemiring R
I : Ideal R
hI : I.IsPrime
hMin : I ∈ minimalPrimes R
S : Type u_2
inst✝⁴ : CommSemiring S
inst✝³ : Algebra R S
inst✝² : IsLocalization.AtPrime S I
J K : Ideal S
inst✝¹ : J.IsPrime
inst✝ : K.IsPrime
i₁ i₂ : { i // i.IsPrime ∧ i ≤ I }
⊢ ↑i₁ = ↑i₂
state_after: R : Type u_1
inst✝⁵ : CommSemiring R
I : Ideal R
hI : I.IsPrime
hMin : I ∈ minimals (fun x x_1 => x ≤ x_1) (setOf Ideal.IsPrime)
S : Type u_2
inst✝⁴ : CommSemiring S
inst✝³ : Algebra R S
inst✝² : IsLocalization.AtPrime S I
J K : Ideal S
inst✝¹ : J.IsPrime
inst✝ : K.IsPrime
i₁ i₂ : { i // i.IsPrime ∧ i ≤ I }
⊢ ↑i₁ = ↑i₂
tactic: rw [minimalPrimes_eq_minimals] at hMin
state_before: R : Type u_1
inst✝⁵ : CommSemiring R
I : Ideal R
hI : I.IsPrime
hMin : I ∈ minimals (fun x x_1 => x ≤ x_1) (setOf Ideal.IsPrime)
S : Type u_2
inst✝⁴ : CommSemiring S
inst✝³ : Algebra R S
inst✝² : IsLocalization.AtPrime S I
J K : Ideal S
inst✝¹ : J.IsPrime
inst✝ : K.IsPrime
i₁ i₂ : { i // i.IsPrime ∧ i ≤ I }
⊢ ↑i₁ = ↑i₂
state_after: no goals
tactic: rw [← eq_of_mem_minimals hMin i₁.2.1 i₁.2.2, ← eq_of_mem_minimals hMin i₂.2.1 i₂.2.2]
Theorem: List.prod_map_neg
File: Mathlib/Algebra/BigOperators/Ring/List.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
M : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝¹ : CommMonoid M
inst✝ : HasDistribNeg M
l : List M
⊢ (map Neg.neg l).prod = (-1) ^ l.length * l.prod
state_after: no goals
tactic: induction l <;> simp [*, pow_succ, ((Commute.neg_one_left _).pow_left _).left_comm]
Theorem: Mathlib.Tactic.Abel.subst_into_smulg
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
l : ℤ
r : α
tl : ℤ
tr t : α
prl : l = tl
prr : r = tr
prt : smulg tl tr = t
⊢ smulg l r = t
state_after: no goals
tactic: simp [prl, prr, prt]
Theorem: MeasurableSpace.measurableSet_iSup
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι✝ : Sort u_6
s✝ t u : Set α
ι : Sort u_7
m : ι → MeasurableSpace α
s : Set α
⊢ MeasurableSet s ↔ GenerateMeasurable {s | ∃ i, MeasurableSet s} s
state_after: no goals
tactic: simp only [iSup, measurableSet_sSup, exists_range_iff]
Theorem: GaussianFourier.integral_rexp_neg_mul_sq_norm
File: Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean

Proof steps:
state_before: b✝ : ℂ
V : Type u_1
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : FiniteDimensional ℝ V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
b : ℝ
hb : 0 < b
⊢ ∫ (v : V), rexp (-b * ‖v‖ ^ 2) = (π / b) ^ (↑(FiniteDimensional.finrank ℝ V) / 2)
state_after: b✝ : ℂ
V : Type u_1
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : FiniteDimensional ℝ V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
b : ℝ
hb : 0 < b
⊢ ↑(∫ (v : V), rexp (-b * ‖v‖ ^ 2)) = ↑((π / b) ^ (↑(FiniteDimensional.finrank ℝ V) / 2))
tactic: rw [← ofReal_inj]
state_before: b✝ : ℂ
V : Type u_1
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : FiniteDimensional ℝ V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
b : ℝ
hb : 0 < b
⊢ ↑(∫ (v : V), rexp (-b * ‖v‖ ^ 2)) = ↑((π / b) ^ (↑(FiniteDimensional.finrank ℝ V) / 2))
state_after: case h.e'_2
b✝ : ℂ
V : Type u_1
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : FiniteDimensional ℝ V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
b : ℝ
hb : 0 < b
⊢ ↑(∫ (v : V), rexp (-b * ‖v‖ ^ 2)) = ∫ (v : V), cexp (-↑b * ↑‖v‖ ^ 2)

case h.e'_3
b✝ : ℂ
V : Type u_1
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : FiniteDimensional ℝ V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
b : ℝ
hb : 0 < b
⊢ ↑((π / b) ^ (↑(FiniteDimensional.finrank ℝ V) / 2)) = (↑π / ↑b) ^ (↑(FiniteDimensional.finrank ℝ V) / 2)
tactic: convert integral_cexp_neg_mul_sq_norm (show 0 < (b : ℂ).re from hb) (V := V)
Theorem: Ideal.finite_mulSupport_coe
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ (mulSupport fun v => ↑v.asIdeal ^ ↑((Associates.mk v.asIdeal).count (Associates.mk I).factors)).Finite
state_after: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ {x | ↑x.asIdeal ^ ↑((Associates.mk x.asIdeal).count (Associates.mk I).factors) ≠ 1}.Finite
tactic: rw [mulSupport]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ {x | ↑x.asIdeal ^ ↑((Associates.mk x.asIdeal).count (Associates.mk I).factors) ≠ 1}.Finite
state_after: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ {x | ¬x.asIdeal ^ (Associates.mk x.asIdeal).count (Associates.mk I).factors = 1}.Finite
tactic: simp_rw [Ne, zpow_natCast, ← FractionalIdeal.coeIdeal_pow, FractionalIdeal.coeIdeal_eq_one]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ {x | ¬x.asIdeal ^ (Associates.mk x.asIdeal).count (Associates.mk I).factors = 1}.Finite
state_after: no goals
tactic: exact finite_mulSupport hI
Theorem: CondensedSet.continuous_coinducingCoprod
File: Mathlib/Condensed/TopCatAdjunction.lean

Proof steps:
state_before: X : CondensedSet
S : CompHaus
x : X.val.obj (Opposite.op S)
⊢ Continuous fun a => CondensedSet.coinducingCoprod X ⟨⟨S, x⟩, a⟩
state_after: X : CondensedSet
S : CompHaus
x : X.val.obj (Opposite.op S)
⊢ ∀ (i : (T : CompHaus) × X.val.obj (Opposite.op T)), Continuous fun a => CondensedSet.coinducingCoprod X ⟨i, a⟩
tactic: suffices ∀ (i : (T : CompHaus.{u}) × X.val.obj ⟨T⟩),
      Continuous (fun (a : i.fst) ↦ X.coinducingCoprod ⟨i, a⟩) from this ⟨_, _⟩
state_before: X : CondensedSet
S : CompHaus
x : X.val.obj (Opposite.op S)
⊢ ∀ (i : (T : CompHaus) × X.val.obj (Opposite.op T)), Continuous fun a => CondensedSet.coinducingCoprod X ⟨i, a⟩
state_after: X : CondensedSet
S : CompHaus
x : X.val.obj (Opposite.op S)
⊢ Continuous (CondensedSet.coinducingCoprod X)
tactic: rw [← continuous_sigma_iff]
state_before: X : CondensedSet
S : CompHaus
x : X.val.obj (Opposite.op S)
⊢ Continuous (CondensedSet.coinducingCoprod X)
state_after: no goals
tactic: apply continuous_coinduced_rng
Theorem: Real.exists_isGLB
File: Mathlib/Data/Real/Archimedean.lean

Proof steps:
state_before: S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
⊢ ∃ x, IsGLB S x
state_after: S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
hne' : (-S).Nonempty
⊢ ∃ x, IsGLB S x
tactic: have hne' : (-S).Nonempty := Set.nonempty_neg.mpr hne
state_before: S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
hne' : (-S).Nonempty
⊢ ∃ x, IsGLB S x
state_after: S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
hne' : (-S).Nonempty
hbdd' : BddAbove (-S)
⊢ ∃ x, IsGLB S x
tactic: have hbdd' : BddAbove (-S) := bddAbove_neg.mpr hbdd
state_before: S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
hne' : (-S).Nonempty
hbdd' : BddAbove (-S)
⊢ ∃ x, IsGLB S x
state_after: case h
S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
hne' : (-S).Nonempty
hbdd' : BddAbove (-S)
⊢ IsGLB S (-Classical.choose ⋯)
tactic: use -Classical.choose (Real.exists_isLUB hne' hbdd')
state_before: case h
S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
hne' : (-S).Nonempty
hbdd' : BddAbove (-S)
⊢ IsGLB S (-Classical.choose ⋯)
state_after: case h
S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
hne' : (-S).Nonempty
hbdd' : BddAbove (-S)
⊢ IsLUB (-S) (Classical.choose ⋯)
tactic: rw [← isLUB_neg]
state_before: case h
S : Set ℝ
hne : S.Nonempty
hbdd : BddBelow S
hne' : (-S).Nonempty
hbdd' : BddAbove (-S)
⊢ IsLUB (-S) (Classical.choose ⋯)
state_after: no goals
tactic: exact Classical.choose_spec (Real.exists_isLUB hne' hbdd')
Theorem: tendsto_iff_norm_sub_tendsto_zero
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
f : α → E
a : Filter α
b : E
⊢ Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0)
state_after: no goals
tactic: simp only [← dist_eq_norm_div, ← tendsto_iff_dist_tendsto_zero]
Theorem: Equiv.piSplitAt_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : β i × ((j : { j // j ≠ i }) → β ↑j)
⊢ (fun f => (f i, fun j => f ↑j)) ((fun f j => if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩) f) = f
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : β i × ((j : { j // j ≠ i }) → β ↑j)
⊢ ((fun f => (f i, fun j => f ↑j)) ((fun f j => if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩) f)).1 = f.1

case a.h
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : β i × ((j : { j // j ≠ i }) → β ↑j)
x : { j // j ≠ i }
⊢ ((fun f => (f i, fun j => f ↑j)) ((fun f j => if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩) f)).2 x = f.2 x
tactic: ext x
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : β i × ((j : { j // j ≠ i }) → β ↑j)
⊢ ((fun f => (f i, fun j => f ↑j)) ((fun f j => if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩) f)).1 = f.1

case a.h
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : β i × ((j : { j // j ≠ i }) → β ↑j)
x : { j // j ≠ i }
⊢ ((fun f => (f i, fun j => f ↑j)) ((fun f j => if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩) f)).2 x = f.2 x
state_after: no goals
tactic: exacts [dif_pos rfl, (dif_neg x.2).trans (by cases x; rfl)]
state_before: α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : (j : α) → β j
⊢ (fun f j => if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩) ((fun f => (f i, fun j => f ↑j)) f) = f
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : (j : α) → β j
x : α
⊢ (fun f j => if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩) ((fun f => (f i, fun j => f ↑j)) f) x = f x
tactic: ext x
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : (j : α) → β j
x : α
⊢ (fun f j => if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩) ((fun f => (f i, fun j => f ↑j)) f) x = f x
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : (j : α) → β j
x : α
⊢ (if h : x = i then ⋯ ▸ f i else f x) = f x
tactic: dsimp only
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : (j : α) → β j
x : α
⊢ (if h : x = i then ⋯ ▸ f i else f x) = f x
state_after: case pos
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : (j : α) → β j
x : α
h : x = i
⊢ ⋯ ▸ f i = f x

case neg
α : Type u_1
inst✝ : DecidableEq α
i : α
β : α → Type u_2
f : (j : α) → β j
x : α
h : ¬x = i
⊢ f x = f x
tactic: split_ifs with h
Theorem: Polynomial.rootMultiplicity_eq_rootMultiplicity
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
⊢ rootMultiplicity t p = rootMultiplicity 0 (p.comp (X + C t))
state_after: no goals
tactic: classical
  simp_rw [rootMultiplicity_eq_multiplicity, comp_X_add_C_eq_zero_iff]
  congr; ext; congr 1
  rw [C_0, sub_zero]
  convert (multiplicity.multiplicity_map_eq <| algEquivAevalXAddC t).symm using 2
  simp [C_eq_algebraMap]
Theorem: Algebra.discr_localizationLocalization
File: Mathlib/RingTheory/Localization/NormTrace.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝²¹ : CommRing R
inst✝²⁰ : CommRing S
inst✝¹⁹ : Algebra R S
Rₘ : Type u_3
Sₘ✝ : Type u_4
inst✝¹⁸ : CommRing Rₘ
inst✝¹⁷ : Algebra R Rₘ
inst✝¹⁶ : CommRing Sₘ✝
inst✝¹⁵ : Algebra S Sₘ✝
M : Submonoid R
inst✝¹⁴ : IsLocalization M Rₘ
inst✝¹³ : IsLocalization (algebraMapSubmonoid S M) Sₘ✝
inst✝¹² : Algebra Rₘ Sₘ✝
inst✝¹¹ : Algebra R Sₘ✝
inst✝¹⁰ : IsScalarTower R Rₘ Sₘ✝
inst✝⁹ : IsScalarTower R S Sₘ✝
Sₘ : Type u_5
inst✝⁸ : CommRing Sₘ
inst✝⁷ : Algebra S Sₘ
inst✝⁶ : Algebra Rₘ Sₘ
inst✝⁵ : Algebra R Sₘ
inst✝⁴ : IsScalarTower R Rₘ Sₘ
inst✝³ : IsScalarTower R S Sₘ
inst✝² : IsLocalization (algebraMapSubmonoid S M) Sₘ
ι : Type u_6
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : Basis ι R S
⊢ discr Rₘ ⇑(Basis.localizationLocalization Rₘ M Sₘ b) = (algebraMap R Rₘ) (discr R ⇑b)
state_after: no goals
tactic: rw [Algebra.discr_def, Algebra.discr_def, RingHom.map_det,
    Algebra.traceMatrix_localizationLocalization]
Theorem: contDiff_succ_iff_hasFDerivAt
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f ↔ ∃ f', ContDiff 𝕜 (↑n) f' ∧ ∀ (x : E), HasFDerivAt f (f' x) x
state_after: no goals
tactic: simp only [← contDiffOn_univ, ← hasFDerivWithinAt_univ,
    contDiffOn_succ_iff_hasFDerivWithin uniqueDiffOn_univ, Set.mem_univ, forall_true_left]
Theorem: Submodule.iInf_comap_proj
File: Mathlib/LinearAlgebra/Pi.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝² : Semiring R
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x : (i : ι) → φ i
⊢ ⨅ i, comap (proj i) (p i) = pi Set.univ p
state_after: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝² : Semiring R
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x✝ x : (i : ι) → φ i
⊢ x ∈ ⨅ i, comap (proj i) (p i) ↔ x ∈ pi Set.univ p
tactic: ext x
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝² : Semiring R
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x✝ x : (i : ι) → φ i
⊢ x ∈ ⨅ i, comap (proj i) (p i) ↔ x ∈ pi Set.univ p
state_after: no goals
tactic: simp
Theorem: DilationEquiv.coe_pow
File: Mathlib/Topology/MetricSpace/DilationEquiv.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
e : X ≃ᵈ X
n : ℕ
⊢ ⇑(e ^ n) = (⇑e)^[n]
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
e : X ≃ᵈ X
n : ℕ
⊢ (⇑(toPerm e))^[n] = (⇑e)^[n]
tactic: rw [← coe_toEquiv, ← toPerm_apply, map_pow, Equiv.Perm.coe_pow]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
e : X ≃ᵈ X
n : ℕ
⊢ (⇑(toPerm e))^[n] = (⇑e)^[n]
state_after: no goals
tactic: rfl
Theorem: LocallyConstant.mapMonoidHom_apply
File: Mathlib/Topology/LocallyConstant/Algebra.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
α : Type u_3
R✝ : Type u_4
R : Type u_5
Z : Type u_6
inst✝¹ : MulOneClass Y
inst✝ : MulOneClass Z
f : Y →* Z
⊢ map (⇑f) 1 = 1
state_after: no goals
tactic: aesop
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
α : Type u_3
R✝ : Type u_4
R : Type u_5
Z : Type u_6
inst✝¹ : MulOneClass Y
inst✝ : MulOneClass Z
f : Y →* Z
⊢ ∀ (x y : LocallyConstant X Y),
    { toFun := map ⇑f, map_one' := ⋯ }.toFun (x * y) =
      { toFun := map ⇑f, map_one' := ⋯ }.toFun x * { toFun := map ⇑f, map_one' := ⋯ }.toFun y
state_after: no goals
tactic: aesop
Theorem: MeasureTheory.Measure.Subtype.volume_univ
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
u : Set δ
inst✝ : MeasureSpace δ
p : δ → Prop
hu : NullMeasurableSet u volume
⊢ volume univ = volume u
state_after: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
u : Set δ
inst✝ : MeasureSpace δ
p : δ → Prop
hu : NullMeasurableSet u volume
⊢ volume (Subtype.val '' univ) = volume u

R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
u : Set δ
inst✝ : MeasureSpace δ
p : δ → Prop
hu : NullMeasurableSet u volume
⊢ Injective Subtype.val

R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
u : Set δ
inst✝ : MeasureSpace δ
p : δ → Prop
hu : NullMeasurableSet u volume
⊢ ∀ (s : Set { x // x ∈ u }), MeasurableSet s → NullMeasurableSet (Subtype.val '' s) volume
tactic: rw [Subtype.volume_def, comap_apply₀ _ _ _ _ MeasurableSet.univ.nullMeasurableSet]
Theorem: Num.cmp_to_nat
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a b : PosNum
⊢ Ordering.casesOn ((pos a).cmp (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))
state_after: α : Type u_1
a b : PosNum
this : Ordering.casesOn (a.cmp b) (↑a < ↑b) (a = b) (↑b < ↑a)
⊢ Ordering.casesOn ((pos a).cmp (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))
tactic: have := PosNum.cmp_to_nat a b
state_before: α : Type u_1
a b : PosNum
this : Ordering.casesOn (a.cmp b) (↑a < ↑b) (a = b) (↑b < ↑a)
⊢ Ordering.casesOn ((pos a).cmp (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))
state_after: α : Type u_1
a b : PosNum
⊢ Ordering.casesOn (a.cmp b) (↑a < ↑b) (a = b) (↑b < ↑a) →
    Ordering.casesOn ((pos a).cmp (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))
tactic: revert this
state_before: α : Type u_1
a b : PosNum
⊢ Ordering.casesOn (a.cmp b) (↑a < ↑b) (a = b) (↑b < ↑a) →
    Ordering.casesOn ((pos a).cmp (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))
state_after: α : Type u_1
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) (a.cmp b) → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) (a.cmp b)
tactic: dsimp [cmp]
state_before: α : Type u_1
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) (a.cmp b) → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) (a.cmp b)
state_after: case lt
α : Type u_1
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.lt → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.lt

case eq
α : Type u_1
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.eq → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.eq

case gt
α : Type u_1
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.gt → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.gt
tactic: cases PosNum.cmp a b
state_before: case lt
α : Type u_1
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.lt → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.lt

case eq
α : Type u_1
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.eq → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.eq

case gt
α : Type u_1
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.gt → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.gt
state_after: no goals
tactic: exacts [id, congr_arg pos, id]
Theorem: Equiv.Perm.SameCycle.toList_isRotated
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : f.SameCycle x y
⊢ f.toList x ~r f.toList y
state_after: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : f.SameCycle x y
hx : x ∈ f.support
⊢ f.toList x ~r f.toList y

case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : f.SameCycle x y
hx : x ∉ f.support
⊢ f.toList x ~r f.toList y
tactic: by_cases hx : x ∈ f.support
Theorem: CochainComplex.HomComplex.Cochain.add_comp
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ z₁' : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
⊢ (z₁ + z₁').comp z₂ h = z₁.comp z₂ h + z₁'.comp z₂ h
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ z₁' : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ ((z₁ + z₁').comp z₂ h).v p q hpq = (z₁.comp z₂ h + z₁'.comp z₂ h).v p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ z₁' : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ ((z₁ + z₁').comp z₂ h).v p q hpq = (z₁.comp z₂ h + z₁'.comp z₂ h).v p q hpq
state_after: no goals
tactic: simp only [comp_v _ _ h p _ q rfl (by omega), add_v, add_comp]
Theorem: Set.inv_smul_set_distrib
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
⊢ (a • s)⁻¹ = op a⁻¹ • s⁻¹
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
x✝ : α
⊢ x✝ ∈ (a • s)⁻¹ ↔ x✝ ∈ op a⁻¹ • s⁻¹
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
x✝ : α
⊢ x✝ ∈ (a • s)⁻¹ ↔ x✝ ∈ op a⁻¹ • s⁻¹
state_after: no goals
tactic: simp [mem_smul_set_iff_inv_smul_mem]