ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Lp.simpleFunc.smul_toSimpleFunc
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : ↥(simpleFunc E p μ)
⊢ ↑(toSimpleFunc (k • f)) =ᶠ[ae μ] k • ↑(toSimpleFunc f)
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : ↥(simpleFunc E p μ)
a✝ : α
⊢ ↑(toSimpleFunc (k • f)) a✝ = ↑↑↑(k • f) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑↑(k • ↑f) a✝ = (k • ↑↑↑f) a✝ → ↑(toSimpleFunc (k • f)) a✝ = (k • ↑(toSimpleFunc f)) a✝
tactic: filter_upwards [toSimpleFunc_eq_toFun (k • f), toSimpleFunc_eq_toFun f,
    Lp.coeFn_smul k (f : Lp E p μ)] with _
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : ↥(simpleFunc E p μ)
a✝ : α
⊢ ↑(toSimpleFunc (k • f)) a✝ = ↑↑↑(k • f) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑↑(k • ↑f) a✝ = (k • ↑↑↑f) a✝ → ↑(toSimpleFunc (k • f)) a✝ = (k • ↑(toSimpleFunc f)) a✝
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : ↥(simpleFunc E p μ)
a✝ : α
⊢ ↑(toSimpleFunc (k • f)) a✝ = ↑↑(k • ↑f) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ → ↑↑(k • ↑f) a✝ = k • ↑↑↑f a✝ → ↑(toSimpleFunc (k • f)) a✝ = k • ↑(toSimpleFunc f) a✝
tactic: simp only [Pi.smul_apply, coe_smul]
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
k : 𝕜
f : ↥(simpleFunc E p μ)
a✝ : α
⊢ ↑(toSimpleFunc (k • f)) a✝ = ↑↑(k • ↑f) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ → ↑↑(k • ↑f) a✝ = k • ↑↑↑f a✝ → ↑(toSimpleFunc (k • f)) a✝ = k • ↑(toSimpleFunc f) a✝
state_after: no goals
tactic: repeat intro h; rw [h]
Theorem: Stirling.stirlingSeq'_pos
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

Proof steps:
state_before: n : ℕ
⊢ 0 < stirlingSeq (n + 1)
state_after: n : ℕ
⊢ 0 < ↑(n + 1)! / (√(2 * ↑(n + 1)) * (↑(n + 1) / rexp 1) ^ (n + 1))
tactic: unfold stirlingSeq
state_before: n : ℕ
⊢ 0 < ↑(n + 1)! / (√(2 * ↑(n + 1)) * (↑(n + 1) / rexp 1) ^ (n + 1))
state_after: no goals
tactic: positivity
Theorem: Real.differentiableOn_negMulLog
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: ⊢ DifferentiableOn ℝ negMulLog {0}ᶜ
state_after: no goals
tactic: simpa only [negMulLog_eq_neg] using differentiableOn_mul_log.neg
Theorem: smul_finsum
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: G : Type u_1
M✝ : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_7
M : Type u_8
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
c : R
f : ι → M
⊢ c • ∑ᶠ (i : ι), f i = ∑ᶠ (i : ι), c • f i
state_after: case inl
G : Type u_1
M✝ : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_7
M : Type u_8
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
f : ι → M
⊢ 0 • ∑ᶠ (i : ι), f i = ∑ᶠ (i : ι), 0 • f i

case inr
G : Type u_1
M✝ : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_7
M : Type u_8
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
c : R
f : ι → M
hc : c ≠ 0
⊢ c • ∑ᶠ (i : ι), f i = ∑ᶠ (i : ι), c • f i
tactic: rcases eq_or_ne c 0 with (rfl | hc)
Theorem: MulEquiv.op_symm_apply_apply
File: Mathlib/Algebra/Group/Opposite.lean

Proof steps:
state_before: α✝ : Type u_1
α : Type ?u.39365
β : Type ?u.39368
inst✝¹ : Mul α
inst✝ : Mul β
f : αᵐᵒᵖ ≃* βᵐᵒᵖ
x : α
⊢ (unop ∘ ⇑f.symm ∘ MulOpposite.op) ((unop ∘ ⇑f ∘ MulOpposite.op) x) = x
state_after: no goals
tactic: simp
state_before: α✝ : Type u_1
α : Type ?u.39365
β : Type ?u.39368
inst✝¹ : Mul α
inst✝ : Mul β
f : αᵐᵒᵖ ≃* βᵐᵒᵖ
x : β
⊢ (unop ∘ ⇑f ∘ MulOpposite.op) ((unop ∘ ⇑f.symm ∘ MulOpposite.op) x) = x
state_after: no goals
tactic: simp
Theorem: le_iff_compact_le_imp
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a✝ b✝ : α
s : Set α
a b : α
h : ∀ (c : α), CompleteLattice.IsCompactElement c → c ≤ a → c ≤ b
⊢ a ≤ b
state_after: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a✝ b✝ : α
s : Set α
a b : α
h : ∀ (c : α), CompleteLattice.IsCompactElement c → c ≤ a → c ≤ b
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ a} ≤ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ b}
tactic: rw [← sSup_compact_le_eq a, ← sSup_compact_le_eq b]
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a✝ b✝ : α
s : Set α
a b : α
h : ∀ (c : α), CompleteLattice.IsCompactElement c → c ≤ a → c ≤ b
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ a} ≤ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ b}
state_after: no goals
tactic: exact sSup_le_sSup fun c hc => ⟨hc.1, h c hc.1 hc.2⟩
Theorem: DoubleQuot.ker_quotQuotMk
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
I J : Ideal R
⊢ RingHom.ker (quotQuotMk I J) = I ⊔ J
state_after: no goals
tactic: rw [RingHom.ker_eq_comap_bot, quotQuotMk, ← comap_comap, ← RingHom.ker, mk_ker,
    comap_map_of_surjective (Ideal.Quotient.mk I) Quotient.mk_surjective, ← RingHom.ker, mk_ker,
    sup_comm]
Theorem: ContinuousAlternatingMap.toAlternatingMapLinear_apply
File: Mathlib/Topology/Algebra/Module/Alternating/Basic.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring A
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace N
inst✝⁵ : ContinuousAdd N
inst✝⁴ : Module A M
inst✝³ : Module A N
inst✝² : Module R N
inst✝¹ : ContinuousConstSMul R N
inst✝ : SMulCommClass A R N
⊢ ∀ (x y : M [⋀^ι]→L[A] N), (x + y).toAlternatingMap = x.toAlternatingMap + y.toAlternatingMap
state_after: no goals
tactic: simp
state_before: R : Type u_1
A : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring A
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace N
inst✝⁵ : ContinuousAdd N
inst✝⁴ : Module A M
inst✝³ : Module A N
inst✝² : Module R N
inst✝¹ : ContinuousConstSMul R N
inst✝ : SMulCommClass A R N
⊢ ∀ (m : R) (x : M [⋀^ι]→L[A] N),
    { toFun := toAlternatingMap, map_add' := ⋯ }.toFun (m • x) =
      (RingHom.id R) m • { toFun := toAlternatingMap, map_add' := ⋯ }.toFun x
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Measure.ext_of_generateFrom_of_iUnion
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 α
C : Set (Set α)
B : ℕ → Set α
hA : m0 = generateFrom C
hC : IsPiSystem C
h1B : ⋃ i, B i = univ
h2B : ∀ (i : ℕ), B i ∈ C
hμB : ∀ (i : ℕ), μ (B i) ≠ ⊤
h_eq : ∀ s ∈ C, μ s = ν s
⊢ μ = ν
state_after: case refine_1
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 α
C : Set (Set α)
B : ℕ → Set α
hA : m0 = generateFrom C
hC : IsPiSystem C
h1B : ⋃ i, B i = univ
h2B : ∀ (i : ℕ), B i ∈ C
hμB : ∀ (i : ℕ), μ (B i) ≠ ⊤
h_eq : ∀ s ∈ C, μ s = ν s
⊢ range B ⊆ C

case refine_2
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 α
C : Set (Set α)
B : ℕ → Set α
hA : m0 = generateFrom C
hC : IsPiSystem C
h1B : ⋃ i, B i = univ
h2B : ∀ (i : ℕ), B i ∈ C
hμB : ∀ (i : ℕ), μ (B i) ≠ ⊤
h_eq : ∀ s ∈ C, μ s = ν s
⊢ ∀ s ∈ range B, μ s ≠ ⊤
tactic: refine ext_of_generateFrom_of_cover_subset hA hC ?_ (countable_range B) h1B ?_ h_eq
Theorem: FirstOrder.Language.BoundedFormula.realize_imp
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
⊢ (φ ⟹ ψ).Realize v xs ↔ φ.Realize v xs → ψ.Realize v xs
state_after: no goals
tactic: simp only [Realize]
Theorem: exists_lt_of_gauge_lt
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
absorbs : Absorbent ℝ s
h : gauge s x < a
⊢ ∃ b, 0 < b ∧ b < a ∧ x ∈ b • s
state_after: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
absorbs : Absorbent ℝ s
h : gauge s x < a
b : ℝ
hba : b < a
hb : 0 < b
hx : x ∈ b • s
⊢ ∃ b, 0 < b ∧ b < a ∧ x ∈ b • s
tactic: obtain ⟨b, ⟨hb, hx⟩, hba⟩ := exists_lt_of_csInf_lt absorbs.gauge_set_nonempty h
state_before: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
absorbs : Absorbent ℝ s
h : gauge s x < a
b : ℝ
hba : b < a
hb : 0 < b
hx : x ∈ b • s
⊢ ∃ b, 0 < b ∧ b < a ∧ x ∈ b • s
state_after: no goals
tactic: exact ⟨b, hb, hba, hx⟩
Theorem: Bool.eq_true_of_not_eq_false'
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: a : Bool
⊢ (!decide (a = false)) = true → a = true
state_after: no goals
tactic: cases a <;> decide
Theorem: Function.Periodic.add
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Mul β
hf : Periodic f c
hg : Periodic g c
⊢ Periodic (f * g) c
state_after: no goals
tactic: simp_all
Theorem: Finset.disjoint_of_erase_left
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ t
hst : _root_.Disjoint (s.erase a) t
⊢ _root_.Disjoint s t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ t
hst : _root_.Disjoint (s.erase a) t
⊢ a ∉ s.erase a ∧ _root_.Disjoint (s.erase a) t
tactic: rw [← erase_insert ha, ← disjoint_erase_comm, disjoint_insert_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ t
hst : _root_.Disjoint (s.erase a) t
⊢ a ∉ s.erase a ∧ _root_.Disjoint (s.erase a) t
state_after: no goals
tactic: exact ⟨not_mem_erase _ _, hst⟩
Theorem: Finsupp.mapRange_smul
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
x✝ : Monoid R
inst✝³ : AddMonoid M
inst✝² : DistribMulAction R M
inst✝¹ : AddMonoid N
inst✝ : DistribMulAction R N
f : M → N
hf : f 0 = 0
c : R
v : α →₀ M
hsmul : ∀ (x : M), f (c • x) = c • f x
⊢ mapRange f hf (c • v) = c • mapRange f hf v
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
x✝ : Monoid R
inst✝³ : AddMonoid M
inst✝² : DistribMulAction R M
inst✝¹ : AddMonoid N
inst✝ : DistribMulAction R N
f : M → N
hf : f 0 = 0
c : R
v : α →₀ M
hsmul : ∀ (x : M), f (c • x) = c • f x
⊢ mapRange (f ∘ fun x => c • x) ?h v = c • mapRange f hf v

case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
x✝ : Monoid R
inst✝³ : AddMonoid M
inst✝² : DistribMulAction R M
inst✝¹ : AddMonoid N
inst✝ : DistribMulAction R N
f : M → N
hf : f 0 = 0
c : R
v : α →₀ M
hsmul : ∀ (x : M), f (c • x) = c • f x
⊢ (f ∘ fun x => c • x) 0 = 0
tactic: erw [← mapRange_comp]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
x✝ : Monoid R
inst✝³ : AddMonoid M
inst✝² : DistribMulAction R M
inst✝¹ : AddMonoid N
inst✝ : DistribMulAction R N
f : M → N
hf : f 0 = 0
c : R
v : α →₀ M
hsmul : ∀ (x : M), f (c • x) = c • f x
⊢ (f ∘ fun x => c • x) 0 = 0
state_after: no goals
tactic: simp only [Function.comp_apply, smul_zero, hf]
Theorem: AddSubgroup.inf_relindex_right
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ (H ⊓ K).relindex K = H.relindex K
state_after: no goals
tactic: rw [relindex, relindex, inf_subgroupOf_right]
Theorem: inner_sub_sub_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ⟪x - y, x - y⟫_𝕜 = ⟪x, x⟫_𝕜 - ⟪x, y⟫_𝕜 - ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ⟪x, x⟫_𝕜 - ⟪y, x⟫_𝕜 - (⟪x, y⟫_𝕜 - ⟪y, y⟫_𝕜) = ⟪x, x⟫_𝕜 - ⟪x, y⟫_𝕜 - ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜
tactic: simp only [inner_sub_left, inner_sub_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ⟪x, x⟫_𝕜 - ⟪y, x⟫_𝕜 - (⟪x, y⟫_𝕜 - ⟪y, y⟫_𝕜) = ⟪x, x⟫_𝕜 - ⟪x, y⟫_𝕜 - ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜
state_after: no goals
tactic: ring
Theorem: Multiset.noncommSum_coe
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm : {x | x ∈ ↑l}.Pairwise Commute
⊢ (↑l).noncommProd comm = l.prod
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm : {x | x ∈ ↑l}.Pairwise Commute
⊢ noncommFold (fun x x_1 => x * x_1) (↑l) comm 1 = l.prod
tactic: rw [noncommProd]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm : {x | x ∈ ↑l}.Pairwise Commute
⊢ noncommFold (fun x x_1 => x * x_1) (↑l) comm 1 = l.prod
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm : {x | x ∈ ↑l}.Pairwise Commute
⊢ List.foldr (fun x x_1 => x * x_1) 1 l = l.prod
tactic: simp only [noncommFold_coe]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm : {x | x ∈ ↑l}.Pairwise Commute
⊢ List.foldr (fun x x_1 => x * x_1) 1 l = l.prod
state_after: case nil
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
comm : {x | x ∈ ↑[]}.Pairwise Commute
⊢ List.foldr (fun x x_1 => x * x_1) 1 [] = [].prod

case cons
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
hd : α
tl : List α
hl : {x | x ∈ ↑tl}.Pairwise Commute → List.foldr (fun x x_1 => x * x_1) 1 tl = tl.prod
comm : {x | x ∈ ↑(hd :: tl)}.Pairwise Commute
⊢ List.foldr (fun x x_1 => x * x_1) 1 (hd :: tl) = (hd :: tl).prod
tactic: induction' l with hd tl hl
Theorem: List.IsPrefix.eraseIdx
File: .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean

Proof steps:
state_before: α : Type u
β : Type v
l l' : List α
h : l <+: l'
k : Nat
⊢ l.eraseIdx k <+: l'.eraseIdx k
state_after: case intro
α : Type u
β : Type v
l : List α
k : Nat
t : List α
⊢ l.eraseIdx k <+: (l ++ t).eraseIdx k
tactic: rcases h with ⟨t, rfl⟩
state_before: case intro
α : Type u
β : Type v
l : List α
k : Nat
t : List α
⊢ l.eraseIdx k <+: (l ++ t).eraseIdx k
state_after: no goals
tactic: if hkl : k < length l then
    simp [eraseIdx_append_of_lt_length hkl]
  else
    rw [Nat.not_lt] at hkl
    simp [eraseIdx_append_of_length_le hkl, eraseIdx_of_length_le hkl]
Theorem: SimpleGraph.Walk.length_eq_zero_iff
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
p : G.Walk u u
⊢ p.length = 0 ↔ p = nil
state_after: no goals
tactic: cases p <;> simp
Theorem: Finset.Icc_subset_Icc_iff
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h₁ : a₁ ≤ b₁
⊢ Icc a₁ b₁ ⊆ Icc a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂
state_after: no goals
tactic: rw [← coe_subset, coe_Icc, coe_Icc, Set.Icc_subset_Icc_iff h₁]
Theorem: Con.pow
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M✝ : Type u_1
N : Type u_2
P : Type u_3
M : Type u_4
inst✝ : Monoid M
c : Con M
w x : M
x✝ : c w x
⊢ c (w ^ 0) (x ^ 0)
state_after: no goals
tactic: simpa using c.refl _
state_before: M✝ : Type u_1
N : Type u_2
P : Type u_3
M : Type u_4
inst✝ : Monoid M
c : Con M
n : ℕ
w x : M
h : c w x
⊢ c (w ^ n.succ) (x ^ n.succ)
state_after: no goals
tactic: simpa [pow_succ] using c.mul (Con.pow c n h) h
Theorem: interior_eq_nhds
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ {x | s ∈ 𝓝 x} = {x | 𝓝 x ≤ 𝓟 s}
state_after: no goals
tactic: simp only [le_principal_iff]
Theorem: CompleteOrthogonalIdempotents.pair_iff
File: Mathlib/RingTheory/Idempotents.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝ : OrthogonalIdempotents e
inst✝ : Fintype I
he : CompleteOrthogonalIdempotents e
x y : R
⊢ CompleteOrthogonalIdempotents ![x, y] ↔ IsIdempotentElem x ∧ y = 1 - x
state_after: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝ : OrthogonalIdempotents e
inst✝ : Fintype I
he : CompleteOrthogonalIdempotents e
x y : R
⊢ (∀ (i : Fin (Nat.succ 0).succ), IsIdempotentElem (![x, y] i)) ∧
      (∀ (i j : Fin (Nat.succ 0).succ), i ≠ j → ![x, y] i * ![x, y] j = 0) ∧
        ∑ i : Fin (Nat.succ 0).succ, ![x, y] i = 1 ↔
    IsIdempotentElem x ∧ y = 1 - x
tactic: rw [completeOrthogonalIdempotents_iff, orthogonalIdempotents_iff, and_assoc]
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝ : OrthogonalIdempotents e
inst✝ : Fintype I
he : CompleteOrthogonalIdempotents e
x y : R
⊢ (∀ (i : Fin (Nat.succ 0).succ), IsIdempotentElem (![x, y] i)) ∧
      (∀ (i j : Fin (Nat.succ 0).succ), i ≠ j → ![x, y] i * ![x, y] j = 0) ∧
        ∑ i : Fin (Nat.succ 0).succ, ![x, y] i = 1 ↔
    IsIdempotentElem x ∧ y = 1 - x
state_after: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝ : OrthogonalIdempotents e
inst✝ : Fintype I
he : CompleteOrthogonalIdempotents e
x y : R
⊢ (IsIdempotentElem x ∧ IsIdempotentElem y) ∧ (x * y = 0 ∧ y * x = 0) ∧ x + y = 1 ↔ IsIdempotentElem x ∧ x + y = 1
tactic: simp only [Nat.succ_eq_add_one, Nat.reduceAdd, Fin.forall_fin_two, Fin.isValue,
    Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons, ne_eq, not_true_eq_false,
    false_implies, zero_ne_one, not_false_eq_true, true_implies, true_and, one_ne_zero,
    and_true, and_self, Fin.sum_univ_two, eq_sub_iff_add_eq, @add_comm _ _ y]
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝ : OrthogonalIdempotents e
inst✝ : Fintype I
he : CompleteOrthogonalIdempotents e
x y : R
⊢ (IsIdempotentElem x ∧ IsIdempotentElem y) ∧ (x * y = 0 ∧ y * x = 0) ∧ x + y = 1 ↔ IsIdempotentElem x ∧ x + y = 1
state_after: case mp
R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝ : OrthogonalIdempotents e
inst✝ : Fintype I
he : CompleteOrthogonalIdempotents e
x y : R
⊢ (IsIdempotentElem x ∧ IsIdempotentElem y) ∧ (x * y = 0 ∧ y * x = 0) ∧ x + y = 1 → IsIdempotentElem x ∧ x + y = 1

case mpr
R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝ : OrthogonalIdempotents e
inst✝ : Fintype I
he : CompleteOrthogonalIdempotents e
x y : R
⊢ IsIdempotentElem x ∧ x + y = 1 → (IsIdempotentElem x ∧ IsIdempotentElem y) ∧ (x * y = 0 ∧ y * x = 0) ∧ x + y = 1
tactic: constructor
Theorem: bernoulli'_one
File: Mathlib/NumberTheory/Bernoulli.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli' 1 = 1 / 2
state_after: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ 1 - ∑ k ∈ range 1, ↑(Nat.choose 1 k) / (↑1 - ↑k + 1) * bernoulli' k = 1 / 2
tactic: rw [bernoulli'_def]
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ 1 - ∑ k ∈ range 1, ↑(Nat.choose 1 k) / (↑1 - ↑k + 1) * bernoulli' k = 1 / 2
state_after: no goals
tactic: norm_num
Theorem: CategoryTheory.Limits.Pi.reindex_inv_π
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ✝ : Type w₃
C : Type u
inst✝² : Category.{v, u} C
γ : Type w'
ε : β ≃ γ
f : γ → C
inst✝¹ : HasProduct f
inst✝ : HasProduct (f ∘ ⇑ε)
b : β
⊢ (reindex ε f).inv ≫ π (f ∘ ⇑ε) b = π f (ε b)
state_after: no goals
tactic: simp [Iso.inv_comp_eq]
Theorem: CategoryTheory.ComposableArrows.map'_inv_eq_inv_map'
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n✝ m✝ : ℕ
F G : ComposableArrows C n✝
n m : ℕ
h : n + 1 ≤ m
f g : ComposableArrows C m
app : f.obj' n ⋯ ≅ g.obj' n ⋯
app' : f.obj' (n + 1) h ≅ g.obj' (n + 1) h
w : f.map' n (n + 1) ⋯ h ≫ app'.hom = app.hom ≫ g.map' n (n + 1) ⋯ h
⊢ g.map' n (n + 1) ⋯ h ≫ app'.inv = app.inv ≫ f.map' n (n + 1) ⋯ h
state_after: no goals
tactic: rw [← cancel_epi app.hom, ← reassoc_of% w, app'.hom_inv_id, comp_id, app.hom_inv_id_assoc]