1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Sum.LiftRel.isLeft_left
File: Mathlib/Data/Sum/Basic.lean

tactic: cases h
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
h : LiftRel r s x (inl c)
⊢ x.isLeft = true
state_after: case inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
a✝¹ : α
a✝ : r a✝¹ c
⊢ (inl a✝¹).isLeft = true

tactic: rfl
state_before: case inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
a✝¹ : α
a✝ : r a✝¹ c
⊢ (inl a✝¹).isLeft = true
state_after: no goals
Theorem: Array.extract_eq_nil_of_start_eq_end
File: Mathlib/Data/Array/ExtractLemmas.lean

tactic: refine extract_empty_of_stop_le_start a ?h
state_before: α : Type u_1
i : Nat
a : Array α
⊢ a.extract i i = #[]
state_after: case h
α : Type u_1
i : Nat
a : Array α
⊢ i ≤ i

tactic: exact Nat.le_refl i
state_before: case h
α : Type u_1
i : Nat
a : Array α
⊢ i ≤ i
state_after: no goals
Theorem: ValuationSubring.valuation_lt_one_iff
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

tactic: rw [LocalRing.mem_maximalIdeal]
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : ↥A
⊢ a ∈ LocalRing.maximalIdeal ↥A ↔ A.valuation ↑a < 1
state_after: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : ↥A
⊢ a ∈ nonunits ↥A ↔ A.valuation ↑a < 1

tactic: dsimp [nonunits]
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : ↥A
⊢ a ∈ nonunits ↥A ↔ A.valuation ↑a < 1
state_after: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : ↥A
⊢ ¬IsUnit a ↔ A.valuation ↑a < 1

tactic: rw [valuation_eq_one_iff]
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : ↥A
⊢ ¬IsUnit a ↔ A.valuation ↑a < 1
state_after: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : ↥A
⊢ ¬A.valuation ↑a = 1 ↔ A.valuation ↑a < 1

tactic: exact (A.valuation_le_one a).lt_iff_ne.symm
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : ↥A
⊢ ¬A.valuation ↑a = 1 ↔ A.valuation ↑a < 1
state_after: no goals
Theorem: Associates.FactorSet.coe_add
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: norm_cast
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
a b : Multiset { a // Irreducible a }
⊢ ↑(a + b) = ↑a + ↑b
state_after: no goals
Theorem: Matrix.vecMul_surjective_iff_isUnit
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [vecMul_surjective_iff_exists_left_inverse, exists_left_inverse_iff_isUnit]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : DecidableEq m
inst✝³ : DecidableEq n
R : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : Field K
inst✝ : Fintype m
A : Matrix m m R
⊢ (Function.Surjective fun v => v ᵥ* A) ↔ IsUnit A
state_after: no goals
Theorem: Polynomial.splits_map_iff
File: Mathlib/Algebra/Polynomial/Splits.lean

tactic: simp [Splits, Polynomial.map_map]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
j : L →+* F
f : K[X]
⊢ Splits j (map i f) ↔ Splits (j.comp i) f
state_after: no goals
Theorem: RatFunc.algebraMap_eq_zero_iff
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: rw [hx, RingHom.map_zero]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
x : K[X]
hx : x = 0
⊢ (algebraMap K[X] (RatFunc K)) x = 0
state_after: no goals
Theorem: contDiffAt_norm
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: have : ‖id x‖ ^ 2 ≠ 0 := pow_ne_zero 2 (norm_pos_iff.2 hx).ne'
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : E
hx : x ≠ 0
⊢ ContDiffAt ℝ n Norm.norm x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : E
hx : x ≠ 0
this : ‖id x‖ ^ 2 ≠ 0
⊢ ContDiffAt ℝ n Norm.norm x

tactic: simpa only [id, sqrt_sq, norm_nonneg] using (contDiffAt_id.norm_sq 𝕜).sqrt this
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : E
hx : x ≠ 0
this : ‖id x‖ ^ 2 ≠ 0
⊢ ContDiffAt ℝ n Norm.norm x
state_after: no goals
Theorem: CategoryTheory.HasLiftingProperty.unop
File: Mathlib/CategoryTheory/LiftingProperties/Basic.lean

tactic: rw [CommSq.HasLift.iff_op]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A✝ B✝ B' X✝ Y✝ Y' : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p' : Y✝ ⟶ Y'
A B X Y : Cᵒᵖ
i : A ⟶ B
p : X ⟶ Y
h : HasLiftingProperty i p
f : Y.unop ⟶ B.unop
g : X.unop ⟶ A.unop
sq : CommSq f p.unop i.unop g
⊢ sq.HasLift
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A✝ B✝ B' X✝ Y✝ Y' : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p' : Y✝ ⟶ Y'
A B X Y : Cᵒᵖ
i : A ⟶ B
p : X ⟶ Y
h : HasLiftingProperty i p
f : Y.unop ⟶ B.unop
g : X.unop ⟶ A.unop
sq : CommSq f p.unop i.unop g
⊢ ⋯.HasLift

tactic: infer_instance
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A✝ B✝ B' X✝ Y✝ Y' : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p' : Y✝ ⟶ Y'
A B X Y : Cᵒᵖ
i : A ⟶ B
p : X ⟶ Y
h : HasLiftingProperty i p
f : Y.unop ⟶ B.unop
g : X.unop ⟶ A.unop
sq : CommSq f p.unop i.unop g
⊢ ⋯.HasLift
state_after: no goals
Theorem: AddCircle.norm_le_half_period
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: obtain ⟨x⟩ := x
state_before: p : ℝ
x : AddCircle p
hp : p ≠ 0
⊢ ‖x‖ ≤ |p| / 2
state_after: case mk
p : ℝ
x✝ : AddCircle p
hp : p ≠ 0
x : ℝ
⊢ ‖Quot.mk Setoid.r x‖ ≤ |p| / 2

tactic: change ‖(x : AddCircle p)‖ ≤ |p| / 2
state_before: case mk
p : ℝ
x✝ : AddCircle p
hp : p ≠ 0
x : ℝ
⊢ ‖Quot.mk Setoid.r x‖ ≤ |p| / 2
state_after: case mk
p : ℝ
x✝ : AddCircle p
hp : p ≠ 0
x : ℝ
⊢ ‖↑x‖ ≤ |p| / 2

tactic: rw [norm_eq, ← mul_le_mul_left (abs_pos.mpr (inv_ne_zero hp)), ← abs_mul, mul_sub, mul_left_comm,
  ← mul_div_assoc, ← abs_mul, inv_mul_cancel hp, mul_one, abs_one]
state_before: case mk
p : ℝ
x✝ : AddCircle p
hp : p ≠ 0
x : ℝ
⊢ ‖↑x‖ ≤ |p| / 2
state_after: case mk
p : ℝ
x✝ : AddCircle p
hp : p ≠ 0
x : ℝ
⊢ |p⁻¹ * x - ↑(round (p⁻¹ * x))| ≤ 1 / 2

tactic: exact abs_sub_round (p⁻¹ * x)
state_before: case mk
p : ℝ
x✝ : AddCircle p
hp : p ≠ 0
x : ℝ
⊢ |p⁻¹ * x - ↑(round (p⁻¹ * x))| ≤ 1 / 2
state_after: no goals
Theorem: String.Iterator.Valid.validFor
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simpa [List.reverseAux_eq] using @ValidFor.mk l.reverse r
state_before: l r : List Char
⊢ ValidFor l.reverse r { s := { data := l ++ r }, i := { byteIdx := utf8ByteSize.go l } }
state_after: no goals
Theorem: le_mul_iff_one_le_right
File: Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean

tactic: rw [mul_one]
state_before: α : Type u_1
a b c d : α
inst✝⁴ : MulOneClass α
inst✝³ : Zero α
inst✝² : Preorder α
inst✝¹ : PosMulMono α
inst✝ : PosMulReflectLE α
a0 : 0 < a
⊢ a ≤ a * b ↔ a * 1 ≤ a * b
state_after: no goals
Theorem: ContDiffBump.integral_pos
File: Mathlib/Analysis/Calculus/BumpFunction/Normed.lean

tactic: refine (integral_pos_iff_support_of_nonneg f.nonneg' f.integrable).mpr ?_
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < ∫ (x : E), ↑f x ∂μ
state_after: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < μ (support ↑f)

tactic: rw [f.support_eq]
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < μ (support ↑f)
state_after: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < μ (ball c f.rOut)

tactic: exact measure_ball_pos μ c f.rOut_pos
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ 0 < μ (ball c f.rOut)
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.W_isInvertedBy_whiskeringRight_presheafToSheaf
File: Mathlib/CategoryTheory/Sites/PreservesSheafification.lean

tactic: intro P₁ P₂ f hf
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝³ : Category.{u_3, u_1} A
inst✝² : Category.{u_4, u_2} B
F : A ⥤ B
inst✝¹ : J.PreservesSheafification F
inst✝ : HasWeakSheafify J B
⊢ J.W.IsInvertedBy ((whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B)
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝³ : Category.{u_3, u_1} A
inst✝² : Category.{u_4, u_2} B
F : A ⥤ B
inst✝¹ : J.PreservesSheafification F
inst✝ : HasWeakSheafify J B
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
hf : J.W f
⊢ IsIso (((whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B).map f)

tactic: dsimp
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝³ : Category.{u_3, u_1} A
inst✝² : Category.{u_4, u_2} B
F : A ⥤ B
inst✝¹ : J.PreservesSheafification F
inst✝ : HasWeakSheafify J B
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
hf : J.W f
⊢ IsIso (((whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B).map f)
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝³ : Category.{u_3, u_1} A
inst✝² : Category.{u_4, u_2} B
F : A ⥤ B
inst✝¹ : J.PreservesSheafification F
inst✝ : HasWeakSheafify J B
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
hf : J.W f
⊢ IsIso ((presheafToSheaf J B).map (whiskerRight f F))

tactic: rw [← W_iff]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝³ : Category.{u_3, u_1} A
inst✝² : Category.{u_4, u_2} B
F : A ⥤ B
inst✝¹ : J.PreservesSheafification F
inst✝ : HasWeakSheafify J B
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
hf : J.W f
⊢ IsIso ((presheafToSheaf J B).map (whiskerRight f F))
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝³ : Category.{u_3, u_1} A
inst✝² : Category.{u_4, u_2} B
F : A ⥤ B
inst✝¹ : J.PreservesSheafification F
inst✝ : HasWeakSheafify J B
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
hf : J.W f
⊢ J.W (whiskerRight f F)

tactic: exact J.W_of_preservesSheafification F _ hf
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝³ : Category.{u_3, u_1} A
inst✝² : Category.{u_4, u_2} B
F : A ⥤ B
inst✝¹ : J.PreservesSheafification F
inst✝ : HasWeakSheafify J B
P₁ P₂ : Cᵒᵖ ⥤ A
f : P₁ ⟶ P₂
hf : J.W f
⊢ J.W (whiskerRight f F)
state_after: no goals
Theorem: closure_of_rat_image_lt
File: Mathlib/Topology/Instances/Real.lean

tactic: simpa using h.le
state_before: α : Type u
β : Type v
γ : Type w
q p : ℚ
h : q < p
⊢ p ∈ Rat.cast ⁻¹' Ici ↑q
state_after: no goals

tactic: rwa [mem_ball, Real.dist_eq, abs_of_pos (sub_pos.2 h₁), sub_lt_iff_lt_add']
state_before: α : Type u
β : Type v
γ : Type w
q : ℚ
x : ℝ
hx : x ∈ {r | ↑q ≤ r}
t : Set ℝ
ht : t ∈ 𝓝 x
ε : ℝ
ε0 : ε > 0
hε : ball x ε ⊆ t
p : ℚ
h₁ : x < ↑p
h₂ : ↑p < x + ε
⊢ ↑p ∈ ball x ε
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.map_add
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: aesop_cat
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : Preadditive C
R : Type u_1
inst✝⁴ : Ring R
inst✝³ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
z z' : Cochain K L n
f : K ⟶ L
Φ : C ⥤ D
inst✝ : Φ.Additive
⊢ (z + z').map Φ = z.map Φ + z'.map Φ
state_after: no goals
Theorem: ADEInequality.lt_four
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: have h4 : (0 : ℚ) < 4 := by norm_num
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: contrapose! H
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: rw [sumInv_pqr]
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: have h4r := H.trans hqr
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: calc
  (2⁻¹ + (q : ℚ)⁻¹ + (r : ℚ)⁻¹) ≤ 2⁻¹ + 4⁻¹ + 4⁻¹ := add_le_add (add_le_add le_rfl hq) hr
  _ = 1 := by norm_num
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: norm_num
state_before: q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
⊢ 0 < 4
state_after: no goals

tactic: rw [inv_le_inv _ h4]
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
⊢ (↑↑q)⁻¹ ≤ 4⁻¹
state_after: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
⊢ 4 ≤ ↑↑q

q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
⊢ 0 < ↑↑q

tactic: assumption_mod_cast
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
⊢ 4 ≤ ↑↑q
state_after: no goals

tactic: norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
⊢ 0 < ↑↑q
state_after: no goals

tactic: rw [inv_le_inv _ h4]
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ (↑↑r)⁻¹ ≤ 4⁻¹
state_after: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ 4 ≤ ↑↑r

q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ 0 < ↑↑r

tactic: assumption_mod_cast
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ 4 ≤ ↑↑r
state_after: no goals

tactic: norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ 0 < ↑↑r
state_after: no goals

tactic: norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : 4 ≤ q
h4r : 4 ≤ r
hq : (↑↑q)⁻¹ ≤ 4⁻¹
hr : (↑↑r)⁻¹ ≤ 4⁻¹
⊢ 2⁻¹ + 4⁻¹ + 4⁻¹ = 1
state_after: no goals
Theorem: MeasureTheory.ProbabilityMeasure.prod_swap
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

tactic: apply Subtype.ext
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ (μ.prod ν).map ⋯ = ν.prod μ
state_after: case a
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ ↑((μ.prod ν).map ⋯) = ↑(ν.prod μ)

tactic: simp [Measure.prod_swap]
state_before: case a
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ ↑((μ.prod ν).map ⋯) = ↑(ν.prod μ)
state_after: no goals
Theorem: MvPolynomial.degrees_sub
File: Mathlib/Algebra/MvPolynomial/CommRing.lean

tactic: simpa only [sub_eq_add_neg] using le_trans (degrees_add p (-q)) (by rw [degrees_neg])
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ (p - q).degrees ≤ p.degrees ⊔ q.degrees
state_after: no goals

tactic: rw [degrees_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ p.degrees ⊔ (-q).degrees ≤ p.degrees ⊔ q.degrees
state_after: no goals
Theorem: PMF.toPMF_eq_iff_toMeasure_eq
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: rw [← toMeasure_inj, Measure.toPMF_toMeasure]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : Countable α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSingletonClass α
p : PMF α
μ✝ : Measure α
inst✝¹ : IsProbabilityMeasure μ✝
μ : Measure α
inst✝ : IsProbabilityMeasure μ
⊢ μ.toPMF = p ↔ μ = p.toMeasure
state_after: no goals
Theorem: tendsto_rpow_div
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: convert tendsto_rpow_div_mul_add (1 : ℝ) _ (0 : ℝ) zero_ne_one
state_before: ⊢ Tendsto (fun x => x ^ (1 / x)) atTop (𝓝 1)
state_after: case h.e'_3.h.h.e'_6.h.e'_6
x✝ : ℝ
⊢ x✝ = 1 * x✝ + 0

tactic: ring
state_before: case h.e'_3.h.h.e'_6.h.e'_6
x✝ : ℝ
⊢ x✝ = 1 * x✝ + 0
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.d_comp_ofHoms_v
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: rw [add_zero] at hpq
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p q : ℤ
hpq : p + 0 = q
⊢ F.d p' p ≫ (ofHoms ψ).v p q hpq = F.d p' q ≫ ψ q
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p q : ℤ
hpq✝ : p + 0 = q
hpq : p = q
⊢ F.d p' p ≫ (ofHoms ψ).v p q hpq✝ = F.d p' q ≫ ψ q

tactic: subst hpq
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p q : ℤ
hpq✝ : p + 0 = q
hpq : p = q
⊢ F.d p' p ≫ (ofHoms ψ).v p q hpq✝ = F.d p' q ≫ ψ q
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p : ℤ
hpq : p + 0 = p
⊢ F.d p' p ≫ (ofHoms ψ).v p p hpq = F.d p' p ≫ ψ p

tactic: rw [ofHoms_v]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p : ℤ
hpq : p + 0 = p
⊢ F.d p' p ≫ (ofHoms ψ).v p p hpq = F.d p' p ≫ ψ p
state_after: no goals
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_succ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: subst H
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = i.succ
⊢ X.σ i ≫ X.δ j = 𝟙 (X _[n])
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.σ i ≫ X.δ i.succ = 𝟙 (X _[n])

tactic: rw [δ_comp_σ_succ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.σ i ≫ X.δ i.succ = 𝟙 (X _[n])
state_after: no goals
Theorem: CategoryTheory.Bicategory.rightUnitor_comp
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (ρ_ (f ≫ g)).hom = (α_ f g (𝟙 c)).hom ≫ f ◁ (ρ_ g).hom
state_after: no goals
Theorem: Real.volume_Icc
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp [volume_val]
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ℝ
⊢ volume (Icc a b) = ofReal (b - a)
state_after: no goals
Theorem: Polynomial.rootMultiplicity_le_one_of_separable
File: Mathlib/FieldTheory/Separable.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : p.Separable
x : R
⊢ rootMultiplicity x p ≤ 1
state_after: case pos
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : p.Separable
x : R
hp : p = 0
⊢ rootMultiplicity x p ≤ 1

case neg
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : p.Separable
x : R
hp : ¬p = 0
⊢ rootMultiplicity x p ≤ 1

tactic: rw [rootMultiplicity_eq_multiplicity, dif_neg hp, ← PartENat.coe_le_coe, PartENat.natCast_get,
  Nat.cast_one]
state_before: case neg
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : p.Separable
x : R
hp : ¬p = 0
⊢ rootMultiplicity x p ≤ 1
state_after: case neg
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : p.Separable
x : R
hp : ¬p = 0
⊢ multiplicity (X - C x) p ≤ 1

tactic: exact multiplicity_le_one_of_separable (not_isUnit_X_sub_C _) hsep
state_before: case neg
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : p.Separable
x : R
hp : ¬p = 0
⊢ multiplicity (X - C x) p ≤ 1
state_after: no goals

tactic: simp [hp]
state_before: case pos
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : p.Separable
x : R
hp : p = 0
⊢ rootMultiplicity x p ≤ 1
state_after: no goals
Theorem: ZetaAsymptotics.tendsto_riemannZeta_sub_one_div_Gammaℝ
File: Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean

tactic: have := tendsto_riemannZeta_sub_one_div.add tendsto_Gamma_term_aux
state_before: ⊢ Tendsto (fun s => riemannZeta s - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 ((↑γ - Complex.log (4 * ↑π)) / 2))
state_after: this :
  Tendsto (fun x => riemannZeta x - 1 / (x - 1) + (1 / (x - 1) - 1 / x.Gammaℝ / (x - 1))) (𝓝[≠] 1)
    (𝓝 (↑γ + -(↑γ + Complex.log (4 * ↑π)) / 2))
⊢ Tendsto (fun s => riemannZeta s - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 ((↑γ - Complex.log (4 * ↑π)) / 2))

tactic: simp_rw [sub_add_sub_cancel] at this
state_before: this :
  Tendsto (fun x => riemannZeta x - 1 / (x - 1) + (1 / (x - 1) - 1 / x.Gammaℝ / (x - 1))) (𝓝[≠] 1)
    (𝓝 (↑γ + -(↑γ + Complex.log (4 * ↑π)) / 2))
⊢ Tendsto (fun s => riemannZeta s - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 ((↑γ - Complex.log (4 * ↑π)) / 2))
state_after: this : Tendsto (fun x => riemannZeta x - 1 / x.Gammaℝ / (x - 1)) (𝓝[≠] 1) (𝓝 (↑γ + -(↑γ + Complex.log (4 * ↑π)) / 2))
⊢ Tendsto (fun s => riemannZeta s - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 ((↑γ - Complex.log (4 * ↑π)) / 2))

tactic: convert this using 2
state_before: this : Tendsto (fun x => riemannZeta x - 1 / x.Gammaℝ / (x - 1)) (𝓝[≠] 1) (𝓝 (↑γ + -(↑γ + Complex.log (4 * ↑π)) / 2))
⊢ Tendsto (fun s => riemannZeta s - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 ((↑γ - Complex.log (4 * ↑π)) / 2))
state_after: case h.e'_5.h.e'_3
this : Tendsto (fun x => riemannZeta x - 1 / x.Gammaℝ / (x - 1)) (𝓝[≠] 1) (𝓝 (↑γ + -(↑γ + Complex.log (4 * ↑π)) / 2))
⊢ (↑γ - Complex.log (4 * ↑π)) / 2 = ↑γ + -(↑γ + Complex.log (4 * ↑π)) / 2

tactic: ring_nf
state_before: case h.e'_5.h.e'_3
this : Tendsto (fun x => riemannZeta x - 1 / x.Gammaℝ / (x - 1)) (𝓝[≠] 1) (𝓝 (↑γ + -(↑γ + Complex.log (4 * ↑π)) / 2))
⊢ (↑γ - Complex.log (4 * ↑π)) / 2 = ↑γ + -(↑γ + Complex.log (4 * ↑π)) / 2
state_after: no goals