ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsConformalMap.smul
File: Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c✝ : R
hf : IsConformalMap f
c : R
hc : c ≠ 0
⊢ IsConformalMap (c • f)
state_after: case intro.intro.intro
R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
g : N →L[R] G
c✝ c : R
hc : c ≠ 0
c' : R
hc' : c' ≠ 0
li : M →ₗᵢ[R] N
⊢ IsConformalMap (c • c' • li.toContinuousLinearMap)
tactic: rcases hf with ⟨c', hc', li, rfl⟩
state_before: case intro.intro.intro
R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
g : N →L[R] G
c✝ c : R
hc : c ≠ 0
c' : R
hc' : c' ≠ 0
li : M →ₗᵢ[R] N
⊢ IsConformalMap (c • c' • li.toContinuousLinearMap)
state_after: no goals
tactic: exact ⟨c * c', mul_ne_zero hc hc', li, smul_smul _ _ _⟩
Theorem: Finset.preimage_mul_left_one
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Finset α
a b : α
⊢ preimage 1 (fun x => a * x) ⋯ = {a⁻¹}
state_after: no goals
tactic: classical rw [← image_mul_left', image_one, mul_one]
Theorem: SimpleGraph.ConnectedComponent.supp_injective
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
⊢ Injective supp
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
⊢ ∀ (v w : V),
    (G.connectedComponentMk v).supp = (G.connectedComponentMk w).supp →
      G.connectedComponentMk v = G.connectedComponentMk w
tactic: refine ConnectedComponent.ind₂ ?_
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
⊢ ∀ (v w : V),
    (G.connectedComponentMk v).supp = (G.connectedComponentMk w).supp →
      G.connectedComponentMk v = G.connectedComponentMk w
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ (G.connectedComponentMk v).supp = (G.connectedComponentMk w).supp →
    G.connectedComponentMk v = G.connectedComponentMk w
tactic: intro v w
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ (G.connectedComponentMk v).supp = (G.connectedComponentMk w).supp →
    G.connectedComponentMk v = G.connectedComponentMk w
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ (∀ (x : V), G.Reachable x v ↔ G.Reachable x w) → G.Reachable v w
tactic: simp only [ConnectedComponent.supp, Set.ext_iff, ConnectedComponent.eq, Set.mem_setOf_eq]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ (∀ (x : V), G.Reachable x v ↔ G.Reachable x w) → G.Reachable v w
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
h : ∀ (x : V), G.Reachable x v ↔ G.Reachable x w
⊢ G.Reachable v w
tactic: intro h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
h : ∀ (x : V), G.Reachable x v ↔ G.Reachable x w
⊢ G.Reachable v w
state_after: no goals
tactic: rw [reachable_comm, h]
Theorem: Matrix.toMatrix₂Aux_toLinearMap₂'Aux
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁹ : CommSemiring R
inst✝¹⁸ : Semiring R₁
inst✝¹⁷ : Semiring S₁
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring S₂
inst✝¹⁴ : AddCommMonoid M₁
inst✝¹³ : Module R₁ M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
inst✝¹⁰ : AddCommMonoid N₂
inst✝⁹ : Module R N₂
inst✝⁸ : Module S₁ N₂
inst✝⁷ : Module S₂ N₂
inst✝⁶ : SMulCommClass S₁ R N₂
inst✝⁵ : SMulCommClass S₂ R N₂
inst✝⁴ : SMulCommClass S₂ S₁ N₂
σ₁ : R₁ →+* S₁
σ₂ : R₂ →+* S₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
f : Matrix n m N₂
⊢ (toMatrix₂Aux R (fun i => (LinearMap.stdBasis R₁ (fun x => R₁) i) 1) fun j =>
        (LinearMap.stdBasis R₂ (fun x => R₂) j) 1)
      (toLinearMap₂'Aux σ₁ σ₂ f) =
    f
state_after: case a
R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁹ : CommSemiring R
inst✝¹⁸ : Semiring R₁
inst✝¹⁷ : Semiring S₁
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring S₂
inst✝¹⁴ : AddCommMonoid M₁
inst✝¹³ : Module R₁ M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
inst✝¹⁰ : AddCommMonoid N₂
inst✝⁹ : Module R N₂
inst✝⁸ : Module S₁ N₂
inst✝⁷ : Module S₂ N₂
inst✝⁶ : SMulCommClass S₁ R N₂
inst✝⁵ : SMulCommClass S₂ R N₂
inst✝⁴ : SMulCommClass S₂ S₁ N₂
σ₁ : R₁ →+* S₁
σ₂ : R₂ →+* S₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
f : Matrix n m N₂
i : n
j : m
⊢ (toMatrix₂Aux R (fun i => (LinearMap.stdBasis R₁ (fun x => R₁) i) 1) fun j =>
        (LinearMap.stdBasis R₂ (fun x => R₂) j) 1)
      (toLinearMap₂'Aux σ₁ σ₂ f) i j =
    f i j
tactic: ext i j
state_before: case a
R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁹ : CommSemiring R
inst✝¹⁸ : Semiring R₁
inst✝¹⁷ : Semiring S₁
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring S₂
inst✝¹⁴ : AddCommMonoid M₁
inst✝¹³ : Module R₁ M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
inst✝¹⁰ : AddCommMonoid N₂
inst✝⁹ : Module R N₂
inst✝⁸ : Module S₁ N₂
inst✝⁷ : Module S₂ N₂
inst✝⁶ : SMulCommClass S₁ R N₂
inst✝⁵ : SMulCommClass S₂ R N₂
inst✝⁴ : SMulCommClass S₂ S₁ N₂
σ₁ : R₁ →+* S₁
σ₂ : R₂ →+* S₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
f : Matrix n m N₂
i : n
j : m
⊢ (toMatrix₂Aux R (fun i => (LinearMap.stdBasis R₁ (fun x => R₁) i) 1) fun j =>
        (LinearMap.stdBasis R₂ (fun x => R₂) j) 1)
      (toLinearMap₂'Aux σ₁ σ₂ f) i j =
    f i j
state_after: no goals
tactic: simp_rw [LinearMap.toMatrix₂Aux_apply, Matrix.toLinearMap₂'Aux_stdBasis]
Theorem: PMF.apply_eq_zero_iff
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
a : α
⊢ p a = 0 ↔ a ∉ p.support
state_after: no goals
tactic: rw [mem_support_iff, Classical.not_not]
Theorem: LinearMap.toMatrix_toLin
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝⁷ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁶ : Fintype n
inst✝⁵ : Finite m
inst✝⁴ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M : Matrix m n R
⊢ (toMatrix v₁ v₂) ((toLin v₁ v₂) M) = M
state_after: no goals
tactic: rw [← Matrix.toLin_symm, LinearEquiv.symm_apply_apply]
Theorem: MeasureTheory.IsStoppingTime.measurableSpace_min
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
hπ : IsStoppingTime f π
⊢ ⋯.measurableSpace = hτ.measurableSpace ⊓ hπ.measurableSpace
state_after: case refine_1
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
hπ : IsStoppingTime f π
⊢ ⋯.measurableSpace ≤ hτ.measurableSpace ⊓ hπ.measurableSpace

case refine_2
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
hπ : IsStoppingTime f π
⊢ hτ.measurableSpace ⊓ hπ.measurableSpace ≤ ⋯.measurableSpace
tactic: refine le_antisymm ?_ ?_
Theorem: vectorSpan_pair_rev
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p₁ p₂ : P
⊢ vectorSpan k {p₁, p₂} = Submodule.span k {p₂ -ᵥ p₁}
state_after: no goals
tactic: rw [pair_comm, vectorSpan_pair]
Theorem: iterateFrobeniusEquiv_eq_pow
File: Mathlib/FieldTheory/Perfect.lean

Proof steps:
state_before: R : Type u_1
p m n : ℕ
inst✝² : CommSemiring R
inst✝¹ : ExpChar R p
inst✝ : PerfectRing R p
⊢ ⇑(iterateFrobeniusEquiv R p n) = ⇑((RingAut.toPerm R) (frobeniusEquiv R p ^ n))
state_after: R : Type u_1
p m n : ℕ
inst✝² : CommSemiring R
inst✝¹ : ExpChar R p
inst✝ : PerfectRing R p
⊢ ⇑(iterateFrobeniusEquiv R p n) = (⇑((RingAut.toPerm R) (frobeniusEquiv R p)))^[n]
tactic: rw [map_pow, Equiv.Perm.coe_pow]
state_before: R : Type u_1
p m n : ℕ
inst✝² : CommSemiring R
inst✝¹ : ExpChar R p
inst✝ : PerfectRing R p
⊢ ⇑(iterateFrobeniusEquiv R p n) = (⇑((RingAut.toPerm R) (frobeniusEquiv R p)))^[n]
state_after: no goals
tactic: exact (pow_iterate p n).symm
Theorem: div_ne_zero
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a / b ≠ 0
state_after: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a * b⁻¹ ≠ 0
tactic: rw [div_eq_mul_inv]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a * b⁻¹ ≠ 0
state_after: no goals
tactic: exact mul_ne_zero ha (inv_ne_zero hb)
Theorem: StieltjesFunction.measure_add
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f✝ f g : StieltjesFunction
⊢ (f + g).measure = f.measure + g.measure
state_after: f✝ f g : StieltjesFunction
a b : ℝ
h : a < b
⊢ (f + g).measure (Ioc a b) = (f.measure + g.measure) (Ioc a b)
tactic: refine Measure.ext_of_Ioc _ _ (fun a b h ↦ ?_)
state_before: f✝ f g : StieltjesFunction
a b : ℝ
h : a < b
⊢ (f + g).measure (Ioc a b) = (f.measure + g.measure) (Ioc a b)
state_after: f✝ f g : StieltjesFunction
a b : ℝ
h : a < b
⊢ ofReal (↑f b + ↑g b - (↑f a + ↑g a)) = ofReal (↑f b - ↑f a) + ofReal (↑g b - ↑g a)
tactic: simp only [measure_Ioc, add_apply, Measure.coe_add, Pi.add_apply]
state_before: f✝ f g : StieltjesFunction
a b : ℝ
h : a < b
⊢ ofReal (↑f b + ↑g b - (↑f a + ↑g a)) = ofReal (↑f b - ↑f a) + ofReal (↑g b - ↑g a)
state_after: f✝ f g : StieltjesFunction
a b : ℝ
h : a < b
⊢ ofReal (↑f b + ↑g b - (↑f a + ↑g a)) = ofReal (↑f b - ↑f a + (↑g b - ↑g a))
tactic: rw [← ENNReal.ofReal_add (sub_nonneg_of_le (f.mono h.le)) (sub_nonneg_of_le (g.mono h.le))]
state_before: f✝ f g : StieltjesFunction
a b : ℝ
h : a < b
⊢ ofReal (↑f b + ↑g b - (↑f a + ↑g a)) = ofReal (↑f b - ↑f a + (↑g b - ↑g a))
state_after: no goals
tactic: ring_nf
Theorem: LieSubmodule.ucs_eq_self_of_normalizer_eq_self
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
h : N₁.normalizer = N₁
k : ℕ
⊢ ucs k N₁ = N₁
state_after: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
h : N₁.normalizer = N₁
⊢ ucs 0 N₁ = N₁

case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
h : N₁.normalizer = N₁
k : ℕ
ih : ucs k N₁ = N₁
⊢ ucs (k + 1) N₁ = N₁
tactic: induction' k with k ih
Theorem: tsum_setElem_eq_tsum_setElem_diff
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
s t : Set β
hf₀ : ∀ b ∈ t, f b = 1
b : ↑s
hb : b ∉ Set.range (Set.inclusion ⋯)
⊢ ↑b ∈ t
state_after: no goals
tactic: simpa using hb
Theorem: Module.DualBases.coe_basis
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
⊢ ⇑h.basis = e
state_after: case h
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
i : ι
⊢ h.basis i = e i
tactic: ext i
state_before: case h
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
i : ι
⊢ h.basis i = e i
state_after: case h
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
i : ι
⊢ h.basis.repr (e i) = Finsupp.single i 1
tactic: rw [Basis.apply_eq_iff]
state_before: case h
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
i : ι
⊢ h.basis.repr (e i) = Finsupp.single i 1
state_after: case h.h
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
i j : ι
⊢ (h.basis.repr (e i)) j = (Finsupp.single i 1) j
tactic: ext j
state_before: case h.h
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
i j : ι
⊢ (h.basis.repr (e i)) j = (Finsupp.single i 1) j
state_after: case h.h
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
i j : ι
⊢ (if j = i then 1 else 0) = if i = j then 1 else 0
tactic: rw [h.basis_repr_apply, coeffs_apply, h.eval, Finsupp.single_apply]
state_before: case h.h
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
i j : ι
⊢ (if j = i then 1 else 0) = if i = j then 1 else 0
state_after: no goals
tactic: convert if_congr (eq_comm (a := j) (b := i)) rfl rfl
Theorem: bot_symmDiff
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ ⊥ ∆ a = a
state_after: no goals
tactic: rw [symmDiff_comm, symmDiff_bot]
Theorem: OreLocalization.zero_def
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : Zero X
inst✝ : MulAction R X
⊢ 0 = 0 /ₒ 1
state_after: no goals
tactic: with_unfolding_all rfl
Theorem: Stream'.cycle_eq
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
⊢ ∀ (l' : List α) (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l', a, l) = a' :: l' ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
state_after: α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
l' : List α
⊢ ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l', a, l) = a' :: l' ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
tactic: intro l'
state_before: α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
l' : List α
⊢ ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l', a, l) = a' :: l' ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
state_after: case nil
α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
⊢ ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', [], a, l) = [a'] ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)

case cons
α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
a₁ : α
l₁ : List α
ih :
  ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l₁, a, l) = a' :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
⊢ ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', a₁ :: l₁, a, l) =
      a' :: a₁ :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
tactic: induction' l' with a₁ l₁ ih
Theorem: Finset.forall_image
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 : β
p : β → Prop
⊢ (∀ b ∈ image f s, p b) ↔ ∀ a ∈ s, p (f a)
state_after: no goals
tactic: simp only [mem_image, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂]
Theorem: MeasureTheory.integrableOn_Iio_iff_integrableAtFilter_atBot_nhdsWithin
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁹ : MeasurableSpace X
inst✝⁸ : TopologicalSpace X
inst✝⁷ : MeasurableSpace Y
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
a : X
inst✝³ : LinearOrder X
inst✝² : CompactIccSpace X
inst✝¹ : NoMinOrder X
inst✝ : OrderTopology X
⊢ IntegrableOn f (Iio a) μ ↔
    IntegrableAtFilter f atBot μ ∧ IntegrableAtFilter f (𝓝[<] a) μ ∧ LocallyIntegrableOn f (Iio a) μ
state_after: case mp
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁹ : MeasurableSpace X
inst✝⁸ : TopologicalSpace X
inst✝⁷ : MeasurableSpace Y
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
a : X
inst✝³ : LinearOrder X
inst✝² : CompactIccSpace X
inst✝¹ : NoMinOrder X
inst✝ : OrderTopology X
⊢ IntegrableOn f (Iio a) μ →
    IntegrableAtFilter f atBot μ ∧ IntegrableAtFilter f (𝓝[<] a) μ ∧ LocallyIntegrableOn f (Iio a) μ

case mpr
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁹ : MeasurableSpace X
inst✝⁸ : TopologicalSpace X
inst✝⁷ : MeasurableSpace Y
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
a : X
inst✝³ : LinearOrder X
inst✝² : CompactIccSpace X
inst✝¹ : NoMinOrder X
inst✝ : OrderTopology X
⊢ IntegrableAtFilter f atBot μ ∧ IntegrableAtFilter f (𝓝[<] a) μ ∧ LocallyIntegrableOn f (Iio a) μ →
    IntegrableOn f (Iio a) μ
tactic: constructor
Theorem: Batteries.OrientedOrd.instLexOrd
File: .lake/packages/batteries/Batteries/Classes/Order.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Ord α
inst✝² : Ord β
inst✝¹ : OrientedOrd α
inst✝ : OrientedOrd β
⊢ OrientedOrd (α × β)
state_after: α : Type u_1
β : Type u_2
inst✝³ : Ord α
inst✝² : Ord β
inst✝¹ : OrientedOrd α
inst✝ : OrientedOrd β
⊢ OrientedCmp (compareLex (compareOn fun x => x.fst) (compareOn fun x => x.snd))
tactic: rw [OrientedOrd, lexOrd_def]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Ord α
inst✝² : Ord β
inst✝¹ : OrientedOrd α
inst✝ : OrientedOrd β
⊢ OrientedCmp (compareLex (compareOn fun x => x.fst) (compareOn fun x => x.snd))
state_after: no goals
tactic: infer_instance
Theorem: Ring.multichoose_neg_add
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n k : ℕ
⊢ multichoose (-↑n) (n + k + 1) = 0
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n k : ℕ
⊢ (fun x => (n + k + 1).factorial • x) (multichoose (-↑n) (n + k + 1)) = (fun x => (n + k + 1).factorial • x) 0
tactic: refine nsmul_right_injective (Nat.factorial (n + k + 1)) (Nat.factorial_ne_zero (n + k + 1)) ?_
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n k : ℕ
⊢ (fun x => (n + k + 1).factorial • x) (multichoose (-↑n) (n + k + 1)) = (fun x => (n + k + 1).factorial • x) 0
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n k : ℕ
⊢ (n + k + 1).factorial • multichoose (-↑n) (n + k + 1) = (n + k + 1).factorial • 0
tactic: simp only
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n k : ℕ
⊢ (n + k + 1).factorial • multichoose (-↑n) (n + k + 1) = (n + k + 1).factorial • 0
state_after: no goals
tactic: rw [factorial_nsmul_multichoose_eq_ascPochhammer, smeval_ascPochhammer_neg_add, smul_zero]
Theorem: Nat.descFactorial_le_pow
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ n.descFactorial 0 ≤ n ^ 0
state_after: no goals
tactic: rw [descFactorial_zero, Nat.pow_zero]
state_before: n k : ℕ
⊢ n.descFactorial (k + 1) ≤ n ^ (k + 1)
state_after: n k : ℕ
⊢ (n - k) * n.descFactorial k ≤ n * n ^ k
tactic: rw [descFactorial_succ, Nat.pow_succ, Nat.mul_comm _ n]
state_before: n k : ℕ
⊢ (n - k) * n.descFactorial k ≤ n * n ^ k
state_after: no goals
tactic: exact Nat.mul_le_mul (Nat.sub_le _ _) (descFactorial_le_pow _ k)
Theorem: ENNReal.toReal_add
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ ⊤
⊢ (a + b).toReal = a.toReal + b.toReal
state_after: case intro
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ (↑a + b).toReal = (↑a).toReal + b.toReal
tactic: lift a to ℝ≥0 using ha
state_before: case intro
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ (↑a + b).toReal = (↑a).toReal + b.toReal
state_after: case intro.intro
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ (↑a + ↑b).toReal = (↑a).toReal + (↑b).toReal
tactic: lift b to ℝ≥0 using hb
state_before: case intro.intro
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ (↑a + ↑b).toReal = (↑a).toReal + (↑b).toReal
state_after: no goals
tactic: rfl
Theorem: Matrix.IsDiag.sub
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : AddGroup α
A B : Matrix n n α
ha : A.IsDiag
hb : B.IsDiag
⊢ (A - B).IsDiag
state_after: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : AddGroup α
A B : Matrix n n α
ha : A.IsDiag
hb : B.IsDiag
i j : n
h : i ≠ j
⊢ (A - B) i j = 0
tactic: intro i j h
state_before: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : AddGroup α
A B : Matrix n n α
ha : A.IsDiag
hb : B.IsDiag
i j : n
h : i ≠ j
⊢ (A - B) i j = 0
state_after: no goals
tactic: simp [ha h, hb h]
Theorem: PiLp.dist_eq_of_L2
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x y : PiLp 2 β
⊢ dist x y = √(∑ i : ι, dist (x i) (y i) ^ 2)
state_after: no goals
tactic: simp_rw [dist_eq_norm, norm_eq_of_L2, sub_apply]