ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearMap.ker_zero
File: Mathlib/Algebra/Module/Submodule/Ker.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
K : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁶ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_12
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
x : M
⊢ x ∈ ker 0
state_after: no goals
tactic: simp
Theorem: MvPolynomial.finSuccEquiv_X_succ
File: Mathlib/Algebra/MvPolynomial/Equiv.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 : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
j : Fin n
⊢ (finSuccEquiv R n) (X j.succ) = Polynomial.C (X j)
state_after: no goals
tactic: simp
Theorem: PiTensorProduct.mapL_smul
File: Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean

Proof steps:
state_before: ι : Type uι
inst✝¹⁰ : Fintype ι
𝕜 : Type u𝕜
inst✝⁹ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁸ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁷ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁶ : SeminormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝³ : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝² : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
inst✝ : DecidableEq ι
i : ι
c : 𝕜
u : E i →L[𝕜] E' i
⊢ mapL (update f i (c • u)) = c • mapL (update f i u)
state_after: case h
ι : Type uι
inst✝¹⁰ : Fintype ι
𝕜 : Type u𝕜
inst✝⁹ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁸ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁷ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁶ : SeminormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝³ : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝² : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
inst✝ : DecidableEq ι
i : ι
c : 𝕜
u : E i →L[𝕜] E' i
x : ⨂[𝕜] (i : ι), E i
⊢ (mapL (update f i (c • u))) x = (c • mapL (update f i u)) x
tactic: ext x
state_before: case h
ι : Type uι
inst✝¹⁰ : Fintype ι
𝕜 : Type u𝕜
inst✝⁹ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁸ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁷ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁶ : SeminormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝³ : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝² : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
inst✝ : DecidableEq ι
i : ι
c : 𝕜
u : E i →L[𝕜] E' i
x : ⨂[𝕜] (i : ι), E i
⊢ (mapL (update f i (c • u))) x = (c • mapL (update f i u)) x
state_after: no goals
tactic: simp only [mapL_apply, mapL_add_smul_aux, ContinuousLinearMap.coe_smul, PiTensorProduct.map_smul,
    LinearMap.smul_apply, ContinuousLinearMap.coe_smul', Pi.smul_apply]
Theorem: DirectSum.IsInternal.collectedOrthonormalBasis_mem
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹¹ : _root_.RCLike 𝕜
E : Type u_4
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁸ : NormedAddCommGroup E'
inst✝⁷ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : InnerProductSpace ℝ F
F' : Type u_7
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : InnerProductSpace ℝ F'
inst✝² : Fintype ι
v✝ : Set E
A : ι → Submodule 𝕜 E
inst✝¹ : DecidableEq ι
h : IsInternal A
α : ι → Type u_8
inst✝ : (i : ι) → Fintype (α i)
hV : OrthogonalFamily 𝕜 (fun i => ↥(A i)) fun i => (A i).subtypeₗᵢ
v : (i : ι) → OrthonormalBasis (α i) 𝕜 ↥(A i)
a : (i : ι) × α i
⊢ (collectedOrthonormalBasis hV h v) a ∈ A a.fst
state_after: no goals
tactic: simp [DirectSum.IsInternal.collectedOrthonormalBasis]
Theorem: sdiff_idem
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ (a \ b) \ b = a \ b
state_after: no goals
tactic: rw [sdiff_sdiff_left, sup_idem]
Theorem: _private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.0.WeierstrassCurve.Jacobian.nonsingular_neg_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hP : W.Nonsingular P
hPz : P z ≠ 0
⊢ W.Nonsingular ![P x / P z ^ 2, W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3), 1]
state_after: no goals
tactic: exact (nonsingular_some ..).mpr <| Affine.nonsingular_neg <| (nonsingular_of_Z_ne_zero hPz).mp hP
Theorem: CategoryTheory.Adjunction.restrictFullyFaithful_homEquiv_apply
File: Mathlib/CategoryTheory/Adjunction/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : C
Y : D
f : L.obj X ⟶ Y
⊢ ((adj.restrictFullyFaithful hiC hiD comm1 comm2).homEquiv X Y) f =
    hiC.preimage (adj.unit.app (iC.obj X) ≫ R'.map (comm1.hom.app X) ≫ R'.map (iD.map f) ≫ comm2.hom.app Y)
state_after: no goals
tactic: simp [restrictFullyFaithful]
Theorem: AddAction.zsmul_period_add_vadd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
i : ℤ
g : G
a : α
⊢ g ^ (↑(period g a) + i) • a = g ^ i • a
state_after: no goals
tactic: rw [← zpow_mod_period_smul, Int.add_emod_self_left, zpow_mod_period_smul]
Theorem: Matrix.transpose_eq_diagonal
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : DecidableEq n
inst✝ : Zero α
M : Matrix n n α
v : n → α
⊢ M = (diagonal v)ᵀ ↔ M = diagonal v
state_after: no goals
tactic: rw [diagonal_transpose]
Theorem: Filter.eventually_lt_of_lt_liminf
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder β
u : α → β
b : β
h : b < liminf u f
hu : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝
⊢ ∀ᶠ (a : α) in f, b < u a
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder β
u : α → β
b : β
h : b < liminf u f
hu : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝
c : β
hc : c ∈ {c | ∀ᶠ (n : α) in f, c ≤ u n}
hbc : b < c
⊢ ∀ᶠ (a : α) in f, b < u a
tactic: obtain ⟨c, hc, hbc⟩ : ∃ (c : β) (_ : c ∈ { c : β | ∀ᶠ n : α in f, c ≤ u n }), b < c := by
    simp_rw [exists_prop]
    exact exists_lt_of_lt_csSup hu h
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder β
u : α → β
b : β
h : b < liminf u f
hu : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝
c : β
hc : c ∈ {c | ∀ᶠ (n : α) in f, c ≤ u n}
hbc : b < c
⊢ ∀ᶠ (a : α) in f, b < u a
state_after: no goals
tactic: exact hc.mono fun x hx => lt_of_lt_of_le hbc hx
Theorem: ProbabilityTheory.lintegral_preCDF_fst
File: Mathlib/Probability/Kernel/Disintegration/CondCdf.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
r : ℚ
inst✝ : IsFiniteMeasure ρ
⊢ ∫⁻ (x : α), preCDF ρ r x ∂ρ.fst = (ρ.IicSnd ↑r) univ
state_after: no goals
tactic: rw [← setLIntegral_univ, setLIntegral_preCDF_fst ρ r MeasurableSet.univ]
Theorem: MeasureTheory.integral_condexp
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean

Proof steps:
state_before: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f g : α → F'
s : Set α
hm : m ≤ m0
hμm : SigmaFinite (μ.trim hm)
⊢ ∫ (x : α), (μ[f|m]) x ∂μ = ∫ (x : α), f x ∂μ
state_after: case pos
α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f g : α → F'
s : Set α
hm : m ≤ m0
hμm : SigmaFinite (μ.trim hm)
hf : Integrable f μ
⊢ ∫ (x : α), (μ[f|m]) x ∂μ = ∫ (x : α), f x ∂μ

case neg
α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f g : α → F'
s : Set α
hm : m ≤ m0
hμm : SigmaFinite (μ.trim hm)
hf : ¬Integrable f μ
⊢ ∫ (x : α), (μ[f|m]) x ∂μ = ∫ (x : α), f x ∂μ
tactic: by_cases hf : Integrable f μ
state_before: case neg
α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f g : α → F'
s : Set α
hm : m ≤ m0
hμm : SigmaFinite (μ.trim hm)
hf : ¬Integrable f μ
⊢ ∫ (x : α), (μ[f|m]) x ∂μ = ∫ (x : α), f x ∂μ
state_after: no goals
tactic: simp only [condexp_undef hf, Pi.zero_apply, integral_zero, integral_undef hf]
Theorem: AlgebraicGeometry.Scheme.OpenCover.fromGlued_openEmbedding
File: Mathlib/AlgebraicGeometry/Gluing.lean

Proof steps:
state_before: X : Scheme
𝒰 : X.OpenCover
⊢ Continuous ⇑𝒰.fromGlued.val.base
state_after: no goals
tactic: fun_prop
Theorem: WellFounded.lt_succ
File: Mathlib/Order/WellFounded.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wf : WellFounded r
x : α
h : ∃ y, r x y
⊢ r x (wf.succ x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wf : WellFounded r
x : α
h : ∃ y, r x y
⊢ r x (wf.min {y | r x y} h)
tactic: rw [WellFounded.succ, dif_pos h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wf : WellFounded r
x : α
h : ∃ y, r x y
⊢ r x (wf.min {y | r x y} h)
state_after: no goals
tactic: apply min_mem
Theorem: MeasureTheory.SignedMeasure.toJordanDecomposition_neg
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
⊢ (-s).toJordanDecomposition = -s.toJordanDecomposition
state_after: case a
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
⊢ (-s).toJordanDecomposition.toSignedMeasure = (-s.toJordanDecomposition).toSignedMeasure
tactic: apply toSignedMeasure_injective
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
⊢ (-s).toJordanDecomposition.toSignedMeasure = (-s.toJordanDecomposition).toSignedMeasure
state_after: no goals
tactic: simp [toSignedMeasure_neg]
Theorem: Matrix.star_dotProduct_star
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : NonUnitalSemiring α
inst✝ : StarRing α
v w : m → α
⊢ star v ⬝ᵥ star w = star (w ⬝ᵥ v)
state_after: no goals
tactic: simp [dotProduct]
Theorem: IsLocalization.isLocalization_of_base_ringEquiv
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
h : R ≃+* P
⊢ IsLocalization (Submonoid.map h.toMonoidHom M) S
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
h : R ≃+* P
this : Algebra P S := ((algebraMap R S).comp h.symm.toRingHom).toAlgebra
⊢ IsLocalization (Submonoid.map h.toMonoidHom M) S
tactic: letI : Algebra P S := ((algebraMap R S).comp h.symm.toRingHom).toAlgebra
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
h : R ≃+* P
this : Algebra P S := ((algebraMap R S).comp h.symm.toRingHom).toAlgebra
⊢ IsLocalization (Submonoid.map h.toMonoidHom M) S
state_after: case map_units'
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
h : R ≃+* P
this : Algebra P S := ((algebraMap R S).comp h.symm.toRingHom).toAlgebra
⊢ ∀ (y : ↥(Submonoid.map h.toMonoidHom M)), IsUnit ((algebraMap P S) ↑y)

case surj'
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
h : R ≃+* P
this : Algebra P S := ((algebraMap R S).comp h.symm.toRingHom).toAlgebra
⊢ ∀ (z : S), ∃ x, z * (algebraMap P S) ↑x.2 = (algebraMap P S) x.1

case exists_of_eq
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
h : R ≃+* P
this : Algebra P S := ((algebraMap R S).comp h.symm.toRingHom).toAlgebra
⊢ ∀ {x y : P}, (algebraMap P S) x = (algebraMap P S) y → ∃ c, ↑c * x = ↑c * y
tactic: constructor
Theorem: DFinsupp.filter_def
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
⊢ filter p f = mk (Finset.filter p f.support) fun i => f ↑i
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
⊢ (filter p f) i = (mk (Finset.filter p f.support) fun i => f ↑i) i
tactic: ext i
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
⊢ (filter p f) i = (mk (Finset.filter p f.support) fun i => f ↑i) i
state_after: no goals
tactic: by_cases h1 : p i <;> by_cases h2 : f i ≠ 0 <;> simp at h2 <;> simp [h1, h2]
Theorem: Finset.sigmaAntidiagonalEquivProd_apply
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
⊢ LeftInverse (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) fun x => ↑x.snd
state_after: case mk.mk.mk
A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
n k l : A
h : (k, l) ∈ antidiagonal n
⊢ (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x => ↑x.snd) ⟨n, ⟨(k, l), h⟩⟩) = ⟨n, ⟨(k, l), h⟩⟩
tactic: rintro ⟨n, ⟨k, l⟩, h⟩
state_before: case mk.mk.mk
A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
n k l : A
h : (k, l) ∈ antidiagonal n
⊢ (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x => ↑x.snd) ⟨n, ⟨(k, l), h⟩⟩) = ⟨n, ⟨(k, l), h⟩⟩
state_after: case mk.mk.mk
A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
n k l : A
h✝ : (k, l) ∈ antidiagonal n
h : (k, l).1 + (k, l).2 = n
⊢ (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x => ↑x.snd) ⟨n, ⟨(k, l), h✝⟩⟩) = ⟨n, ⟨(k, l), h✝⟩⟩
tactic: rw [mem_antidiagonal] at h
state_before: case mk.mk.mk
A : Type u_1
inst✝¹ : AddMonoid A
inst✝ : HasAntidiagonal A
n k l : A
h✝ : (k, l) ∈ antidiagonal n
h : (k, l).1 + (k, l).2 = n
⊢ (fun x => ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x => ↑x.snd) ⟨n, ⟨(k, l), h✝⟩⟩) = ⟨n, ⟨(k, l), h✝⟩⟩
state_after: no goals
tactic: exact Sigma.subtype_ext h rfl
Theorem: tsum_mul_tsum_eq_tsum_sum_range
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
hf : Summable f
hg : Summable g
hfg : Summable fun x => f x.1 * g x.2
⊢ (∑' (n : ℕ), f n) * ∑' (n : ℕ), g n = ∑' (n : ℕ), ∑ k ∈ range (n + 1), f k * g (n - k)
state_after: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
hf : Summable f
hg : Summable g
hfg : Summable fun x => f x.1 * g x.2
⊢ (∑' (n : ℕ), f n) * ∑' (n : ℕ), g n = ∑' (n : ℕ), ∑ ij ∈ antidiagonal n, f ij.1 * g ij.2
tactic: simp_rw [← Nat.sum_antidiagonal_eq_sum_range_succ fun k l ↦ f k * g l]
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
hf : Summable f
hg : Summable g
hfg : Summable fun x => f x.1 * g x.2
⊢ (∑' (n : ℕ), f n) * ∑' (n : ℕ), g n = ∑' (n : ℕ), ∑ ij ∈ antidiagonal n, f ij.1 * g ij.2
state_after: no goals
tactic: exact tsum_mul_tsum_eq_tsum_sum_antidiagonal hf hg hfg
Theorem: CoxeterSystem.rightInvSeq_drop
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.rightInvSeq (drop j ω) = drop j (cs.rightInvSeq ω)
state_after: case zero
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ cs.rightInvSeq (drop 0 ω) = drop 0 (cs.rightInvSeq ω)

case succ
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
j : ℕ
ih₁ : ∀ (ω : List B), cs.rightInvSeq (drop j ω) = drop j (cs.rightInvSeq ω)
ω : List B
⊢ cs.rightInvSeq (drop (j + 1) ω) = drop (j + 1) (cs.rightInvSeq ω)
tactic: induction' j with j ih₁ generalizing ω
Theorem: upperSemicontinuousAt_sum
File: Mathlib/Topology/Semicontinuous.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : TopologicalSpace α
β : Type u_2
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
γ : Type u_4
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a : Finset ι
ha : ∀ i ∈ a, UpperSemicontinuousAt (f i) x
⊢ UpperSemicontinuousAt (fun z => ∑ i ∈ a, f i z) x
state_after: α : Type u_1
inst✝⁵ : TopologicalSpace α
β : Type u_2
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
γ : Type u_4
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a : Finset ι
ha : ∀ i ∈ a, UpperSemicontinuousWithinAt (f i) univ x
⊢ UpperSemicontinuousWithinAt (fun z => ∑ i ∈ a, f i z) univ x
tactic: simp_rw [← upperSemicontinuousWithinAt_univ_iff] at *
state_before: α : Type u_1
inst✝⁵ : TopologicalSpace α
β : Type u_2
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
γ : Type u_4
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a : Finset ι
ha : ∀ i ∈ a, UpperSemicontinuousWithinAt (f i) univ x
⊢ UpperSemicontinuousWithinAt (fun z => ∑ i ∈ a, f i z) univ x
state_after: no goals
tactic: exact upperSemicontinuousWithinAt_sum ha
Theorem: Polynomial.map_cyclotomic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ map f (cyclotomic n R) = cyclotomic n S
state_after: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ map (f.comp (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)
tactic: rw [← map_cyclotomic_int n R, ← map_cyclotomic_int n S, map_map]
state_before: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ map (f.comp (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)
state_after: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
this : Subsingleton (ℤ →+* S)
⊢ map (f.comp (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)
tactic: have : Subsingleton (ℤ →+* S) := inferInstance
state_before: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
this : Subsingleton (ℤ →+* S)
⊢ map (f.comp (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)
state_after: no goals
tactic: congr!
Theorem: CategoryTheory.isPreconnected_of_zigzag
File: Mathlib/CategoryTheory/IsConnected.lean

Proof steps:
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
⊢ IsPreconnected J
state_after: case h
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
⊢ ∀ (j₁ j₂ : J), Zigzag j₁ j₂
tactic: apply zigzag_isPreconnected
state_before: case h
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
⊢ ∀ (j₁ j₂ : J), Zigzag j₁ j₂
state_after: case h
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
j₁ j₂ : J
⊢ Zigzag j₁ j₂
tactic: intro j₁ j₂
state_before: case h
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
j₁ j₂ : J
⊢ Zigzag j₁ j₂
state_after: case h.intro.intro
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
j₁ j₂ : J
l : List J
hl₁ : List.Chain Zag j₁ l
hl₂ : (j₁ :: l).getLast ⋯ = j₂
⊢ Zigzag j₁ j₂
tactic: rcases h j₁ j₂ with ⟨l, hl₁, hl₂⟩
state_before: case h.intro.intro
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
j₁ j₂ : J
l : List J
hl₁ : List.Chain Zag j₁ l
hl₂ : (j₁ :: l).getLast ⋯ = j₂
⊢ Zigzag j₁ j₂
state_after: no goals
tactic: apply List.relationReflTransGen_of_exists_chain l hl₁ hl₂
Theorem: Finset.Nontrivial.exists_cons_eq
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
hs : s.Nontrivial
⊢ ∃ t a, ∃ (ha : a ∉ t), ∃ b, ∃ (hb : b ∉ t) (hab : ¬a = b), cons a (cons b t hb) ⋯ = s
state_after: no goals
tactic: classical
  obtain ⟨a, ha, b, hb, hab⟩ := hs
  have : b ∈ s.erase a := mem_erase.2 ⟨hab.symm, hb⟩
  refine ⟨(s.erase a).erase b, a, ?_, b, ?_, ?_, ?_⟩ <;>
    simp [insert_erase this, insert_erase ha, *]
Theorem: Lagrange.interpolate_empty
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
⊢ (interpolate ∅ v) r = 0
state_after: no goals
tactic: rw [interpolate_apply, sum_empty]