ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ADEInequality.lt_four
File: Mathlib/NumberTheory/ADEInequality.lean

Proof steps:
state_before: q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
⊢ q < 4
state_after: q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
h4 : 0 < 4
⊢ q < 4
tactic: have h4 : (0 : ℚ) < 4 := by norm_num
state_before: q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
h4 : 0 < 4
⊢ q < 4
state_after: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
⊢ sumInv {2, q, r} ≤ 1
tactic: contrapose! H
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
⊢ sumInv {2, q, r} ≤ 1
state_after: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1
tactic: rw [sumInv_pqr]
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1
state_after: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1
tactic: have h4r := H.trans hqr
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
hq : (↑↑q)⁻¹ ≤ 4⁻¹
hr : (↑↑r)⁻¹ ≤ 4⁻¹
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1
state_after: no goals
tactic: calc
    (2⁻¹ + (q : ℚ)⁻¹ + (r : ℚ)⁻¹) ≤ 2⁻¹ + 4⁻¹ + 4⁻¹ := add_le_add (add_le_add le_rfl hq) hr
    _ = 1 := by norm_num
Theorem: NNReal.inv_lt_one_iff
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: x : ℝ≥0
hx : x ≠ 0
⊢ x⁻¹ < 1 ↔ 1 < x
state_after: no goals
tactic: rw [← one_div, div_lt_iff hx, one_mul]
Theorem: AlgebraicGeometry.affineOpensRestrict_apply_coe_coe
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

Proof steps:
state_before: X✝ Y : Scheme
U✝ : X✝.Opens
hU : IsAffineOpen U✝
f : ↑Γ(X✝, U✝)
X : Scheme
U : X.Opens
⊢ (fun U_1 => ↑U_1 ≤ Scheme.Hom.opensRange U.ι) = fun V => ↑V ≤ U
state_after: no goals
tactic: simp
Theorem: multiplicity.dvd_of_multiplicity_pos
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : 0 < multiplicity a b
⊢ a ∣ b
state_after: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : 0 < multiplicity a b
⊢ a ^ 1 ∣ b
tactic: rw [← pow_one a]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : 0 < multiplicity a b
⊢ a ^ 1 ∣ b
state_after: case a
α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : 0 < multiplicity a b
⊢ ↑1 ≤ multiplicity a b
tactic: apply pow_dvd_of_le_multiplicity
state_before: case a
α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : 0 < multiplicity a b
⊢ ↑1 ≤ multiplicity a b
state_after: no goals
tactic: simpa only [Nat.cast_one, PartENat.pos_iff_one_le] using h
Theorem: Asymptotics.IsBigOWith.sub_isLittleO
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E'
g₁ g₂ : α → F'
h₁ : IsBigOWith c₁ l f₁ g
h₂ : f₂ =o[l] g
hc : c₁ < c₂
⊢ IsBigOWith c₂ l (fun x => f₁ x - f₂ x) g
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using h₁.add_isLittleO h₂.neg_left hc
Theorem: IsPoly.neg
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : (α → ℕ) → ℤ
⊢ IsPoly f → IsPoly (-f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f : (α → ℕ) → ℤ
⊢ IsPoly f → IsPoly (0 - f)
tactic: rw [← zero_sub]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : (α → ℕ) → ℤ
⊢ IsPoly f → IsPoly (0 - f)
state_after: no goals
tactic: exact (IsPoly.const 0).sub
Theorem: SetTheory.PGame.add_lf_add_left
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
y z : PGame
h : y ⧏ z
x : PGame
⊢ x + y ⧏ x + z
state_after: xl xr : Type u
y z : PGame
h : y ⧏ z
x : PGame
⊢ y + x ⧏ z + x
tactic: rw [lf_congr add_comm_equiv add_comm_equiv]
state_before: xl xr : Type u
y z : PGame
h : y ⧏ z
x : PGame
⊢ y + x ⧏ z + x
state_after: no goals
tactic: apply add_lf_add_right h
Theorem: Ideal.mul_add_mem_pow_succ_unique
File: Mathlib/RingTheory/Ideal/Norm.lean

Proof steps:
state_before: S : Type u_1
inst✝² : CommRing S
inst✝¹ : IsDomain S
P : Ideal S
P_prime : P.IsPrime
hP : P ≠ ⊥
inst✝ : IsDedekindDomain S
i : ℕ
a d d' e e' : S
a_not_mem : a ∉ P ^ (i + 1)
e_mem : e ∈ P ^ (i + 1)
e'_mem : e' ∈ P ^ (i + 1)
h : a * d + e - (a * d' + e') ∈ P ^ (i + 1)
⊢ d - d' ∈ P
state_after: S : Type u_1
inst✝² : CommRing S
inst✝¹ : IsDomain S
P : Ideal S
P_prime : P.IsPrime
hP : P ≠ ⊥
inst✝ : IsDedekindDomain S
i : ℕ
a d d' e e' : S
a_not_mem : a ∉ P ^ (i + 1)
e_mem : e ∈ P ^ (i + 1)
e'_mem : e' ∈ P ^ (i + 1)
h : a * d + e - (a * d' + e') ∈ P ^ (i + 1)
h' : a * (d - d') ∈ P ^ (i + 1)
⊢ d - d' ∈ P
tactic: have h' : a * (d - d') ∈ P ^ (i + 1) := by
    convert Ideal.add_mem _ h (Ideal.sub_mem _ e'_mem e_mem) using 1
    ring
state_before: S : Type u_1
inst✝² : CommRing S
inst✝¹ : IsDomain S
P : Ideal S
P_prime : P.IsPrime
hP : P ≠ ⊥
inst✝ : IsDedekindDomain S
i : ℕ
a d d' e e' : S
a_not_mem : a ∉ P ^ (i + 1)
e_mem : e ∈ P ^ (i + 1)
e'_mem : e' ∈ P ^ (i + 1)
h : a * d + e - (a * d' + e') ∈ P ^ (i + 1)
h' : a * (d - d') ∈ P ^ (i + 1)
⊢ d - d' ∈ P
state_after: no goals
tactic: exact Ideal.mem_prime_of_mul_mem_pow hP a_not_mem h'
Theorem: tendsto_const_mul_pow_nhds_iff'
File: Mathlib/Topology/Algebra/Order/Field.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d
state_after: case inl
𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
c d : 𝕜
⊢ Tendsto (fun x => c * x ^ 0) atTop (𝓝 d) ↔ (c = 0 ∨ 0 = 0) ∧ c = d

case inr
𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d
tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: case inr
𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d
state_after: case inr.inl
𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
hc : c < 0
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d

case inr.inr.inl
𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
d : 𝕜
hn : n ≠ 0
⊢ Tendsto (fun x => 0 * x ^ n) atTop (𝓝 d) ↔ (0 = 0 ∨ n = 0) ∧ 0 = d

case inr.inr.inr
𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
hc : 0 < c
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d
tactic: rcases lt_trichotomy c 0 with (hc | rfl | hc)
Theorem: MvPolynomial.renameEquiv_apply
File: Mathlib/Algebra/MvPolynomial/Rename.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ ≃ τ
p : MvPolynomial σ R
⊢ (rename ⇑f.symm) ((rename ⇑f) p) = p
state_after: no goals
tactic: rw [rename_rename, f.symm_comp_self, rename_id]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ ≃ τ
p : MvPolynomial τ R
⊢ (rename ⇑f) ((rename ⇑f.symm) p) = p
state_after: no goals
tactic: rw [rename_rename, f.self_comp_symm, rename_id]
Theorem: CategoryTheory.Subgroupoid.mem_discrete_iff
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d : C
f : c ⟶ d
⊢ f ∈ discrete.arrows c d → ∃ (h : c = d), f = eqToHom h
state_after: case id
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d : C
⊢ ∃ (h : c = c), 𝟙 c = eqToHom h
tactic: rintro ⟨⟩
state_before: case id
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d : C
⊢ ∃ (h : c = c), 𝟙 c = eqToHom h
state_after: no goals
tactic: exact ⟨rfl, rfl⟩
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d : C
f : c ⟶ d
⊢ (∃ (h : c = d), f = eqToHom h) → f ∈ discrete.arrows c d
state_after: case intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
⊢ eqToHom ⋯ ∈ discrete.arrows c c
tactic: rintro ⟨rfl, rfl⟩
state_before: case intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
⊢ eqToHom ⋯ ∈ discrete.arrows c c
state_after: no goals
tactic: constructor
Theorem: MeasureTheory.FiniteMeasure.restrict_nonzero_iff
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A : Set Ω
⊢ μ.restrict A ≠ 0 ↔ μ A ≠ 0
state_after: no goals
tactic: rw [← mass_nonzero_iff, restrict_mass]
Theorem: Nat.bodd_add_div2
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ (bif n.succ.bodd then 1 else 0) + 2 * n.succ.div2 = n.succ
state_after: m n✝ n : ℕ
⊢ (bif n.bodd then 0 else 1) + (bif n.bodd then n.div2.succ else n.div2) * 2 = n.succ
tactic: simp only [bodd_succ, Bool.cond_not, div2_succ, Nat.mul_comm]
state_before: m n✝ n : ℕ
⊢ (bif n.bodd then 0 else 1) + (bif n.bodd then n.div2.succ else n.div2) * 2 = n.succ
state_after: m n✝ n : ℕ
⊢ (bif n.bodd then 0 else 1) + (bif n.bodd then n.div2.succ else n.div2) * 2 =
    ((bif n.bodd then 1 else 0) + 2 * n.div2).succ
tactic: refine Eq.trans ?_ (congr_arg succ (bodd_add_div2 n))
state_before: m n✝ n : ℕ
⊢ (bif n.bodd then 0 else 1) + (bif n.bodd then n.div2.succ else n.div2) * 2 =
    ((bif n.bodd then 1 else 0) + 2 * n.div2).succ
state_after: case false
m n✝ n : ℕ
⊢ (bif false then 0 else 1) + (bif false then n.div2.succ else n.div2) * 2 =
    ((bif false then 1 else 0) + 2 * n.div2).succ

case true
m n✝ n : ℕ
⊢ (bif true then 0 else 1) + (bif true then n.div2.succ else n.div2) * 2 = ((bif true then 1 else 0) + 2 * n.div2).succ
tactic: cases bodd n
Theorem: Matrix.Pivot.listTransvecCol_mul_last_row_drop
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
i : Fin r ⊕ Unit
k : ℕ
hk : k ≤ r
⊢ ((List.drop k (listTransvecCol M)).prod * M) (inr ()) i = M (inr ()) i
state_after: no goals
tactic: induction hk using Nat.decreasingInduction with
  | of_succ n hn IH =>
    have hn' : n < (listTransvecCol M).length := by simpa [listTransvecCol] using hn
    rw [List.drop_eq_getElem_cons hn']
    simpa [listTransvecCol, Matrix.mul_assoc]
  | self =>
    simp only [length_listTransvecCol, le_refl, List.drop_eq_nil_of_le, List.prod_nil,
      Matrix.one_mul]
Theorem: Valuation.map_one_sub_of_lt
File: Mathlib/RingTheory/Valuation/Basic.lean

Proof steps:
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v x < 1
⊢ v (1 - x) = 1
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (-x) < v 1
⊢ v (1 - x) = 1
tactic: rw [← v.map_one, ← v.map_neg] at h
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (-x) < v 1
⊢ v (1 - x) = 1
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (-x) < v 1
⊢ v (1 + -x) = 1
tactic: rw [sub_eq_add_neg 1 x]
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (-x) < v 1
⊢ v (1 + -x) = 1
state_after: no goals
tactic: simpa only [v.map_one, v.map_neg] using v.map_add_eq_of_lt_left h
Theorem: Matroid.StrictRestriction.ssubset
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N <r M
⊢ N.E ⊂ M.E
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
h : M ↾ R <r M
⊢ (M ↾ R).E ⊂ M.E
tactic: obtain ⟨R, -, rfl⟩ := h.1
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
h : M ↾ R <r M
⊢ (M ↾ R).E ⊂ M.E
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
h : M ↾ R <r M
h' : (M ↾ R).E = M.E
⊢ M = M ↾ R ↾ R
tactic: refine h.restriction.subset.ssubset_of_ne (fun h' ↦ h.2 ⟨R, Subset.rfl, ?_⟩)
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
h : M ↾ R <r M
h' : (M ↾ R).E = M.E
⊢ M = M ↾ R ↾ R
state_after: no goals
tactic: rw [show R = M.E from h', restrict_idem, restrict_ground_eq_self]
Theorem: CategoryTheory.Limits.Cocones.whiskeringEquivalence_unitIso
File: Mathlib/CategoryTheory/Limits/Cones.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
e : K ≌ J
s : Cocone (e.functor ⋙ F)
k : K
⊢ (((whiskering e.inverse ⋙
                    precompose
                      (F.leftUnitor.inv ≫ whiskerRight e.counitIso.inv F ≫ (e.inverse.associator e.functor F).inv)) ⋙
                  whiskering e.functor).obj
              s).ι.app
        k ≫
      (Iso.refl
          (((whiskering e.inverse ⋙
                    precompose
                      (F.leftUnitor.inv ≫ whiskerRight e.counitIso.inv F ≫ (e.inverse.associator e.functor F).inv)) ⋙
                  whiskering e.functor).obj
              s).pt).hom =
    ((𝟭 (Cocone (e.functor ⋙ F))).obj s).ι.app k
state_after: no goals
tactic: simpa [e.counitInv_app_functor k] using s.w (e.unit.app k)
Theorem: Multiset.sum_hom
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F✝ : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝⁴ : CommMonoid α
inst✝³ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f✝ g : ι → α
inst✝² : CommMonoid β
s : Multiset α
F : Type u_6
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
l : List α
⊢ (map ⇑f ⟦l⟧).prod = f (prod ⟦l⟧)
state_after: no goals
tactic: simp only [l.prod_hom f, quot_mk_to_coe, map_coe, prod_coe]
Theorem: ENNReal.inv_lt_one
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a⁻¹ < 1 ↔ 1 < a
state_after: no goals
tactic: rw [inv_lt_iff_inv_lt, inv_one]
Theorem: Submodule.biInf_comap_proj
File: Mathlib/LinearAlgebra/Pi.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝² : Semiring R
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x : (i : ι) → φ i
⊢ ⨅ i ∈ I, comap (proj i) (p i) = pi I p
state_after: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝² : Semiring R
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x✝ x : (i : ι) → φ i
⊢ x ∈ ⨅ i ∈ I, comap (proj i) (p i) ↔ x ∈ pi I p
tactic: ext x
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝² : Semiring R
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x✝ x : (i : ι) → φ i
⊢ x ∈ ⨅ i ∈ I, comap (proj i) (p i) ↔ x ∈ pi I p
state_after: no goals
tactic: simp
Theorem: PicardLindelof.dist_t₀_le
File: Mathlib/Analysis/ODE/PicardLindelof.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
⊢ dist t v.t₀ ≤ v.tDist
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
⊢ |↑t - ↑v.t₀| ≤ v.tDist
tactic: rw [Subtype.dist_eq, Real.dist_eq]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
⊢ |↑t - ↑v.t₀| ≤ v.tDist
state_after: case inl
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : t ≤ v.t₀
⊢ |↑t - ↑v.t₀| ≤ v.tDist

case inr
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : v.t₀ ≤ t
⊢ |↑t - ↑v.t₀| ≤ v.tDist
tactic: rcases le_total t v.t₀ with ht | ht
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ''
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ j.castSucc
⊢ X.δ j.succ ≫ X.δ (i.castLT ⋯) = X.δ i ≫ X.δ j
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ j.castSucc
⊢ X.map (SimplexCategory.δ j.succ).op ≫ X.map (SimplexCategory.δ (i.castLT ⋯)).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.δ j).op
tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ j.castSucc
⊢ X.map (SimplexCategory.δ j.succ).op ≫ X.map (SimplexCategory.δ (i.castLT ⋯)).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.δ j).op
state_after: no goals
tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ'' H]
Theorem: absorbs_iff_norm
File: Mathlib/Analysis/LocallyConvex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s t u v A B : Set E
⊢ (∃ i, True ∧ ∀ ⦃x : 𝕜⦄, x ∈ norm ⁻¹' Ici i → B ⊆ x • A) ↔ ∃ r, ∀ (c : 𝕜), r ≤ ‖c‖ → B ⊆ c • A
state_after: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s t u v A B : Set E
⊢ (∃ i, ∀ ⦃x : 𝕜⦄, x ∈ norm ⁻¹' Ici i → B ⊆ x • A) ↔ ∃ r, ∀ (c : 𝕜), r ≤ ‖c‖ → B ⊆ c • A
tactic: simp only [true_and]
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s t u v A B : Set E
⊢ (∃ i, ∀ ⦃x : 𝕜⦄, x ∈ norm ⁻¹' Ici i → B ⊆ x • A) ↔ ∃ r, ∀ (c : 𝕜), r ≤ ‖c‖ → B ⊆ c • A
state_after: no goals
tactic: rfl
Theorem: Set.uIcc_prod_eq
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Lattice α
inst✝ : Lattice β
a✝ a₁ a₂ b✝ b₁ b₂ c x : α
a b : α × β
⊢ [[a, b]] = [[a.1, b.1]] ×ˢ [[a.2, b.2]]
state_after: no goals
tactic: simp
Theorem: Rel.dom_inv
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
⊢ r.inv.dom = r.codom
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
x : β
⊢ x ∈ r.inv.dom ↔ x ∈ r.codom
tactic: ext x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
x : β
⊢ x ∈ r.inv.dom ↔ x ∈ r.codom
state_after: no goals
tactic: rfl
Theorem: Quiver.Symmetrify.lift_reverse
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

Proof steps:
state_before: U : Type u_1
V : Type u_2
W : Type u_3
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_4
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
f : X ⟶ Y
⊢ (lift φ).map (reverse f) = reverse ((lift φ).map f)
state_after: U : Type u_1
V : Type u_2
W : Type u_3
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_4
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
f : X ⟶ Y
⊢ (match Sum.swap f with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    reverse
      (match f with
      | Sum.inl g => φ.map g
      | Sum.inr g => reverse (φ.map g))
tactic: dsimp [Symmetrify.lift]
state_before: U : Type u_1
V : Type u_2
W : Type u_3
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_4
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
f : X ⟶ Y
⊢ (match Sum.swap f with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    reverse
      (match f with
      | Sum.inl g => φ.map g
      | Sum.inr g => reverse (φ.map g))
state_after: case inl
U : Type u_1
V : Type u_2
W : Type u_3
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_4
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
val✝ : X ⟶ Y
⊢ (match (Sum.inl val✝).swap with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    reverse
      (match Sum.inl val✝ with
      | Sum.inl g => φ.map g
      | Sum.inr g => reverse (φ.map g))

case inr
U : Type u_1
V : Type u_2
W : Type u_3
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_4
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
val✝ : Y ⟶ X
⊢ (match (Sum.inr val✝).swap with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    reverse
      (match Sum.inr val✝ with
      | Sum.inl g => φ.map g
      | Sum.inr g => reverse (φ.map g))
tactic: cases f
Theorem: CategoryTheory.Limits.imageSubobject_zero_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝² : HasImage f
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
⊢ (imageSubobject 0).arrow = 0
state_after: C : Type u
inst✝³ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝² : HasImage f
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
⊢ (imageSubobjectIso 0).hom ≫ image.ι 0 = 0
tactic: rw [← imageSubobject_arrow]
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝² : HasImage f
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
⊢ (imageSubobjectIso 0).hom ≫ image.ι 0 = 0
state_after: no goals
tactic: simp
Theorem: lt_div_iff_of_neg'
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
⊢ a < b / c ↔ b < c * a
state_after: no goals
tactic: rw [mul_comm, lt_div_iff_of_neg hc]