ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ONote.NFBelow.fst
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: e : ONote
n : ℕ+
a : ONote
b : Ordinal.{0}
h : (e.oadd n a).NFBelow b
⊢ e.NF
state_after: case oadd'
e : ONote
n : ℕ+
a : ONote
b eb : Ordinal.{0}
h₁ : e.NFBelow eb
h₂ : a.NFBelow e.repr
h₃ : e.repr < b
⊢ e.NF
tactic: cases' h with _ _ _ _ eb _ h₁ h₂ h₃
state_before: case oadd'
e : ONote
n : ℕ+
a : ONote
b eb : Ordinal.{0}
h₁ : e.NFBelow eb
h₂ : a.NFBelow e.repr
h₃ : e.repr < b
⊢ e.NF
state_after: no goals
tactic: exact ⟨⟨_, h₁⟩⟩
Theorem: toIocMod_apply_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 : α
⊢ toIocMod hp a a = a + p
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a < a + p ∧ ∃ z, a = a + p + z • p
tactic: rw [toIocMod_eq_iff hp, Set.right_mem_Ioc]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a < a + p ∧ ∃ z, a = a + p + z • p
state_after: no goals
tactic: exact ⟨lt_add_of_pos_right _ hp, -1, by simp⟩
Theorem: Nat.Partrec.none
File: Mathlib/Computability/Partrec.lean

Proof steps:
state_before: n a : ℕ
x✝ : a ∈ Nat.rfind fun n_1 => (fun m => decide (m = 0)) <$> (↑fun x => 1) (Nat.pair n n_1)
h : (Nat.rfind fun n_1 => (fun m => decide (m = 0)) <$> (↑fun x => 1) (Nat.pair n n_1)).Dom
h✝ : (Nat.rfind fun n_1 => (fun m => decide (m = 0)) <$> (↑fun x => 1) (Nat.pair n n_1)).get h = a
⊢ False
state_after: no goals
tactic: simp at h
Theorem: MonotoneOn.map_max
File: Mathlib/Order/MinMax.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
hf : MonotoneOn f s
ha : a ∈ s
hb : b ∈ s
⊢ f (max a b) = max (f a) (f b)
state_after: no goals
tactic: rcases le_total a b with h | h <;>
    simp only [max_eq_right, max_eq_left, hf ha hb, hf hb ha, h]
Theorem: Real.rpow_eq_nhds_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: p : ℝ × ℝ
hp_fst : 0 < p.1
⊢ (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => rexp (log x.1 * x.2)
state_after: p : ℝ × ℝ
hp_fst : 0 < p.1
⊢ ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, 0 < x.1
tactic: suffices ∀ᶠ x : ℝ × ℝ in 𝓝 p, 0 < x.1 from
    this.mono fun x hx ↦ by
      dsimp only
      rw [rpow_def_of_pos hx]
state_before: p : ℝ × ℝ
hp_fst : 0 < p.1
⊢ ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, 0 < x.1
state_after: no goals
tactic: exact IsOpen.eventually_mem (isOpen_lt continuous_const continuous_fst) hp_fst
Theorem: CategoryTheory.mono_iff_isPullback
File: Mathlib/CategoryTheory/Limits/EpiMono.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PullbackCone f f
⊢ Mono f ↔ IsPullback (𝟙 X) (𝟙 X) f f
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PullbackCone f f
⊢ Mono f → IsPullback (𝟙 X) (𝟙 X) f f

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PullbackCone f f
⊢ IsPullback (𝟙 X) (𝟙 X) f f → Mono f
tactic: constructor
Theorem: List.map_reverse_inits
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ map reverse l.inits = l.reverse.tails.reverse
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ map reverse (map reverse l.reverse.tails).reverse = l.reverse.tails.reverse
tactic: rw [inits_eq_tails l]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ map reverse (map reverse l.reverse.tails).reverse = l.reverse.tails.reverse
state_after: no goals
tactic: simp [reverse_involutive.comp_self, ← map_reverse]
Theorem: Nat.choose_succ_right_eq
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n k : ℕ
⊢ n.choose (k + 1) * (k + 1) = n.choose k * (n - k)
state_after: n k : ℕ
e : (n + 1) * n.choose k = n.choose (k + 1) * (k + 1) + n.choose k * (k + 1)
⊢ n.choose (k + 1) * (k + 1) = n.choose k * (n - k)
tactic: have e : (n + 1) * choose n k = choose n (k + 1) * (k + 1) + choose n k * (k + 1) := by
    rw [← Nat.add_mul, Nat.add_comm (choose _ _), ← choose_succ_succ, succ_mul_choose_eq]
state_before: n k : ℕ
e : (n + 1) * n.choose k = n.choose (k + 1) * (k + 1) + n.choose k * (k + 1)
⊢ n.choose (k + 1) * (k + 1) = n.choose k * (n - k)
state_after: no goals
tactic: rw [← Nat.sub_eq_of_eq_add e, Nat.mul_comm, ← Nat.mul_sub_left_distrib, Nat.add_sub_add_right]
Theorem: Set.ordConnected_of_uIcc_subset_left
File: Mathlib/Order/Interval/Set/OrdConnected.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrder α
s : Set α
x : α
h : ∀ y ∈ s, [[x, y]] ⊆ s
y : α
hy : y ∈ s
z : α
hz : z ∈ s
⊢ [[y, x]] ∪ [[x, z]] = [[x, y]] ∪ [[x, z]]
state_after: no goals
tactic: rw [uIcc_comm]
Theorem: SetTheory.PGame.neg_nim
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: o : Ordinal.{u_1}
⊢ -nim o = nim o
state_after: case h
o : Ordinal.{u_1}
IH : ∀ k < o, -nim k = nim k
⊢ -nim o = nim o
tactic: induction' o using Ordinal.induction with o IH
state_before: case h
o : Ordinal.{u_1}
IH : ∀ k < o, -nim k = nim k
⊢ -nim o = nim o
state_after: case h
o : Ordinal.{u_1}
IH : ∀ k < o, -nim k = nim k
⊢ (-mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
        nim (typein (fun x x_1 => x < x_1) o₂)) =
    mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
      nim (typein (fun x x_1 => x < x_1) o₂)
tactic: rw [nim_def]
state_before: case h
o : Ordinal.{u_1}
IH : ∀ k < o, -nim k = nim k
⊢ (-mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
        nim (typein (fun x x_1 => x < x_1) o₂)) =
    mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
      nim (typein (fun x x_1 => x < x_1) o₂)
state_after: case h
o : Ordinal.{u_1}
IH : ∀ k < o, -nim k = nim k
⊢ (mk (Quotient.out o).α (Quotient.out o).α (fun j => -nim (typein (fun x x_1 => x < x_1) j)) fun i =>
      -nim (typein (fun x x_1 => x < x_1) i)) =
    mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
      nim (typein (fun x x_1 => x < x_1) o₂)
tactic: dsimp
state_before: case h
o : Ordinal.{u_1}
IH : ∀ k < o, -nim k = nim k
⊢ (mk (Quotient.out o).α (Quotient.out o).α (fun j => -nim (typein (fun x x_1 => x < x_1) j)) fun i =>
      -nim (typein (fun x x_1 => x < x_1) i)) =
    mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
      nim (typein (fun x x_1 => x < x_1) o₂)
state_after: no goals
tactic: congr <;> funext i <;> exact IH _ (Ordinal.typein_lt_self i)
Theorem: Matrix.J_squared
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

Proof steps:
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ J l R * J l R = -1
state_after: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (0 * 0 + -1 * 1) (0 * -1 + -1 * 0) (1 * 0 + 0 * 1) (1 * -1 + 0 * 0) = -1
tactic: rw [J, fromBlocks_multiply]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (0 * 0 + -1 * 1) (0 * -1 + -1 * 0) (1 * 0 + 0 * 1) (1 * -1 + 0 * 0) = -1
state_after: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (-1) 0 0 (-1) = -1
tactic: simp only [Matrix.zero_mul, Matrix.neg_mul, zero_add, neg_zero, Matrix.one_mul, add_zero]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (-1) 0 0 (-1) = -1
state_after: no goals
tactic: rw [← neg_zero, ← Matrix.fromBlocks_neg, ← fromBlocks_one]
Theorem: le_map_add_map_sub
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝⁴ : FunLike F α β
inst✝³ : Group α
inst✝² : CommSemigroup β
inst✝¹ : LE β
inst✝ : SubmultiplicativeHomClass F α β
f : F
a b : α
⊢ f a ≤ f b * f (a / b)
state_after: no goals
tactic: simpa only [mul_comm, div_mul_cancel] using map_mul_le_mul f (a / b) b
Theorem: NumberField.Embeddings.coeff_bdd_of_norm_le
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
x : K
h : ∀ (φ : K →+* A), ‖φ x‖ ≤ B
i : ℕ
⊢ ‖(minpoly ℚ x).coeff i‖ ≤ max B 1 ^ finrank ℚ K * ↑((finrank ℚ K).choose (finrank ℚ K / 2))
state_after: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
x : K
h : ∀ (φ : K →+* A), ‖φ x‖ ≤ B
i : ℕ
hx : IsIntegral ℚ x
⊢ ‖(minpoly ℚ x).coeff i‖ ≤ max B 1 ^ finrank ℚ K * ↑((finrank ℚ K).choose (finrank ℚ K / 2))
tactic: have hx := Algebra.IsSeparable.isIntegral ℚ x
state_before: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
x : K
h : ∀ (φ : K →+* A), ‖φ x‖ ≤ B
i : ℕ
hx : IsIntegral ℚ x
⊢ ‖(minpoly ℚ x).coeff i‖ ≤ max B 1 ^ finrank ℚ K * ↑((finrank ℚ K).choose (finrank ℚ K / 2))
state_after: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
x : K
h : ∀ (φ : K →+* A), ‖φ x‖ ≤ B
i : ℕ
hx : IsIntegral ℚ x
⊢ ‖(map (algebraMap ℚ A) (minpoly ℚ x)).coeff i‖ ≤ max B 1 ^ finrank ℚ K * ↑((finrank ℚ K).choose (finrank ℚ K / 2))
tactic: rw [← norm_algebraMap' A, ← coeff_map (algebraMap ℚ A)]
state_before: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
x : K
h : ∀ (φ : K →+* A), ‖φ x‖ ≤ B
i : ℕ
hx : IsIntegral ℚ x
⊢ ‖(map (algebraMap ℚ A) (minpoly ℚ x)).coeff i‖ ≤ max B 1 ^ finrank ℚ K * ↑((finrank ℚ K).choose (finrank ℚ K / 2))
state_after: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
x : K
h : ∀ (φ : K →+* A), ‖φ x‖ ≤ B
i : ℕ
hx : IsIntegral ℚ x
z : A
hz : z ∈ (map (algebraMap ℚ A) (minpoly ℚ x)).roots
⊢ ‖z‖ ≤ B
tactic: refine coeff_bdd_of_roots_le _ (minpoly.monic hx)
      (IsAlgClosed.splits_codomain _) (minpoly.natDegree_le x) (fun z hz => ?_) i
state_before: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
x : K
h : ∀ (φ : K →+* A), ‖φ x‖ ≤ B
i : ℕ
hx : IsIntegral ℚ x
z : A
hz : z ∈ (map (algebraMap ℚ A) (minpoly ℚ x)).roots
⊢ ‖z‖ ≤ B
state_after: no goals
tactic: classical
  rw [← Multiset.mem_toFinset] at hz
  obtain ⟨φ, rfl⟩ := (range_eval_eq_rootSet_minpoly K A x).symm.subset hz
  exact h φ
Theorem: Orientation.cos_oangle_add_left_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle (x + y) y).cos = ‖y‖ / ‖x + y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle y (x + y)).cos = ‖y‖ / ‖x + y‖
tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle y (x + y)).cos = ‖y‖ / ‖x + y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle y (y + x)).cos = ‖y‖ / ‖y + x‖
tactic: rw [add_comm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle y (y + x)).cos = ‖y‖ / ‖y + x‖
state_after: no goals
tactic: exact (-o).cos_oangle_add_right_of_oangle_eq_pi_div_two h
Theorem: Pell.Solution₁.y_mul_pos
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
a b : Solution₁ d
hax : 0 < a.x
hay : 0 < a.y
hbx : 0 < b.x
hby : 0 < b.y
⊢ 0 < (a * b).y
state_after: d : ℤ
a b : Solution₁ d
hax : 0 < a.x
hay : 0 < a.y
hbx : 0 < b.x
hby : 0 < b.y
⊢ 0 < a.x * b.y + a.y * b.x
tactic: simp only [y_mul]
state_before: d : ℤ
a b : Solution₁ d
hax : 0 < a.x
hay : 0 < a.y
hbx : 0 < b.x
hby : 0 < b.y
⊢ 0 < a.x * b.y + a.y * b.x
state_after: no goals
tactic: positivity
Theorem: IsExtreme.extremePoints_subset_extremePoints
File: Mathlib/Analysis/Convex/Extreme.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hAB : IsExtreme 𝕜 A B
x✝ : E
⊢ x✝ ∈ extremePoints 𝕜 B → x✝ ∈ extremePoints 𝕜 A
state_after: no goals
tactic: simpa only [← isExtreme_singleton] using hAB.trans
Theorem: OreLocalization.nontrivial_iff
File: Mathlib/RingTheory/OreLocalization/Ring.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Ring R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddCommGroup X
inst✝ : Module R X
⊢ Nontrivial (OreLocalization S R) ↔ 0 ∉ S
state_after: no goals
tactic: rw [← not_subsingleton_iff_nontrivial, subsingleton_iff]
Theorem: Set.pairwise_pair_of_symmetric
File: Mathlib/Data/Set/Pairwise/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
hr : Symmetric r
⊢ {a, b}.Pairwise r ↔ a ≠ b → r a b
state_after: no goals
tactic: simp [pairwise_insert_of_symmetric hr]
Theorem: List.mem_iota
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: m n : Nat
⊢ m ∈ iota n ↔ 1 ≤ m ∧ m ≤ n
state_after: no goals
tactic: simp [iota_eq_reverse_range', Nat.add_comm, Nat.lt_succ]
Theorem: Set.Finite.encard_eq_coe_toFinset_card
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
h : s.Finite
⊢ s.encard = ↑h.toFinset.card
state_after: α : Type u_1
β : Type u_2
s t : Set α
h : s.Finite
this : Fintype ↑s
⊢ s.encard = ↑h.toFinset.card
tactic: have := h.fintype
state_before: α : Type u_1
β : Type u_2
s t : Set α
h : s.Finite
this : Fintype ↑s
⊢ s.encard = ↑h.toFinset.card
state_after: no goals
tactic: rw [encard, PartENat.card_eq_coe_fintype_card,
    PartENat.withTopEquiv_natCast, toFinite_toFinset, toFinset_card]
Theorem: ProjectiveSpectrum.basicOpen_mul
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ ↑(basicOpen 𝒜 (f * g)) = ↑(basicOpen 𝒜 f ⊓ basicOpen 𝒜 g)
state_after: no goals
tactic: simp [zeroLocus_singleton_mul]
Theorem: Matrix.diagonal_eq_diagonal_iff
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : DecidableEq n
inst✝ : Zero α
d₁ d₂ : n → α
h : diagonal d₁ = diagonal d₂
i : n
⊢ d₁ i = d₂ i
state_after: no goals
tactic: simpa using congr_arg (fun m : Matrix n n α => m i i) h
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : DecidableEq n
inst✝ : Zero α
d₁ d₂ : n → α
h : ∀ (i : n), d₁ i = d₂ i
⊢ diagonal d₁ = diagonal d₂
state_after: no goals
tactic: rw [show d₁ = d₂ from funext h]
Theorem: MeasureTheory.ae_eq_zero_of_eLpNorm'_eq_zero
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
f : α → E
hq0 : 0 ≤ q
hf : AEStronglyMeasurable f μ
h : eLpNorm' f q μ = 0
⊢ f =ᶠ[ae μ] 0
state_after: α : 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
f : α → E
hq0 : 0 ≤ q
hf : AEStronglyMeasurable f μ
h : ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ = 0 ∧ 0 < 1 / q ∨ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ = ⊤ ∧ 1 / q < 0
⊢ f =ᶠ[ae μ] 0
tactic: rw [eLpNorm', ENNReal.rpow_eq_zero_iff] at h
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
f : α → E
hq0 : 0 ≤ q
hf : AEStronglyMeasurable f μ
h : ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ = 0 ∧ 0 < 1 / q ∨ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ = ⊤ ∧ 1 / q < 0
⊢ f =ᶠ[ae μ] 0
state_after: no goals
tactic: cases h with
  | inl h =>
    rw [lintegral_eq_zero_iff' (hf.ennnorm.pow_const q)] at h
    refine h.left.mono fun x hx => ?_
    rw [Pi.zero_apply, ENNReal.rpow_eq_zero_iff] at hx
    cases hx with
    | inl hx =>
      cases' hx with hx _
      rwa [← ENNReal.coe_zero, ENNReal.coe_inj, nnnorm_eq_zero] at hx
    | inr hx =>
      exact absurd hx.left ENNReal.coe_ne_top
  | inr h =>
    exfalso
    rw [one_div, inv_lt_zero] at h
    exact hq0.not_lt h.right
Theorem: Nat.ord_proj_dvd_ord_proj_iff_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
⊢ (∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p) ↔ a ∣ b
state_after: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
⊢ a ∣ b
tactic: refine ⟨fun h => ?_, fun hab p => ord_proj_dvd_ord_proj_of_dvd hb0 hab p⟩
state_before: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
⊢ a ∣ b
state_after: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
⊢ a.factorization ≤ b.factorization
tactic: rw [← factorization_le_iff_dvd ha0 hb0]
state_before: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
⊢ a.factorization ≤ b.factorization
state_after: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
⊢ a.factorization q ≤ b.factorization q
tactic: intro q
state_before: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
⊢ a.factorization q ≤ b.factorization q
state_after: case inl
a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
hq_le : q ≤ 1
⊢ a.factorization q ≤ b.factorization q

case inr
a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
hq1 : 1 < q
⊢ a.factorization q ≤ b.factorization q
tactic: rcases le_or_lt q 1 with (hq_le | hq1)
state_before: case inr
a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
hq1 : 1 < q
⊢ a.factorization q ≤ b.factorization q
state_after: no goals
tactic: exact (pow_dvd_pow_iff_le_right hq1).1 (h q)
Theorem: Function.Periodic.div_const
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✝ : DivisionSemiring α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x / a)) (c * a)
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using h.mul_const_inv a
Theorem: ArithmeticFunction.pow_apply
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
k n : ℕ
⊢ (pow k) n = if k = 0 ∧ n = 0 then 0 else n ^ k
state_after: case zero
R : Type u_1
n : ℕ
⊢ (pow 0) n = if 0 = 0 ∧ n = 0 then 0 else n ^ 0

case succ
R : Type u_1
n n✝ : ℕ
⊢ (pow (n✝ + 1)) n = if n✝ + 1 = 0 ∧ n = 0 then 0 else n ^ (n✝ + 1)
tactic: cases k
state_before: case succ
R : Type u_1
n n✝ : ℕ
⊢ (pow (n✝ + 1)) n = if n✝ + 1 = 0 ∧ n = 0 then 0 else n ^ (n✝ + 1)
state_after: case succ
R : Type u_1
n k : ℕ
⊢ (pow (k + 1)) n = if k + 1 = 0 ∧ n = 0 then 0 else n ^ (k + 1)
tactic: rename_i k
state_before: case succ
R : Type u_1
n k : ℕ
⊢ (pow (k + 1)) n = if k + 1 = 0 ∧ n = 0 then 0 else n ^ (k + 1)
state_after: no goals
tactic: simp [pow, k.succ_pos.ne']
Theorem: MeasureTheory.sum_measure_preimage_singleton
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Finset β
f : α → β
hf : ∀ y ∈ s, MeasurableSet (f ⁻¹' {y})
⊢ ∑ b ∈ s, μ (f ⁻¹' {b}) = μ (f ⁻¹' ↑s)
state_after: no goals
tactic: simp only [← measure_biUnion_finset (pairwiseDisjoint_fiber f s) hf,
    Finset.set_biUnion_preimage_singleton]
Theorem: List.cycleOf_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.Nodup
hn : 2 ≤ l.length
x : { x // x ∈ l }
⊢ 2 ≤ l.attach.length
state_after: no goals
tactic: rwa [← length_attach] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.Nodup
hn✝ : 2 ≤ l.length
x : { x // x ∈ l }
hn : 2 ≤ l.attach.length
⊢ l.attach.Nodup
state_after: no goals
tactic: rwa [← nodup_attach] at hl
Theorem: Function.ExtendByZero.hom_apply
File: Mathlib/Algebra/Group/Pi/Lemmas.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
I : Type u
f✝ : I → Type v
x y : (i : I) → f✝ i
i j : I
η : Type v
R : Type w
s : ι → η
inst✝ : MulOneClass R
f g : ι → R
⊢ { toFun := fun f => extend s f 1, map_one' := ⋯ }.toFun (f * g) =
    { toFun := fun f => extend s f 1, map_one' := ⋯ }.toFun f *
      { toFun := fun f => extend s f 1, map_one' := ⋯ }.toFun g
state_after: no goals
tactic: simpa using Function.extend_mul s f g 1 1
Theorem: WeierstrassCurve.Affine.Y_sub_polynomialY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ Y - W.polynomialY = W.negPolynomial
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ Y - (C (C 2) * Y + C (C W.a₁ * X + C W.a₃)) = -Y - C (C W.a₁ * X + C W.a₃)
tactic: rw [polynomialY, negPolynomial]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ Y - (C (C 2) * Y + C (C W.a₁ * X + C W.a₃)) = -Y - C (C W.a₁ * X + C W.a₃)
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ Y - (2 * Y + (C (C W.a₁) * C X + C (C W.a₃))) = -Y - (C (C W.a₁) * C X + C (C W.a₃))
tactic: C_simp
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ Y - (2 * Y + (C (C W.a₁) * C X + C (C W.a₃))) = -Y - (C (C W.a₁) * C X + C (C W.a₃))
state_after: no goals
tactic: ring
Theorem: Polynomial.splits_of_splits_id
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f x✝¹ : K[X]
hu : IsUnit x✝¹
x✝ : Splits (RingHom.id K) x✝¹
⊢ 0 ≤ 1
state_after: no goals
tactic: decide
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f a p : K[X]
ha0 : a ≠ 0
hp : Prime p
ih : Splits (RingHom.id K) a → Splits i a
hfi : Splits (RingHom.id K) (p * a)
⊢ p ∣ map (RingHom.id K) p
state_after: no goals
tactic: rw [map_id]