ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: cyclotomic_comp_X_add_one_isEisensteinAt
File: Mathlib/RingTheory/Polynomial/Eisenstein/IsIntegral.lean

Proof steps:
state_before: R : Type u
p : ℕ
hp : Fact (Nat.Prime p)
⊢ ((cyclotomic p ℤ).comp (X + 1)).IsEisensteinAt (Submodule.span ℤ {↑p})
state_after: case refine_1
R : Type u
p : ℕ
hp : Fact (Nat.Prime p)
⊢ ((cyclotomic p ℤ).comp (X + 1)).Monic

case refine_2
R : Type u
p : ℕ
hp : Fact (Nat.Prime p)
i : ℕ
hi : i < ((cyclotomic p ℤ).comp (X + 1)).natDegree
⊢ ((cyclotomic p ℤ).comp (X + 1)).coeff i ∈ Submodule.span ℤ {↑p}

case refine_3
R : Type u
p : ℕ
hp : Fact (Nat.Prime p)
⊢ ((cyclotomic p ℤ).comp (X + 1)).coeff 0 ∉ Submodule.span ℤ {↑p} ^ 2
tactic: refine Monic.isEisensteinAt_of_mem_of_not_mem ?_
      (Ideal.IsPrime.ne_top <| (Ideal.span_singleton_prime (mod_cast hp.out.ne_zero)).2 <|
        Nat.prime_iff_prime_int.1 hp.out) (fun {i hi} => ?_) ?_
Theorem: torusMap_eq_center_iff
File: Mathlib/MeasureTheory/Integral/TorusIntegral.lean

Proof steps:
state_before: n : ℕ
E : Type u_1
inst✝ : NormedAddCommGroup E
c : Fin n → ℂ
R θ : Fin n → ℝ
⊢ torusMap c R θ = c ↔ R = 0
state_after: no goals
tactic: simp [funext_iff, torusMap, exp_ne_zero]
Theorem: HurwitzZeta.isBigO_atTop_oddKernel
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : UnitAddCircle
⊢ ∃ p, 0 < p ∧ oddKernel a =O[atTop] fun x => rexp (-p * x)
state_after: case H
b : ℝ
⊢ ∃ p, 0 < p ∧ oddKernel ↑b =O[atTop] fun x => rexp (-p * x)
tactic: induction' a using QuotientAddGroup.induction_on with b
state_before: case H
b : ℝ
⊢ ∃ p, 0 < p ∧ oddKernel ↑b =O[atTop] fun x => rexp (-p * x)
state_after: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
⊢ ∃ p, 0 < p ∧ oddKernel ↑b =O[atTop] fun x => rexp (-p * x)
tactic: obtain ⟨p, hp, hp'⟩ := HurwitzKernelBounds.isBigO_atTop_F_int_one b
state_before: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
⊢ ∃ p, 0 < p ∧ oddKernel ↑b =O[atTop] fun x => rexp (-p * x)
state_after: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
⊢ ∀ᶠ (x : ℝ) in atTop, ‖oddKernel (↑b) x‖ ≤ HurwitzKernelBounds.F_int 1 (↑b) x
tactic: refine ⟨p, hp, (Eventually.isBigO ?_).trans hp'⟩
state_before: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
⊢ ∀ᶠ (x : ℝ) in atTop, ‖oddKernel (↑b) x‖ ≤ HurwitzKernelBounds.F_int 1 (↑b) x
state_after: case h
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ‖oddKernel (↑b) t‖ ≤ HurwitzKernelBounds.F_int 1 (↑b) t
tactic: filter_upwards [eventually_gt_atTop 0] with t ht
state_before: case h
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ‖oddKernel (↑b) t‖ ≤ HurwitzKernelBounds.F_int 1 (↑b) t
state_after: no goals
tactic: simpa only [← (hasSum_int_oddKernel b ht).tsum_eq, Real.norm_eq_abs, HurwitzKernelBounds.F_int,
    HurwitzKernelBounds.f_int, pow_one, norm_mul, abs_of_nonneg (exp_pos _).le] using
    norm_tsum_le_tsum_norm (hasSum_int_oddKernel b ht).summable.norm
Theorem: PadicInt.intCast_eq
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ
this : ↑z1 = ↑z2 ↔ z1 = z2
⊢ ↑z1 = ↑z2 ↔ ↑z1 = ↑z2
state_after: no goals
tactic: norm_cast
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ
⊢ ↑z1 = ↑z2 ↔ z1 = z2
state_after: no goals
tactic: norm_cast
Theorem: FractionalIdeal.spanSingleton_div_spanSingleton
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x y : K
⊢ spanSingleton R₁⁰ x / spanSingleton R₁⁰ y = spanSingleton R₁⁰ (x / y)
state_after: no goals
tactic: rw [div_spanSingleton, mul_comm, spanSingleton_mul_spanSingleton, div_eq_mul_inv]
Theorem: Surreal.Multiplication.mulOptionsLTMul_of_numeric
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
hn : (x * y).Numeric
⊢ (MulOptionsLTMul x y ∧ MulOptionsLTMul (-x) (-y)) ∧ MulOptionsLTMul x (-y) ∧ MulOptionsLTMul (-x) y
state_after: case left
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
hn : (x * y).Numeric
⊢ MulOptionsLTMul x y ∧ MulOptionsLTMul (-x) (-y)

case right
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
hn : (x * y).Numeric
⊢ MulOptionsLTMul x (-y) ∧ MulOptionsLTMul (-x) y
tactic: constructor
Theorem: isIntegralCurve_iff_isIntegralCurveAt
File: Mathlib/Geometry/Manifold/IntegralCurve.lean

Proof steps:
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
h : ∀ (t : ℝ), IsIntegralCurveAt γ v t
t : ℝ
⊢ HasMFDerivAt 𝓘(ℝ, ℝ) I γ t (ContinuousLinearMap.smulRight 1 (v (γ t)))
state_after: case intro.intro
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s✝ s' : Set ℝ
t₀ : ℝ
h✝ : ∀ (t : ℝ), IsIntegralCurveAt γ v t
t : ℝ
s : Set ℝ
hs : s ∈ 𝓝 t
h : IsIntegralCurveOn γ v s
⊢ HasMFDerivAt 𝓘(ℝ, ℝ) I γ t (ContinuousLinearMap.smulRight 1 (v (γ t)))
tactic: obtain ⟨s, hs, h⟩ := isIntegralCurveAt_iff.mp (h t)
state_before: case intro.intro
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s✝ s' : Set ℝ
t₀ : ℝ
h✝ : ∀ (t : ℝ), IsIntegralCurveAt γ v t
t : ℝ
s : Set ℝ
hs : s ∈ 𝓝 t
h : IsIntegralCurveOn γ v s
⊢ HasMFDerivAt 𝓘(ℝ, ℝ) I γ t (ContinuousLinearMap.smulRight 1 (v (γ t)))
state_after: no goals
tactic: exact h t (mem_of_mem_nhds hs)
Theorem: Ideal.exists_ideal_over_prime_of_isIntegral
File: Mathlib/RingTheory/Ideal/Over.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra.IsIntegral R S
P : Ideal R
inst✝ : P.IsPrime
I : Ideal S
hIP : comap (algebraMap R S) I ≤ P
⊢ ∃ Q ≥ I, Q.IsPrime ∧ comap (algebraMap R S) Q = P
state_after: R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra.IsIntegral R S
P : Ideal R
inst✝ : P.IsPrime
I : Ideal S
hIP : comap (algebraMap R S) I ≤ P
P' : Ideal S
hP : P' ≥ I
hP' : P'.IsPrime
hP'' : comap (algebraMap R S) P' ≤ P
⊢ ∃ Q ≥ I, Q.IsPrime ∧ comap (algebraMap R S) Q = P
tactic: have ⟨P', hP, hP', hP''⟩ := exists_ideal_comap_le_prime P I hIP
state_before: R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra.IsIntegral R S
P : Ideal R
inst✝ : P.IsPrime
I : Ideal S
hIP : comap (algebraMap R S) I ≤ P
P' : Ideal S
hP : P' ≥ I
hP' : P'.IsPrime
hP'' : comap (algebraMap R S) P' ≤ P
⊢ ∃ Q ≥ I, Q.IsPrime ∧ comap (algebraMap R S) Q = P
state_after: case intro.intro.intro
R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra.IsIntegral R S
P : Ideal R
inst✝ : P.IsPrime
I : Ideal S
hIP : comap (algebraMap R S) I ≤ P
P' : Ideal S
hP : P' ≥ I
hP' : P'.IsPrime
hP'' : comap (algebraMap R S) P' ≤ P
Q : Ideal S
hQ : Q ≥ P'
hQ' : Q.IsPrime
hQ'' : comap (algebraMap R S) Q = P
⊢ ∃ Q ≥ I, Q.IsPrime ∧ comap (algebraMap R S) Q = P
tactic: obtain ⟨Q, hQ, hQ', hQ''⟩ := exists_ideal_over_prime_of_isIntegral_of_isPrime P P' hP''
state_before: case intro.intro.intro
R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra.IsIntegral R S
P : Ideal R
inst✝ : P.IsPrime
I : Ideal S
hIP : comap (algebraMap R S) I ≤ P
P' : Ideal S
hP : P' ≥ I
hP' : P'.IsPrime
hP'' : comap (algebraMap R S) P' ≤ P
Q : Ideal S
hQ : Q ≥ P'
hQ' : Q.IsPrime
hQ'' : comap (algebraMap R S) Q = P
⊢ ∃ Q ≥ I, Q.IsPrime ∧ comap (algebraMap R S) Q = P
state_after: no goals
tactic: exact ⟨Q, hP.trans hQ, hQ', hQ''⟩
Theorem: Infinite.exists_subset_card_eq
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
inst✝ : Infinite α
n : ℕ
⊢ (map (natEmbedding α) (range n)).card = n
state_after: no goals
tactic: rw [card_map, card_range]
Theorem: Quaternion.star_mul_self
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ star a * a = ↑(normSq a)
state_after: no goals
tactic: rw [star_comm_self, self_mul_star]
Theorem: IsSubgroup.mul_mem_cancel_right
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
s : Set G
hs : IsSubgroup s
h : a ∈ s
hba : b * a ∈ s
⊢ b ∈ s
state_after: no goals
tactic: simpa using hs.mul_mem hba (hs.inv_mem h)
Theorem: MeasureTheory.Measure.prod_sum_left
File: Mathlib/MeasureTheory/Constructions/Prod/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
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ✝ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ι : Type u_7
m : ι → Measure α
μ : Measure β
inst✝ : SFinite μ
⊢ (sum m).prod μ = sum fun i => (m i).prod μ
state_after: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ✝ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ι : Type u_7
m : ι → Measure α
μ : Measure β
inst✝ : SFinite μ
s : Set (α × β)
hs : MeasurableSet s
⊢ ((sum m).prod μ) s = (sum fun i => (m i).prod μ) s
tactic: ext s hs
state_before: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ✝ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ι : Type u_7
m : ι → Measure α
μ : Measure β
inst✝ : SFinite μ
s : Set (α × β)
hs : MeasurableSet s
⊢ ((sum m).prod μ) s = (sum fun i => (m i).prod μ) s
state_after: no goals
tactic: simp only [prod_apply hs, lintegral_sum_measure, hs, sum_apply, ENNReal.tsum_prod']
Theorem: MeasureTheory.setLIntegral_rnDeriv_mul
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
f : α → ℝ≥0∞
hf : AEMeasurable f ν
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x * f x ∂ν = ∫⁻ (x : α) in s, f x ∂μ
state_after: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
f : α → ℝ≥0∞
hf : AEMeasurable f ν
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x * f x ∂ν = ∫⁻ (x : α) in s, f x ∂ν.withDensity (μ.rnDeriv ν)
tactic: nth_rw 2 [← Measure.withDensity_rnDeriv_eq μ ν hμν]
state_before: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
f : α → ℝ≥0∞
hf : AEMeasurable f ν
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x * f x ∂ν = ∫⁻ (x : α) in s, f x ∂ν.withDensity (μ.rnDeriv ν)
state_after: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
f : α → ℝ≥0∞
hf : AEMeasurable f ν
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x * f x ∂ν = ∫⁻ (a : α) in s, (μ.rnDeriv ν * f) a ∂ν
tactic: rw [setLIntegral_withDensity_eq_lintegral_mul₀ (measurable_rnDeriv μ ν).aemeasurable hf hs]
state_before: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
f : α → ℝ≥0∞
hf : AEMeasurable f ν
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x * f x ∂ν = ∫⁻ (a : α) in s, (μ.rnDeriv ν * f) a ∂ν
state_after: no goals
tactic: simp only [Pi.mul_apply]
Theorem: SimpleGraph.edgeSet_deleteEdges
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
H : SimpleGraph V
s✝ s₁ s₂ s : Set (Sym2 V)
⊢ (G.deleteEdges s).edgeSet = G.edgeSet \ s
state_after: no goals
tactic: simp [deleteEdges]
Theorem: IsGroupHom.injective_iff
File: Mathlib/Deprecated/Group.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f✝ : α → β
hf✝ : IsGroupHom f✝
f : α → β
hf : IsGroupHom f
h : Function.Injective f
x✝ : α
⊢ f x✝ = 1 → x✝ = 1
state_after: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f✝ : α → β
hf✝ : IsGroupHom f✝
f : α → β
hf : IsGroupHom f
h : Function.Injective f
x✝ : α
⊢ f x✝ = f 1 → x✝ = 1
tactic: rw [← hf.map_one]
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f✝ : α → β
hf✝ : IsGroupHom f✝
f : α → β
hf : IsGroupHom f
h : Function.Injective f
x✝ : α
⊢ f x✝ = f 1 → x✝ = 1
state_after: no goals
tactic: exact @h _ _
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f✝ : α → β
hf✝ : IsGroupHom f✝
f : α → β
hf : IsGroupHom f
h : ∀ (a : α), f a = 1 → a = 1
x y : α
hxy : f x = f y
⊢ f (x / y) = 1
state_after: no goals
tactic: rwa [hf.map_div, div_eq_one]
Theorem: vsub_midpoint
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p₁ p₂ p : P
⊢ p -ᵥ midpoint R p₁ p₂ = ⅟2 • (p -ᵥ p₁) + ⅟2 • (p -ᵥ p₂)
state_after: no goals
tactic: rw [← neg_vsub_eq_vsub_rev, midpoint_vsub, neg_add, ← smul_neg, ← smul_neg, neg_vsub_eq_vsub_rev,
    neg_vsub_eq_vsub_rev]
Theorem: LieAlgebra.Orthogonal.pso_inv
File: Mathlib/Algebra/Lie/Classical.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
⊢ Pso p q R i * Pso p q R (-i) = 1
state_after: case a
n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : p ⊕ q
⊢ (Pso p q R i * Pso p q R (-i)) x y = 1 x y
tactic: ext (x y)
state_before: case a
n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : p ⊕ q
⊢ (Pso p q R i * Pso p q R (-i)) x y = 1 x y
state_after: case a.inl.inl
n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : p
⊢ (Pso p q R i * Pso p q R (-i)) (Sum.inl x) (Sum.inl y) = 1 (Sum.inl x) (Sum.inl y)

case a.inl.inr
n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x : p
y : q
⊢ (Pso p q R i * Pso p q R (-i)) (Sum.inl x) (Sum.inr y) = 1 (Sum.inl x) (Sum.inr y)

case a.inr.inl
n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x : q
y : p
⊢ (Pso p q R i * Pso p q R (-i)) (Sum.inr x) (Sum.inl y) = 1 (Sum.inr x) (Sum.inl y)

case a.inr.inr
n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : q
⊢ (Pso p q R i * Pso p q R (-i)) (Sum.inr x) (Sum.inr y) = 1 (Sum.inr x) (Sum.inr y)
tactic: rcases x with ⟨x⟩|⟨x⟩ <;> rcases y with ⟨y⟩|⟨y⟩
Theorem: ComplexShape.Embedding.boundaryGE
File: Mathlib/Algebra/Homology/Embedding/Boundary.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i' : ι'
j : ι
hj : c'.Rel i' (e.f j)
hi' : ∀ (i : ι), e.f i ≠ i'
⊢ e.BoundaryGE j
state_after: case left
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i' : ι'
j : ι
hj : c'.Rel i' (e.f j)
hi' : ∀ (i : ι), e.f i ≠ i'
⊢ c'.Rel (c'.prev (e.f j)) (e.f j)

case right
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i' : ι'
j : ι
hj : c'.Rel i' (e.f j)
hi' : ∀ (i : ι), e.f i ≠ i'
⊢ ∀ (i : ι), ¬c'.Rel (e.f i) (e.f j)
tactic: constructor
Theorem: Fin.insertNth_zero_right
File: Mathlib/Algebra/Group/Fin/Tuple.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u_1
inst✝ : (j : Fin (n + 1)) → One (α j)
i : Fin (n + 1)
x : α i
⊢ x = Pi.mulSingle i x i ∧ 1 = i.removeNth (Pi.mulSingle i x)
state_after: m n : ℕ
α : Fin (n + 1) → Type u_1
inst✝ : (j : Fin (n + 1)) → One (α j)
i : Fin (n + 1)
x : α i
⊢ x = Pi.mulSingle i x i ∧ 1 = fun i_1 => Pi.mulSingle i x (i.succAbove i_1)
tactic: unfold removeNth
state_before: m n : ℕ
α : Fin (n + 1) → Type u_1
inst✝ : (j : Fin (n + 1)) → One (α j)
i : Fin (n + 1)
x : α i
⊢ x = Pi.mulSingle i x i ∧ 1 = fun i_1 => Pi.mulSingle i x (i.succAbove i_1)
state_after: no goals
tactic: simp [succAbove_ne, Pi.one_def]
Theorem: Finset.addEnergy_empty_left
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ Eₘ[∅, t] = 0
state_after: no goals
tactic: simp [mulEnergy]
Theorem: LinearRecurrence.is_sol_mkSol
File: Mathlib/Algebra/LinearRecurrence.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
⊢ E.IsSolution (E.mkSol init)
state_after: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
n : ℕ
⊢ E.mkSol init (n + E.order) = ∑ i : Fin E.order, E.coeffs i * E.mkSol init (n + ↑i)
tactic: intro n
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
n : ℕ
⊢ E.mkSol init (n + E.order) = ∑ i : Fin E.order, E.coeffs i * E.mkSol init (n + ↑i)
state_after: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
n : ℕ
⊢ (if h : n + E.order < E.order then init ⟨n + E.order, h⟩
    else
      ∑ k : Fin E.order,
        let_fun x := ⋯;
        E.coeffs k * E.mkSol init (n + E.order - E.order + ↑k)) =
    ∑ i : Fin E.order, E.coeffs i * E.mkSol init (n + ↑i)
tactic: rw [mkSol]
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
n : ℕ
⊢ (if h : n + E.order < E.order then init ⟨n + E.order, h⟩
    else
      ∑ k : Fin E.order,
        let_fun x := ⋯;
        E.coeffs k * E.mkSol init (n + E.order - E.order + ↑k)) =
    ∑ i : Fin E.order, E.coeffs i * E.mkSol init (n + ↑i)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ShortComplex.Splitting.unop_s
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.124213, u_1} C
inst✝² : Category.{?u.124217, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S✝ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.Splitting
⊢ (S.unop.f ≫ h.s.unop).op = (𝟙 S.unop.X₁).op
state_after: no goals
tactic: simp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.124213, u_1} C
inst✝² : Category.{?u.124217, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S✝ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.Splitting
⊢ (h.r.unop ≫ S.unop.g).op = (𝟙 S.unop.X₃).op
state_after: no goals
tactic: simp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.124213, u_1} C
inst✝² : Category.{?u.124217, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S✝ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.Splitting
⊢ (h.s.unop ≫ S.unop.f + S.unop.g ≫ h.r.unop).op = (𝟙 S.unop.X₂).op
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.124213, u_1} C
inst✝² : Category.{?u.124217, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S✝ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.Splitting
⊢ S.g ≫ h.s + h.r ≫ S.f = h.r ≫ S.f + S.g ≫ h.s
tactic: simp only [unop_X₂, Opposite.op_unop, unop_X₁, unop_f, unop_X₃, unop_g, op_add,
      op_comp, Quiver.Hom.op_unop, op_id, ← h.id]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.124213, u_1} C
inst✝² : Category.{?u.124217, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S✝ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.Splitting
⊢ S.g ≫ h.s + h.r ≫ S.f = h.r ≫ S.f + S.g ≫ h.s
state_after: no goals
tactic: abel
Theorem: CategoryTheory.Iso.inv_hom_id_eval
File: Mathlib/CategoryTheory/GradedObject.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
J : Type u_4
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{?u.7315, u_2} D
inst✝ : Category.{?u.7319, u_3} E
X Y : GradedObject J C
e : X ≅ Y
j : J
⊢ e.inv j ≫ e.hom j = 𝟙 (Y j)
state_after: no goals
tactic: rw [← GradedObject.categoryOfGradedObjects_comp, e.inv_hom_id,
    GradedObject.categoryOfGradedObjects_id]
Theorem: List.getElem_range
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: n m : Nat
h : m < (range n).length
⊢ (range n)[m] = m
state_after: no goals
tactic: simp [range_eq_range']
Theorem: Matrix.inv_diagonal
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
⊢ (diagonal v)⁻¹ = diagonal (Ring.inverse v)
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)
tactic: rw [nonsing_inv_eq_ring_inverse]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)
state_after: case pos
l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
h : IsUnit v
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)

case neg
l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
v : n → α
h : ¬IsUnit v
⊢ Ring.inverse (diagonal v) = diagonal (Ring.inverse v)
tactic: by_cases h : IsUnit v