ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Monoid.image_closure
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝² : Monoid M
s✝ : Set M
A✝ : Type u_2
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_3
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
⊢ f '' Closure s ≤ Closure (f '' s)
state_after: case intro.intro
M : Type u_1
inst✝² : Monoid M
s✝ : Set M
A✝ : Type u_2
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_3
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x : M
hx : x ∈ Closure s
⊢ f x ∈ Closure (f '' s)
tactic: rintro _ ⟨x, hx, rfl⟩
state_before: case intro.intro
M : Type u_1
inst✝² : Monoid M
s✝ : Set M
A✝ : Type u_2
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_3
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x : M
hx : x ∈ Closure s
⊢ f x ∈ Closure (f '' s)
state_after: case intro.intro.basic
M : Type u_1
inst✝² : Monoid M
s✝ : Set M
A✝ : Type u_2
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_3
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x z : M
hz : z ∈ s
⊢ f z ∈ Closure (f '' s)

case intro.intro.one
M : Type u_1
inst✝² : Monoid M
s✝ : Set M
A✝ : Type u_2
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_3
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x : M
⊢ f 1 ∈ Closure (f '' s)

case intro.intro.mul
M : Type u_1
inst✝² : Monoid M
s✝ : Set M
A✝ : Type u_2
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_3
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x a✝² b✝ : M
a✝¹ : InClosure s a✝²
a✝ : InClosure s b✝
a_ih✝¹ : f a✝² ∈ Closure (f '' s)
a_ih✝ : f b✝ ∈ Closure (f '' s)
⊢ f (a✝² * b✝) ∈ Closure (f '' s)
tactic: induction' hx with z hz
Theorem: AList.insert_entries_of_neg
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : AList β
h : a ∉ s
⊢ (insert a b s).entries = ⟨a, b⟩ :: s.entries
state_after: no goals
tactic: rw [insert_entries, kerase_of_not_mem_keys h]
Theorem: EuclideanGeometry.angle_lt_pi_div_two_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ < π / 2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ < π / 2
tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
    inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ < π / 2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ < π / 2
tactic: rw [ne_comm, ← @vsub_ne_zero V] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ < π / 2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ InnerProductGeometry.angle (p₂ -ᵥ p₃) (p₂ -ᵥ p₃ + (p₁ -ᵥ p₂)) < π / 2
tactic: rw [angle, ← vsub_add_vsub_cancel p₁ p₂ p₃, add_comm]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ InnerProductGeometry.angle (p₂ -ᵥ p₃) (p₂ -ᵥ p₃ + (p₁ -ᵥ p₂)) < π / 2
state_after: no goals
tactic: exact angle_add_lt_pi_div_two_of_inner_eq_zero h h0
Theorem: Pell.xn_modEq_x2n_sub
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
⊢ xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]
state_after: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
this : 2 * n - j + j ≤ n + j
⊢ xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]
tactic: have : 2 * n - j + j ≤ n + j := by
      rw [tsub_add_cancel_of_le h, two_mul]; exact Nat.add_le_add_left jn _
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
this : 2 * n - j + j ≤ n + j
⊢ xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]
state_after: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
this : 2 * n - j + j ≤ n + j
t : xn a1 (2 * n - (2 * n - j)) + xn a1 (2 * n - j) ≡ 0 [MOD xn a1 n] :=
  xn_modEq_x2n_sub_lem a1 (Nat.le_of_add_le_add_right this)
⊢ xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]
tactic: let t := xn_modEq_x2n_sub_lem a1 (Nat.le_of_add_le_add_right this)
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
this : 2 * n - j + j ≤ n + j
t : xn a1 (2 * n - (2 * n - j)) + xn a1 (2 * n - j) ≡ 0 [MOD xn a1 n] :=
  xn_modEq_x2n_sub_lem a1 (Nat.le_of_add_le_add_right this)
⊢ xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]
state_after: no goals
tactic: rwa [tsub_tsub_cancel_of_le h, add_comm] at t
Theorem: EReal.image_coe_Ici
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : ℝ
⊢ Real.toEReal '' Ici x = Ico ↑x ⊤
state_after: x : ℝ
⊢ WithBot.some '' (WithTop.some '' Ici x) = Ico ↑x ⊤
tactic: refine (image_comp WithBot.some WithTop.some _).trans ?_
state_before: x : ℝ
⊢ WithBot.some '' (WithTop.some '' Ici x) = Ico ↑x ⊤
state_after: x : ℝ
⊢ Ico ↑↑x ↑⊤ = Ico ↑x ⊤
tactic: rw [WithTop.image_coe_Ici, WithBot.image_coe_Ico]
state_before: x : ℝ
⊢ Ico ↑↑x ↑⊤ = Ico ↑x ⊤
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.eLpNorm'_measure_zero_of_pos
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
hq_pos : 0 < q
⊢ eLpNorm' f q 0 = 0
state_after: no goals
tactic: simp [eLpNorm', hq_pos]
Theorem: _private.Mathlib.MeasureTheory.Decomposition.SignedHahn.0.MeasureTheory.SignedMeasure.restrictNonposSeq_succ
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n : ℕ
⊢ MeasureTheory.SignedMeasure.restrictNonposSeq s i n.succ =
    MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \ ⋃ k, ⋃ (_ : k ≤ n), MeasureTheory.SignedMeasure.restrictNonposSeq s i k)
state_after: no goals
tactic: rw [restrictNonposSeq]
Theorem: LieSubmodule.normalizer_inf
File: Mathlib/Algebra/Lie/Normalizer.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
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
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer
state_after: case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
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
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m✝ : M
⊢ m✝ ∈ (N₁ ⊓ N₂).normalizer ↔ m✝ ∈ N₁.normalizer ⊓ N₂.normalizer
tactic: ext
state_before: case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
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
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m✝ : M
⊢ m✝ ∈ (N₁ ⊓ N₂).normalizer ↔ m✝ ∈ N₁.normalizer ⊓ N₂.normalizer
state_after: no goals
tactic: simp [← forall_and]
Theorem: MeasureTheory.lintegral_eq_nnreal
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
μ : Measure α
⊢ ∫⁻ (a : α), f a ∂μ = ⨆ φ, ⨆ (_ : ∀ (x : α), ↑(↑φ x) ≤ f x), (SimpleFunc.map ofNNReal φ).lintegral μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
μ : Measure α
⊢ ⨆ g, ⨆ (_ : ↑g ≤ fun a => f a), g.lintegral μ =
    ⨆ φ, ⨆ (_ : ∀ (x : α), ↑(↑φ x) ≤ f x), (SimpleFunc.map ofNNReal φ).lintegral μ
tactic: rw [lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
μ : Measure α
⊢ ⨆ g, ⨆ (_ : ↑g ≤ fun a => f a), g.lintegral μ =
    ⨆ φ, ⨆ (_ : ∀ (x : α), ↑(↑φ x) ≤ f x), (SimpleFunc.map ofNNReal φ).lintegral μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
μ : Measure α
φ : α →ₛ ℝ≥0∞
hφ : ↑φ ≤ fun a => f a
⊢ φ.lintegral μ ≤ ⨆ φ, ⨆ (_ : ∀ (x : α), ↑(↑φ x) ≤ f x), (SimpleFunc.map ofNNReal φ).lintegral μ
tactic: refine
    le_antisymm (iSup₂_le fun φ hφ ↦ ?_) (iSup_mono' fun φ ↦ ⟨φ.map ((↑) : ℝ≥0 → ℝ≥0∞), le_rfl⟩)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
μ : Measure α
φ : α →ₛ ℝ≥0∞
hφ : ↑φ ≤ fun a => f a
⊢ φ.lintegral μ ≤ ⨆ φ, ⨆ (_ : ∀ (x : α), ↑(↑φ x) ≤ f x), (SimpleFunc.map ofNNReal φ).lintegral μ
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
μ : Measure α
φ : α →ₛ ℝ≥0∞
hφ : ↑φ ≤ fun a => f a
h : ∀ᵐ (a : α) ∂μ, ↑φ a ≠ ⊤
⊢ φ.lintegral μ ≤ ⨆ φ, ⨆ (_ : ∀ (x : α), ↑(↑φ x) ≤ f x), (SimpleFunc.map ofNNReal φ).lintegral μ

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
μ : Measure α
φ : α →ₛ ℝ≥0∞
hφ : ↑φ ≤ fun a => f a
h : ¬∀ᵐ (a : α) ∂μ, ↑φ a ≠ ⊤
⊢ φ.lintegral μ ≤ ⨆ φ, ⨆ (_ : ∀ (x : α), ↑(↑φ x) ≤ f x), (SimpleFunc.map ofNNReal φ).lintegral μ
tactic: by_cases h : ∀ᵐ a ∂μ, φ a ≠ ∞
Theorem: finAddFlip_apply_castAdd
File: Mathlib/Logic/Equiv/Fin.lean

Proof steps:
state_before: m n✝ : ℕ
k : Fin m
n : ℕ
⊢ finAddFlip (Fin.castAdd n k) = Fin.natAdd n k
state_after: no goals
tactic: simp [finAddFlip]
Theorem: Multiset.dedup_cons
File: Mathlib/Data/Multiset/FinsetOps.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
⊢ (a ::ₘ s).dedup = ndinsert a s.dedup
state_after: no goals
tactic: by_cases h : a ∈ s <;> simp [h]
Theorem: Submonoid.mem_sup_right
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S T : Submonoid M
⊢ ∀ {x : M}, x ∈ T → x ∈ S ⊔ T
state_after: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S T : Submonoid M
⊢ T ≤ S ⊔ T
tactic: rw [← SetLike.le_def]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S T : Submonoid M
⊢ T ≤ S ⊔ T
state_after: no goals
tactic: exact le_sup_right
Theorem: Finset.sum_sym2_filter_not_isDiag
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι✝ : Type u_1
κ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f g : α✝ → β
ι : Type u_6
α : Type u_7
inst✝¹ : LinearOrder ι
inst✝ : AddCommMonoid α
s : Finset ι
p : Sym2 ι → α
⊢ ∑ i ∈ filter (fun x => ¬x.IsDiag) s.sym2, p i = ∑ i ∈ filter (fun i => i.1 < i.2) s.offDiag, p s(i.1, i.2)
state_after: ι✝ : Type u_1
κ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f g : α✝ → β
ι : Type u_6
α : Type u_7
inst✝¹ : LinearOrder ι
inst✝ : AddCommMonoid α
s : Finset ι
p : Sym2 ι → α
⊢ ∑ i ∈ filter (fun x => ¬x.IsDiag) s.sym2, p i = ∑ i ∈ filter (fun i => i.1 ≤ i.2) s.offDiag, p s(i.1, i.2)
tactic: rw [Finset.offDiag_filter_lt_eq_filter_le]
state_before: ι✝ : Type u_1
κ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f g : α✝ → β
ι : Type u_6
α : Type u_7
inst✝¹ : LinearOrder ι
inst✝ : AddCommMonoid α
s : Finset ι
p : Sym2 ι → α
⊢ ∑ i ∈ filter (fun x => ¬x.IsDiag) s.sym2, p i = ∑ i ∈ filter (fun i => i.1 ≤ i.2) s.offDiag, p s(i.1, i.2)
state_after: ι✝ : Type u_1
κ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f g : α✝ → β
ι : Type u_6
α : Type u_7
inst✝¹ : LinearOrder ι
inst✝ : AddCommMonoid α
s : Finset ι
p : Sym2 ι → α
⊢ ∑ i ∈ filter (fun x => ¬x.IsDiag) s.sym2, p i =
    ∑ x ∈ Finset.subtype (fun i => i.1 ≤ i.2) s.offDiag, p s((↑x).1, (↑x).2)
tactic: conv_rhs => rw [← Finset.sum_subtype_eq_sum_filter]
state_before: ι✝ : Type u_1
κ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f g : α✝ → β
ι : Type u_6
α : Type u_7
inst✝¹ : LinearOrder ι
inst✝ : AddCommMonoid α
s : Finset ι
p : Sym2 ι → α
⊢ ∑ i ∈ filter (fun x => ¬x.IsDiag) s.sym2, p i =
    ∑ x ∈ Finset.subtype (fun i => i.1 ≤ i.2) s.offDiag, p s((↑x).1, (↑x).2)
state_after: case refine_1
ι✝ : Type u_1
κ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f g : α✝ → β
ι : Type u_6
α : Type u_7
inst✝¹ : LinearOrder ι
inst✝ : AddCommMonoid α
s : Finset ι
p : Sym2 ι → α
⊢ ∀ (i : { p // p.1 ≤ p.2 }),
    i ∈ Finset.subtype (fun i => i.1 ≤ i.2) s.offDiag ↔ Sym2.sortEquiv.symm i ∈ filter (fun x => ¬x.IsDiag) s.sym2

case refine_2
ι✝ : Type u_1
κ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f g : α✝ → β
ι : Type u_6
α : Type u_7
inst✝¹ : LinearOrder ι
inst✝ : AddCommMonoid α
s : Finset ι
p : Sym2 ι → α
⊢ ∀ i ∈ Finset.subtype (fun i => i.1 ≤ i.2) s.offDiag, p s((↑i).1, (↑i).2) = p (Sym2.sortEquiv.symm i)
tactic: refine (Finset.sum_equiv Sym2.sortEquiv.symm ?_ ?_).symm
Theorem: List.Nodup.getEquivOfForallMemList_apply
File: Mathlib/Data/List/NodupEquivFin.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
nd : l.Nodup
h : ∀ (x : α), x ∈ l
i : Fin l.length
⊢ (fun a => ⟨indexOf a l, ⋯⟩) ((fun i => l.get i) i) = i
state_after: no goals
tactic: simp [List.indexOf_getElem, nd]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
nd : l.Nodup
h : ∀ (x : α), x ∈ l
a : α
⊢ (fun i => l.get i) ((fun a => ⟨indexOf a l, ⋯⟩) a) = a
state_after: no goals
tactic: simp
Theorem: CategoryTheory.OverPresheafAux.YonedaCollection.map₁_snd
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
p : YonedaCollection F X
⊢ op (CostructuredArrow.mk p.fst) = op (CostructuredArrow.mk (map₁ η p).fst)
state_after: no goals
tactic: rw [YonedaCollection.map₁_fst]
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
p : YonedaCollection F X
⊢ (map₁ η p).snd = G.map (eqToHom ⋯) (η.app (op (CostructuredArrow.mk p.fst)) p.snd)
state_after: no goals
tactic: simp [map₁]
Theorem: hasFDerivAt_jacobiTheta₂_term
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: n : ℤ
z τ : ℂ
⊢ HasFDerivAt (fun p => jacobiTheta₂_term n p.1 p.2) (jacobiTheta₂_term_fderiv n z τ) (z, τ)
state_after: n : ℤ
z τ : ℂ
f : ℂ × ℂ → ℂ := fun p => 2 * ↑π * I * ↑n * p.1 + ↑π * I * ↑n ^ 2 * p.2
⊢ HasFDerivAt (fun p => jacobiTheta₂_term n p.1 p.2) (jacobiTheta₂_term_fderiv n z τ) (z, τ)
tactic: let f : ℂ × ℂ → ℂ := fun p ↦ 2 * π * I * n * p.1 + π * I * n ^ 2 * p.2
state_before: n : ℤ
z τ : ℂ
f : ℂ × ℂ → ℂ := fun p => 2 * ↑π * I * ↑n * p.1 + ↑π * I * ↑n ^ 2 * p.2
⊢ HasFDerivAt (fun p => jacobiTheta₂_term n p.1 p.2) (jacobiTheta₂_term_fderiv n z τ) (z, τ)
state_after: n : ℤ
z τ : ℂ
f : ℂ × ℂ → ℂ := fun p => 2 * ↑π * I * ↑n * p.1 + ↑π * I * ↑n ^ 2 * p.2
⊢ HasFDerivAt f ((2 * ↑π * I * ↑n) • ContinuousLinearMap.fst ℂ ℂ ℂ + (↑π * I * ↑n ^ 2) • ContinuousLinearMap.snd ℂ ℂ ℂ)
    (z, τ)
tactic: suffices HasFDerivAt f ((2 * π * I * n) • (ContinuousLinearMap.fst ℂ ℂ ℂ)
    + (π * I * n ^ 2) • (ContinuousLinearMap.snd ℂ ℂ ℂ)) (z, τ) from this.cexp
state_before: n : ℤ
z τ : ℂ
f : ℂ × ℂ → ℂ := fun p => 2 * ↑π * I * ↑n * p.1 + ↑π * I * ↑n ^ 2 * p.2
⊢ HasFDerivAt f ((2 * ↑π * I * ↑n) • ContinuousLinearMap.fst ℂ ℂ ℂ + (↑π * I * ↑n ^ 2) • ContinuousLinearMap.snd ℂ ℂ ℂ)
    (z, τ)
state_after: no goals
tactic: exact (hasFDerivAt_fst.const_mul _).add (hasFDerivAt_snd.const_mul _)
Theorem: Finsupp.sum_finset_sum_index
File: Mathlib/Algebra/BigOperators/Finsupp.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝¹ : Finset α
f : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝¹ : AddCommMonoid M
inst✝ : CommMonoid N
s✝ : Finset ι
g : ι → α →₀ M
h : α → M → N
h_zero : ∀ (a : α), h a 0 = 1
h_add : ∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂
a : ι
s : Finset ι
has : a ∉ s
ih : ∏ i ∈ s, (g i).prod h = (∑ i ∈ s, g i).prod h
⊢ ∏ i ∈ Finset.cons a s has, (g i).prod h = (∑ i ∈ Finset.cons a s has, g i).prod h
state_after: no goals
tactic: rw [prod_cons, ih, sum_cons, prod_add_index' h_zero h_add]
Theorem: toIcoMod_add_left
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a (p + b) = toIcoMod hp a b
state_after: no goals
tactic: rw [add_comm, toIcoMod_add_right]
Theorem: intervalIntegral.integral_eq_sub_of_hasDerivAt_of_tendsto
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝ : CompleteSpace E
f f' : ℝ → E
hab : a < b
fa fb : E
hderiv : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x
hint : IntervalIntegrable f' volume a b
ha : Tendsto f (𝓝[>] a) (𝓝 fa)
hb : Tendsto f (𝓝[<] b) (𝓝 fb)
⊢ ∫ (y : ℝ) in a..b, f' y = fb - fa
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝ : CompleteSpace E
f f' : ℝ → E
hab : a < b
fa fb : E
hderiv : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x
hint : IntervalIntegrable f' volume a b
ha : Tendsto f (𝓝[>] a) (𝓝 fa)
hb : Tendsto f (𝓝[<] b) (𝓝 fb)
F : ℝ → E := update (update f a fa) b fb
⊢ ∫ (y : ℝ) in a..b, f' y = fb - fa
tactic: set F : ℝ → E := update (update f a fa) b fb
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝ : CompleteSpace E
f f' : ℝ → E
hab : a < b
fa fb : E
hderiv : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x
hint : IntervalIntegrable f' volume a b
ha : Tendsto f (𝓝[>] a) (𝓝 fa)
hb : Tendsto f (𝓝[<] b) (𝓝 fb)
F : ℝ → E := update (update f a fa) b fb
⊢ ∫ (y : ℝ) in a..b, f' y = fb - fa
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝ : CompleteSpace E
f f' : ℝ → E
hab : a < b
fa fb : E
hderiv : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x
hint : IntervalIntegrable f' volume a b
ha : Tendsto f (𝓝[>] a) (𝓝 fa)
hb : Tendsto f (𝓝[<] b) (𝓝 fb)
F : ℝ → E := update (update f a fa) b fb
Fderiv : ∀ x ∈ Ioo a b, HasDerivAt F (f' x) x
⊢ ∫ (y : ℝ) in a..b, f' y = fb - fa
tactic: have Fderiv : ∀ x ∈ Ioo a b, HasDerivAt F (f' x) x := by
    refine fun x hx => (hderiv x hx).congr_of_eventuallyEq ?_
    filter_upwards [Ioo_mem_nhds hx.1 hx.2] with _ hy
    unfold_let F
    rw [update_noteq hy.2.ne, update_noteq hy.1.ne']
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝ : CompleteSpace E
f f' : ℝ → E
hab : a < b
fa fb : E
hderiv : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x
hint : IntervalIntegrable f' volume a b
ha : Tendsto f (𝓝[>] a) (𝓝 fa)
hb : Tendsto f (𝓝[<] b) (𝓝 fb)
F : ℝ → E := update (update f a fa) b fb
Fderiv : ∀ x ∈ Ioo a b, HasDerivAt F (f' x) x
hcont : ContinuousOn F (Icc a b)
⊢ ∫ (y : ℝ) in a..b, f' y = fb - fa
state_after: no goals
tactic: simpa [F, hab.ne, hab.ne'] using integral_eq_sub_of_hasDerivAt_of_le hab.le hcont Fderiv hint
Theorem: ite_le_one
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a b : α
inst✝ : LE α
ha : a ≤ 1
hb : b ≤ 1
⊢ (if p then a else b) ≤ 1
state_after: no goals
tactic: split <;> assumption
Theorem: xor_not_right
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: a b : Prop
⊢ Xor' a ¬b ↔ (a ↔ b)
state_after: no goals
tactic: by_cases a <;> simp [*]
Theorem: CategoryTheory.Iso.cancel_iso_inv_right
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f f' : X ⟶ Y
g : Z ≅ Y
⊢ f ≫ g.inv = f' ≫ g.inv ↔ f = f'
state_after: no goals
tactic: simp only [cancel_mono]
Theorem: Polynomial.root_left_of_root_gcd
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : Field R
p q : R[X]
inst✝¹ : CommSemiring k
inst✝ : DecidableEq R
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
⊢ eval₂ ϕ α f = 0
state_after: case intro
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : Field R
p✝ q : R[X]
inst✝¹ : CommSemiring k
inst✝ : DecidableEq R
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
p : R[X]
hp : f = EuclideanDomain.gcd f g * p
⊢ eval₂ ϕ α f = 0
tactic: cases' EuclideanDomain.gcd_dvd_left f g with p hp
state_before: case intro
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : Field R
p✝ q : R[X]
inst✝¹ : CommSemiring k
inst✝ : DecidableEq R
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
p : R[X]
hp : f = EuclideanDomain.gcd f g * p
⊢ eval₂ ϕ α f = 0
state_after: no goals
tactic: rw [hp, Polynomial.eval₂_mul, hα, zero_mul]