ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ProbabilityTheory.integral_gaussianPDFReal_eq_one
File: Mathlib/Probability/Distributions/Gaussian.lean

Proof steps:
state_before: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ ∫ (x : ℝ), gaussianPDFReal μ v x = 1
state_after: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
h : ∫⁻ (x : ℝ), ENNReal.ofReal (gaussianPDFReal μ v x) = 1
⊢ ∫ (x : ℝ), gaussianPDFReal μ v x = 1
tactic: have h := lintegral_gaussianPDFReal_eq_one μ hv
state_before: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
h : ∫⁻ (x : ℝ), ENNReal.ofReal (gaussianPDFReal μ v x) = 1
⊢ ∫ (x : ℝ), gaussianPDFReal μ v x = 1
state_after: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
h : ENNReal.ofReal (∫ (x : ℝ), gaussianPDFReal μ v x) = ENNReal.ofReal 1
⊢ ∫ (x : ℝ), gaussianPDFReal μ v x = 1
tactic: rw [← ofReal_integral_eq_lintegral_ofReal (integrable_gaussianPDFReal _ _)
    (ae_of_all _ (gaussianPDFReal_nonneg _ _)), ← ENNReal.ofReal_one] at h
state_before: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
h : ENNReal.ofReal (∫ (x : ℝ), gaussianPDFReal μ v x) = ENNReal.ofReal 1
⊢ ∫ (x : ℝ), gaussianPDFReal μ v x = 1
state_after: no goals
tactic: rwa [← ENNReal.ofReal_eq_ofReal_iff (integral_nonneg (gaussianPDFReal_nonneg _ _)) zero_le_one]
Theorem: Finset.eventually_constant_prod
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 : α → β
inst✝ : CommMonoid β
u : ℕ → β
N : ℕ
hu : ∀ n ≥ N, u n = 1
n : ℕ
hn : N ≤ n
⊢ ∏ k ∈ range n, u k = ∏ k ∈ range N, u k
state_after: case intro
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
u : ℕ → β
N : ℕ
hu : ∀ n ≥ N, u n = 1
m : ℕ
hn : N ≤ N + m
⊢ ∏ k ∈ range (N + m), u k = ∏ k ∈ range N, u k
tactic: obtain ⟨m, rfl : n = N + m⟩ := Nat.exists_eq_add_of_le hn
state_before: case intro
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
u : ℕ → β
N : ℕ
hu : ∀ n ≥ N, u n = 1
m : ℕ
hn : N ≤ N + m
⊢ ∏ k ∈ range (N + m), u k = ∏ k ∈ range N, u k
state_after: case intro
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
u : ℕ → β
N : ℕ
hu : ∀ n ≥ N, u n = 1
m : ℕ
⊢ ∏ k ∈ range (N + m), u k = ∏ k ∈ range N, u k
tactic: clear hn
state_before: case intro
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
u : ℕ → β
N : ℕ
hu : ∀ n ≥ N, u n = 1
m : ℕ
⊢ ∏ k ∈ range (N + m), u k = ∏ k ∈ range N, u k
state_after: case intro.zero
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
u : ℕ → β
N : ℕ
hu : ∀ n ≥ N, u n = 1
⊢ ∏ k ∈ range (N + 0), u k = ∏ k ∈ range N, u k

case intro.succ
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
u : ℕ → β
N : ℕ
hu : ∀ n ≥ N, u n = 1
m : ℕ
hm : ∏ k ∈ range (N + m), u k = ∏ k ∈ range N, u k
⊢ ∏ k ∈ range (N + (m + 1)), u k = ∏ k ∈ range N, u k
tactic: induction' m with m hm
Theorem: div_mul_comm
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b * c = c / b * a
state_after: no goals
tactic: simp
Theorem: PowerSeries.coeff_C_mul_X_pow
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
x : R
k n : ℕ
⊢ (coeff R n) ((C R) x * X ^ k) = if n = k then x else 0
state_after: no goals
tactic: simp [X_pow_eq, coeff_monomial]
Theorem: QuadraticForm.equivalent_one_zero_neg_one_weighted_sum_squared
File: Mathlib/LinearAlgebra/QuadraticForm/Real.lean

Proof steps:
state_before: ι : Type u_1
inst✝³ : Fintype ι
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module ℝ M
inst✝ : FiniteDimensional ℝ M
Q : QuadraticForm ℝ M
w : Fin (FiniteDimensional.finrank ℝ M) → SignType
hw : Equivalent Q (weightedSumSquares ℝ fun i => ↑(w i))
i : Fin (FiniteDimensional.finrank ℝ M)
⊢ (fun x => ↑(w x)) i = -1 ∨ (fun x => ↑(w x)) i = 0 ∨ (fun x => ↑(w x)) i = 1
state_after: no goals
tactic: cases h : w i <;> simp [h]
Theorem: List.ext_get?_iff
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
⊢ l₁ = l₂ → ∀ (n : ℕ), l₁.get? n = l₂.get? n
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ l₁ : List α
n✝ : ℕ
⊢ l₁.get? n✝ = l₁.get? n✝
tactic: rintro rfl _
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ l₁ : List α
n✝ : ℕ
⊢ l₁.get? n✝ = l₁.get? n✝
state_after: no goals
tactic: rfl
Theorem: Cardinal.lift_le_continuum
File: Mathlib/SetTheory/Cardinal/Continuum.lean

Proof steps:
state_before: c : Cardinal.{u}
⊢ lift.{v, u} c ≤ 𝔠 ↔ c ≤ 𝔠
state_after: no goals
tactic: rw [← lift_continuum.{v, u}, lift_le]
Theorem: GenContFract.of_one_le_get?_partDen
File: Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean

Proof steps:
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
b : K
nth_partDen_eq : (of v).partDens.get? n = some b
⊢ 1 ≤ b
state_after: case intro.intro.refl
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
gp_n : Pair K
nth_s_eq : (of v).s.get? n = some gp_n
nth_partDen_eq : (of v).partDens.get? n = some gp_n.b
⊢ 1 ≤ gp_n.b
tactic: obtain ⟨gp_n, nth_s_eq, ⟨-⟩⟩ : ∃ gp_n, (of v).s.get? n = some gp_n ∧ gp_n.b = b :=
    exists_s_b_of_partDen nth_partDen_eq
state_before: case intro.intro.refl
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
gp_n : Pair K
nth_s_eq : (of v).s.get? n = some gp_n
nth_partDen_eq : (of v).partDens.get? n = some gp_n.b
⊢ 1 ≤ gp_n.b
state_after: case intro.intro.refl.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
gp_n : Pair K
nth_s_eq : (of v).s.get? n = some gp_n
nth_partDen_eq : (of v).partDens.get? n = some gp_n.b
ifp_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_n
ifp_n_b_eq_gp_n_b : ↑ifp_n.b = gp_n.b
⊢ 1 ≤ gp_n.b
tactic: obtain ⟨ifp_n, succ_nth_stream_eq, ifp_n_b_eq_gp_n_b⟩ :
      ∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ (ifp.b : K) = gp_n.b :=
    IntFractPair.exists_succ_get?_stream_of_gcf_of_get?_eq_some nth_s_eq
state_before: case intro.intro.refl.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
gp_n : Pair K
nth_s_eq : (of v).s.get? n = some gp_n
nth_partDen_eq : (of v).partDens.get? n = some gp_n.b
ifp_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_n
ifp_n_b_eq_gp_n_b : ↑ifp_n.b = gp_n.b
⊢ 1 ≤ gp_n.b
state_after: case intro.intro.refl.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
gp_n : Pair K
nth_s_eq : (of v).s.get? n = some gp_n
nth_partDen_eq : (of v).partDens.get? n = some gp_n.b
ifp_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_n
ifp_n_b_eq_gp_n_b : ↑ifp_n.b = gp_n.b
⊢ 1 ≤ ↑ifp_n.b
tactic: rw [← ifp_n_b_eq_gp_n_b]
state_before: case intro.intro.refl.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
gp_n : Pair K
nth_s_eq : (of v).s.get? n = some gp_n
nth_partDen_eq : (of v).partDens.get? n = some gp_n.b
ifp_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_n
ifp_n_b_eq_gp_n_b : ↑ifp_n.b = gp_n.b
⊢ 1 ≤ ↑ifp_n.b
state_after: no goals
tactic: exact mod_cast IntFractPair.one_le_succ_nth_stream_b succ_nth_stream_eq
Theorem: _private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_anticollision
File: Mathlib/NumberTheory/Rayleigh.lean

Proof steps:
state_before: r s : ℝ
hrs : r.IsConjExponent s
j k : ℤ
⊢ ¬∃ j k m, ↑k < ↑j / r ∧ (↑j + 1) / r ≤ ↑k + 1 ∧ ↑m ≤ ↑j / s ∧ (↑j + 1) / s < ↑m + 1
state_after: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
⊢ False
tactic: intro ⟨j, k, m, h₁₁, h₁₂, h₂₁, h₂₂⟩
state_before: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
⊢ False
state_after: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : ↑k + ↑m < ↑j / r + ↑j / s
⊢ False
tactic: have h₃ := add_lt_add_of_lt_of_le h₁₁ h₂₁
state_before: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : ↑k + ↑m < ↑j / r + ↑j / s
⊢ False
state_after: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : ↑k + ↑m < ↑j / r + ↑j / s
h₄ : (↑j + 1) / r + (↑j + 1) / s < ↑k + 1 + (↑m + 1)
⊢ False
tactic: have h₄ := add_lt_add_of_le_of_lt h₁₂ h₂₂
state_before: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : ↑k + ↑m < ↑j / r + ↑j / s
h₄ : (↑j + 1) / r + (↑j + 1) / s < ↑k + 1 + (↑m + 1)
⊢ False
state_after: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : ↑k + ↑m < ↑j
h₄ : ↑j + 1 < ↑k + 1 + (↑m + 1)
⊢ False
tactic: simp_rw [div_eq_inv_mul, ← right_distrib, hrs.inv_add_inv_conj, one_mul] at h₃ h₄
state_before: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : ↑k + ↑m < ↑j
h₄ : ↑j + 1 < ↑k + 1 + (↑m + 1)
⊢ False
state_after: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : ↑k + ↑m < ↑j
h₄ : ↑j < ↑k + ↑m + ↑1
⊢ False
tactic: rw [← Int.cast_one, ← add_assoc, add_lt_add_iff_right, add_right_comm] at h₄
state_before: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : ↑k + ↑m < ↑j
h₄ : ↑j < ↑k + ↑m + ↑1
⊢ False
state_after: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : k + m < j
h₄ : j ≤ k + m
⊢ False
tactic: simp_rw [← Int.cast_add, Int.cast_lt, Int.lt_add_one_iff] at h₃ h₄
state_before: r s : ℝ
hrs : r.IsConjExponent s
j✝ k✝ j k m : ℤ
h₁₁ : ↑k < ↑j / r
h₁₂ : (↑j + 1) / r ≤ ↑k + 1
h₂₁ : ↑m ≤ ↑j / s
h₂₂ : (↑j + 1) / s < ↑m + 1
h₃ : k + m < j
h₄ : j ≤ k + m
⊢ False
state_after: no goals
tactic: exact h₄.not_lt h₃
Theorem: abs_norm_sub_norm_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ |‖a‖ - ‖b‖| ≤ ‖a / b‖
state_after: no goals
tactic: simpa [dist_eq_norm_div] using abs_dist_sub_le a b 1
Theorem: Besicovitch.multiplicity_le
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ multiplicity E ≤ 5 ^ finrank ℝ E
state_after: case h₁
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ {N | ∃ s, s.card = N ∧ (∀ c ∈ s, ‖c‖ ≤ 2) ∧ ∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 ≤ ‖c - d‖}.Nonempty

case h₂
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ ∀ b ∈ {N | ∃ s, s.card = N ∧ (∀ c ∈ s, ‖c‖ ≤ 2) ∧ ∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 ≤ ‖c - d‖}, b ≤ 5 ^ finrank ℝ E
tactic: apply csSup_le
Theorem: LieIdeal.coe_killingCompl_top
File: Mathlib/Algebra/Lie/TraceForm.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : 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✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : Module.Free R L
inst✝ : Module.Finite R L
I : LieIdeal R L
⊢ (lieIdealSubalgebra R L (killingCompl R L ⊤)).toSubmodule = LinearMap.ker (killingForm R L)
state_after: case h
R : Type u_1
K : Type u_2
L : 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✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : Module.Free R L
inst✝ : Module.Finite R L
I : LieIdeal R L
x : L
⊢ x ∈ (lieIdealSubalgebra R L (killingCompl R L ⊤)).toSubmodule ↔ x ∈ LinearMap.ker (killingForm R L)
tactic: ext x
state_before: case h
R : Type u_1
K : Type u_2
L : 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✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : Module.Free R L
inst✝ : Module.Finite R L
I : LieIdeal R L
x : L
⊢ x ∈ (lieIdealSubalgebra R L (killingCompl R L ⊤)).toSubmodule ↔ x ∈ LinearMap.ker (killingForm R L)
state_after: no goals
tactic: simp [LinearMap.ext_iff, LinearMap.BilinForm.IsOrtho, LieModule.traceForm_comm R L L x]
Theorem: sbtw_pointReflection_of_ne
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
h : x ≠ y
⊢ Sbtw R y x ((pointReflection R x) y)
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
h : x ≠ y
⊢ x ≠ (pointReflection R x) y
tactic: refine ⟨wbtw_pointReflection _ _ _, h, ?_⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
h : x ≠ y
⊢ x ≠ (pointReflection R x) y
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
h : x ≠ y
⊢ (pointReflection R x) x ≠ (pointReflection R x) y
tactic: nth_rw 1 [← pointReflection_self R x]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
h : x ≠ y
⊢ (pointReflection R x) x ≠ (pointReflection R x) y
state_after: no goals
tactic: exact (pointReflection_involutive R x).injective.ne h
Theorem: PowerSeries.ker_coeff_eq_max_ideal
File: Mathlib/RingTheory/PowerSeries/Inverse.lean

Proof steps:
state_before: R : Type u_1
k : Type u_2
inst✝ : Field k
x✝ : k⟦X⟧
⊢ x✝ ∈ RingHom.ker (constantCoeff k) ↔ x✝ ∈ maximalIdeal k⟦X⟧
state_after: no goals
tactic: rw [RingHom.mem_ker, maximalIdeal_eq_span_X, Ideal.mem_span_singleton, X_dvd_iff]
Theorem: TruncatedWittVector.truncate_comp
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
n₁ n₂ n₃ : ℕ
h1 : n₁ ≤ n₂
h2 : n₂ ≤ n₃
⊢ (truncate h1).comp (truncate h2) = truncate ⋯
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
n₁ n₂ n₃ : ℕ
h1 : n₁ ≤ n₂
h2 : n₂ ≤ n₃
x : TruncatedWittVector p n₃ R
⊢ ((truncate h1).comp (truncate h2)) x = (truncate ⋯) x
tactic: ext1 x
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
n₁ n₂ n₃ : ℕ
h1 : n₁ ≤ n₂
h2 : n₂ ≤ n₃
x : TruncatedWittVector p n₃ R
⊢ ((truncate h1).comp (truncate h2)) x = (truncate ⋯) x
state_after: no goals
tactic: simp only [truncate_truncate, Function.comp_apply, RingHom.coe_comp]
Theorem: AlgebraicTopology.AlternatingCofaceMapComplex.d_squared
File: Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.75369, u_2} A
inst✝ : Abelian A
X Y : CosimplicialObject C
n : ℕ
⊢ objD X n ≫ objD X (n + 1) = 0
state_after: no goals
tactic: simp only [d_eq_unop_d, ← unop_comp, AlternatingFaceMapComplex.d_squared, unop_zero]
Theorem: HurwitzZeta.cosZeta_two_mul_nat
File: Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean

Proof steps:
state_before: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ cosZeta (↑x) (2 * ↑k) =
    (-1) ^ (k + 1) * (2 * ↑π) ^ (2 * k) / 2 / ↑(2 * k)! *
      Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * k)))
state_after: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ ∑' (b : ℕ), ↑(Real.cos (2 * π * x * ↑b)) / ↑b ^ (2 * ↑k) =
    (-1) ^ (k + 1) * (2 * ↑π) ^ (2 * k) / 2 / ↑(2 * k)! *
      Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * k)))

k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ 1 < (2 * ↑k).re
tactic: rw [← (hasSum_nat_cosZeta x (?_ : 1 < re (2 * k))).tsum_eq]
Theorem: AddUnits.val_eq_zero
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u a : αˣ
⊢ ↑a = 1 ↔ a = 1
state_after: no goals
tactic: rw [← Units.val_one, eq_iff]
Theorem: StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf_app
File: Mathlib/Topology/Sheaves/Skyscraper.lean

Proof steps:
state_before: X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕.stalk p₀ ⟶ c
U V : (Opens ↑X)ᵒᵖ
inc : U ⟶ V
⊢ 𝓕.map inc ≫
      (fun U => if h : p₀ ∈ unop U then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj U)) V =
    (fun U => if h : p₀ ∈ unop U then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj U)) U ≫
      (skyscraperPresheaf p₀ c).map inc
state_after: X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕.stalk p₀ ⟶ c
U V : (Opens ↑X)ᵒᵖ
inc : U ⟶ V
⊢ (𝓕.map inc ≫ if h : p₀ ∈ unop V then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj V)) =
    (if h : p₀ ∈ unop U then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj U)) ≫
      if h : p₀ ∈ unop V then eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (if p₀ ∈ unop U then c else ⊤_ C)
tactic: dsimp
state_before: X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕.stalk p₀ ⟶ c
U V : (Opens ↑X)ᵒᵖ
inc : U ⟶ V
⊢ (𝓕.map inc ≫ if h : p₀ ∈ unop V then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj V)) =
    (if h : p₀ ∈ unop U then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj U)) ≫
      if h : p₀ ∈ unop V then eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (if p₀ ∈ unop U then c else ⊤_ C)
state_after: case pos
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕.stalk p₀ ⟶ c
U V : (Opens ↑X)ᵒᵖ
inc : U ⟶ V
hV : p₀ ∈ unop V
⊢ (𝓕.map inc ≫ if h : p₀ ∈ unop V then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj V)) =
    (if h : p₀ ∈ unop U then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj U)) ≫
      if h : p₀ ∈ unop V then eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (if p₀ ∈ unop U then c else ⊤_ C)

case neg
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕.stalk p₀ ⟶ c
U V : (Opens ↑X)ᵒᵖ
inc : U ⟶ V
hV : p₀ ∉ unop V
⊢ (𝓕.map inc ≫ if h : p₀ ∈ unop V then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj V)) =
    (if h : p₀ ∈ unop U then 𝓕.germ ⟨p₀, h⟩ ≫ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj U)) ≫
      if h : p₀ ∈ unop V then eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (if p₀ ∈ unop U then c else ⊤_ C)
tactic: by_cases hV : p₀ ∈ V.unop
Theorem: MonoidHom.compAddChar_injective_right
File: Mathlib/Algebra/Group/AddChar.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ : AddChar A M
f : M →* N
hf : Injective ⇑f
⊢ Injective fun ψ => f.compAddChar ψ
state_after: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ✝ : AddChar A M
f : M →* N
hf : Injective ⇑f
ψ χ : AddChar B M
h : (fun ψ => f.compAddChar ψ) ψ = (fun ψ => f.compAddChar ψ) χ
⊢ ψ = χ
tactic: rintro ψ χ h
state_before: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ✝ : AddChar A M
f : M →* N
hf : Injective ⇑f
ψ χ : AddChar B M
h : (fun ψ => f.compAddChar ψ) ψ = (fun ψ => f.compAddChar ψ) χ
⊢ ψ = χ
state_after: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ✝ : AddChar A M
f : M →* N
hf : Injective ⇑f
ψ χ : AddChar B M
h : ⇑((fun ψ => f.compAddChar ψ) ψ) = ⇑((fun ψ => f.compAddChar ψ) χ)
⊢ ⇑ψ = ⇑χ
tactic: rw [DFunLike.ext'_iff] at h ⊢
state_before: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ✝ : AddChar A M
f : M →* N
hf : Injective ⇑f
ψ χ : AddChar B M
h : ⇑((fun ψ => f.compAddChar ψ) ψ) = ⇑((fun ψ => f.compAddChar ψ) χ)
⊢ ⇑ψ = ⇑χ
state_after: no goals
tactic: exact hf.comp_left h
Theorem: AntitoneOn.map_sup
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → β
s : Set α
x y : α
inst✝¹ : LinearOrder α
inst✝ : SemilatticeInf β
hf : AntitoneOn f s
hx : x ∈ s
hy : y ∈ s
⊢ f (x ⊔ y) = f x ⊓ f y
state_after: no goals
tactic: cases le_total x y <;> have := hf ?_ ?_ ‹_› <;>
    first
    | assumption
    | simp only [*, sup_of_le_left, sup_of_le_right, inf_of_le_left, inf_of_le_right]
Theorem: Finset.card_equiv
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f : α → β
n : ℕ
t : Finset β
e : α ≃ β
hst : ∀ (i : α), i ∈ s ↔ e i ∈ t
⊢ s.card = t.card
state_after: no goals
tactic: refine card_nbij' e e.symm ?_ ?_ ?_ ?_ <;> simp [hst]