1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Mathlib.Meta.NormNum.jacobiSymNat.even_odd₇
File: Mathlib/Tactic/NormNum/LegendreSymbol.lean

tactic: simp only [jacobiSymNat, ← hr, ← hc, Int.ofNat_ediv, Nat.cast_ofNat]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 7
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSymNat a b = r
state_after: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 7
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSym (↑a) b = jacobiSym (↑a / 2) b

tactic: rw [← jacobiSym.even_odd (mod_cast ha), if_neg (by simp [hb])]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 7
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSym (↑a) b = jacobiSym (↑a / 2) b
state_after: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 7
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ b % 2 = 1

tactic: rw [← Nat.mod_mod_of_dvd, hb]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 7
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ b % 2 = 1
state_after: case h
a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 7
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ 2 ∣ 8

tactic: norm_num
state_before: case h
a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 7
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ 2 ∣ 8
state_after: no goals

tactic: simp [hb]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 7
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ ¬(b % 8 = 3 ∨ b % 8 = 5)
state_after: no goals
Theorem: AddCommGrp.Colimits.quot_add
File: Mathlib/Algebra/Category/Grp/Colimits.lean

tactic: exact Quot.mk Setoid.r (add x y)
state_before: J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
x : ?m.15514
y : ?m.15517
⊢ ColimitType F
state_after: no goals

tactic: exact Quot.mk Setoid.r x
state_before: J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
x y : Prequotient F
⊢ ColimitType F
state_after: no goals

tactic: exact Quot.mk Setoid.r y
state_before: J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
x y : Prequotient F
⊢ ColimitType F
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.rightShift_v
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

tactic: rw [← hp', ← hpq, ← hn', add_assoc]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
p' : ℤ
hp' : p + n = p'
⊢ p' = q + a
state_after: no goals

tactic: subst hp'
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
p' : ℤ
hp' : p + n = p'
⊢ (γ.rightShift a n' hn').v p q hpq = γ.v p p' hp' ≫ (L.shiftFunctorObjXIso a q p' ⋯).inv
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
⊢ (γ.rightShift a n' hn').v p q hpq = γ.v p (p + n) ⋯ ≫ (L.shiftFunctorObjXIso a q (p + n) ⋯).inv

tactic: dsimp only [rightShift]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
⊢ (γ.rightShift a n' hn').v p q hpq = γ.v p (p + n) ⋯ ≫ (L.shiftFunctorObjXIso a q (p + n) ⋯).inv
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
⊢ (mk fun p q hpq => γ.v p (p + n) ⋯ ≫ (L.shiftFunctorObjXIso a q (p + n) ⋯).inv).v p q hpq =
    γ.v p (p + n) ⋯ ≫ (L.shiftFunctorObjXIso a q (p + n) ⋯).inv

tactic: simp only [mk_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
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
⊢ (mk fun p q hpq => γ.v p (p + n) ⋯ ≫ (L.shiftFunctorObjXIso a q (p + n) ⋯).inv).v p q hpq =
    γ.v p (p + n) ⋯ ≫ (L.shiftFunctorObjXIso a q (p + n) ⋯).inv
state_after: no goals
Theorem: TopCat.Presheaf.Pushforward.comp_hom_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: simp [comp]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ℱ : Presheaf C X
Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
U : (Opens ↑Z)ᵒᵖ
⊢ (comp ℱ f g).hom.app U = 𝟙 (((f ≫ g) _* ℱ).obj U)
state_after: no goals
Theorem: LieAlgebra.IsKilling.isCrystallographic_rootSystem
File: Mathlib/Algebra/Lie/Weights/RootSystem.lean

tactic: rintro α _ ⟨β, rfl⟩
state_before: K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
⊢ (rootSystem H).IsCrystallographic
state_after: case intro
K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α✝ β✝ : Weight K (↥H) L
hα : α✝.IsNonZero
α β : { α // α.IsNonZero }
⊢ ((rootSystem H).toLin ((rootSystem H).root α)) ((rootSystem H).coroot β) ∈ ↑(AddSubgroup.zmultiples 1)

tactic: exact ⟨chainBotCoeff β.1 α.1 - chainTopCoeff β.1 α.1, by simp [apply_coroot_eq_cast β.1 α.1]⟩
state_before: case intro
K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α✝ β✝ : Weight K (↥H) L
hα : α✝.IsNonZero
α β : { α // α.IsNonZero }
⊢ ((rootSystem H).toLin ((rootSystem H).root α)) ((rootSystem H).coroot β) ∈ ↑(AddSubgroup.zmultiples 1)
state_after: no goals

tactic: simp [apply_coroot_eq_cast β.1 α.1]
state_before: K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α✝ β✝ : Weight K (↥H) L
hα : α✝.IsNonZero
α β : { α // α.IsNonZero }
⊢ (fun x => x • 1) (↑(chainBotCoeff ⇑↑β ↑α) - ↑(chainTopCoeff ⇑↑β ↑α)) =
    ((rootSystem H).toLin ((rootSystem H).root α)) ((rootSystem H).coroot β)
state_after: no goals
Theorem: Real.arctan_eq_of_tan_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [tan_arctan, h]
state_before: x y : ℝ
h : tan x = y
hx : x ∈ Ioo (-(π / 2)) (π / 2)
⊢ tan (arctan y) = tan x
state_after: no goals
Theorem: Function.isPeriodicPt_prod_map
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp [IsPeriodicPt]
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x✝ : α × β
a : α
b : β
m n : ℕ
x : α × β
⊢ IsPeriodicPt (Prod.map f g) n x ↔ IsPeriodicPt f n x.1 ∧ IsPeriodicPt g n x.2
state_after: no goals
Theorem: MeasureTheory.Measure.restrict_singleton'
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: simp only [measure_singleton, Measure.restrict_eq_zero]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : NoAtoms μ
a : α
⊢ μ.restrict {a} = 0
state_after: no goals
Theorem: Finsupp.prod_toMultiset
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: refine f.induction ?_ ?_
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f : α →₀ ℕ
⊢ (toMultiset f).prod = f.prod fun a n => a ^ n
state_after: case refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f : α →₀ ℕ
⊢ (toMultiset 0).prod = prod 0 fun a n => a ^ n

case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f : α →₀ ℕ
⊢ ∀ (a : α) (b : ℕ) (f : α →₀ ℕ),
    a ∉ f.support →
      b ≠ 0 →
        ((toMultiset f).prod = f.prod fun a n => a ^ n) →
          (toMultiset (single a b + f)).prod = (single a b + f).prod fun a n => a ^ n

tactic: rw [toMultiset_zero, Multiset.prod_zero, Finsupp.prod_zero_index]
state_before: case refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f : α →₀ ℕ
⊢ (toMultiset 0).prod = prod 0 fun a n => a ^ n
state_after: no goals

tactic: intro a n f _ _ ih
state_before: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f : α →₀ ℕ
⊢ ∀ (a : α) (b : ℕ) (f : α →₀ ℕ),
    a ∉ f.support →
      b ≠ 0 →
        ((toMultiset f).prod = f.prod fun a n => a ^ n) →
          (toMultiset (single a b + f)).prod = (single a b + f).prod fun a n => a ^ n
state_after: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f✝ : α →₀ ℕ
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : a ∉ f.support
a✝ : n ≠ 0
ih : (toMultiset f).prod = f.prod fun a n => a ^ n
⊢ (toMultiset (single a n + f)).prod = (single a n + f).prod fun a n => a ^ n

tactic: rw [toMultiset_add, Multiset.prod_add, ih, toMultiset_single, Multiset.prod_nsmul,
  Finsupp.prod_add_index' pow_zero pow_add, Finsupp.prod_single_index, Multiset.prod_singleton]
state_before: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f✝ : α →₀ ℕ
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : a ∉ f.support
a✝ : n ≠ 0
ih : (toMultiset f).prod = f.prod fun a n => a ^ n
⊢ (toMultiset (single a n + f)).prod = (single a n + f).prod fun a n => a ^ n
state_after: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f✝ : α →₀ ℕ
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : a ∉ f.support
a✝ : n ≠ 0
ih : (toMultiset f).prod = f.prod fun a n => a ^ n
⊢ a ^ 0 = 1

tactic: exact pow_zero a
state_before: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : CommMonoid α
f✝ : α →₀ ℕ
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : a ∉ f.support
a✝ : n ≠ 0
ih : (toMultiset f).prod = f.prod fun a n => a ^ n
⊢ a ^ 0 = 1
state_after: no goals
Theorem: MeasureTheory.setLIntegral_max
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral_max hf hg, restrict_restrict, restrict_restrict, inter_comm s, inter_comm s]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
s : Set α
⊢ ∫⁻ (x : α) in s, max (f x) (g x) ∂μ =
    ∫⁻ (x : α) in s ∩ {x | f x ≤ g x}, g x ∂μ + ∫⁻ (x : α) in s ∩ {x | g x < f x}, f x ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
s : Set α
⊢ MeasurableSet {x | g x < f x}

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
s : Set α
⊢ MeasurableSet {x | f x ≤ g x}

tactic: exacts [measurableSet_lt hg hf, measurableSet_le hf hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
s : Set α
⊢ MeasurableSet {x | g x < f x}

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
s : Set α
⊢ MeasurableSet {x | f x ≤ g x}
state_after: no goals
Theorem: RatFunc.map_apply_div_ne_zero
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: have hq' : φ q ≠ 0 := nonZeroDivisors.ne_zero (hφ (mem_nonZeroDivisors_iff_ne_zero.mpr hq))
state_before: K : Type u
inst✝⁵ : CommRing K
inst✝⁴ : IsDomain K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
p q : K[X]
hq : q ≠ 0
⊢ (map φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) =
    (algebraMap R[X] (RatFunc R)) (φ p) / (algebraMap R[X] (RatFunc R)) (φ q)
state_after: K : Type u
inst✝⁵ : CommRing K
inst✝⁴ : IsDomain K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
p q : K[X]
hq : q ≠ 0
hq' : φ q ≠ 0
⊢ (map φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) =
    (algebraMap R[X] (RatFunc R)) (φ p) / (algebraMap R[X] (RatFunc R)) (φ q)

tactic: simp only [← mk_eq_div, mk_eq_localization_mk _ hq, map_apply_ofFractionRing_mk,
  mk_eq_localization_mk _ hq']
state_before: K : Type u
inst✝⁵ : CommRing K
inst✝⁴ : IsDomain K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
p q : K[X]
hq : q ≠ 0
hq' : φ q ≠ 0
⊢ (map φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) =
    (algebraMap R[X] (RatFunc R)) (φ p) / (algebraMap R[X] (RatFunc R)) (φ q)
state_after: no goals
Theorem: HasSum.toNNReal
File: Mathlib/Topology/Instances/NNReal.lean

tactic: lift y to ℝ≥0 using hy.nonneg hf₀
state_before: α : Type u_1
f : α → ℝ
y : ℝ
hf₀ : ∀ (n : α), 0 ≤ f n
hy : HasSum f y
⊢ HasSum (fun x => (f x).toNNReal) y.toNNReal
state_after: case intro
α : Type u_1
f : α → ℝ
hf₀ : ∀ (n : α), 0 ≤ f n
y : ℝ≥0
hy : HasSum f ↑y
⊢ HasSum (fun x => (f x).toNNReal) (↑y).toNNReal

tactic: lift f to α → ℝ≥0 using hf₀
state_before: case intro
α : Type u_1
f : α → ℝ
hf₀ : ∀ (n : α), 0 ≤ f n
y : ℝ≥0
hy : HasSum f ↑y
⊢ HasSum (fun x => (f x).toNNReal) (↑y).toNNReal
state_after: case intro.intro
α : Type u_1
y : ℝ≥0
f : α → ℝ≥0
hy : HasSum (fun i => ↑(f i)) ↑y
⊢ HasSum (fun x => ((fun i => ↑(f i)) x).toNNReal) (↑y).toNNReal

tactic: simpa [hasSum_coe] using hy
state_before: case intro.intro
α : Type u_1
y : ℝ≥0
f : α → ℝ≥0
hy : HasSum (fun i => ↑(f i)) ↑y
⊢ HasSum (fun x => ((fun i => ↑(f i)) x).toNNReal) (↑y).toNNReal
state_after: no goals
Theorem: Ordinal.sub_self
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [add_zero] using add_sub_cancel a 0
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
⊢ a - a = 0
state_after: no goals
Theorem: affineSpan_insert_eq_affineSpan
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [← mem_coe] at h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : P
ps : Set P
h : p ∈ affineSpan k ps
⊢ affineSpan k (insert p ps) = affineSpan k ps
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : P
ps : Set P
h : p ∈ ↑(affineSpan k ps)
⊢ affineSpan k (insert p ps) = affineSpan k ps

tactic: rw [← affineSpan_insert_affineSpan, Set.insert_eq_of_mem h, affineSpan_coe]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : P
ps : Set P
h : p ∈ ↑(affineSpan k ps)
⊢ affineSpan k (insert p ps) = affineSpan k ps
state_after: no goals
Theorem: LinearMap.rank_zero
File: Mathlib/LinearAlgebra/Dimension/LinearMap.lean

tactic: rw [rank, LinearMap.range_zero, rank_bot]
state_before: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁷ : Ring K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V'
inst✝¹ : Module K V'
inst✝ : Nontrivial K
⊢ rank 0 = 0
state_after: no goals
Theorem: CategoryTheory.Subobject.ofLE_refl
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: apply (cancel_mono X.arrow).mp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X : Subobject B
⊢ X.ofLE X ⋯ = 𝟙 (underlying.obj X)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X : Subobject B
⊢ X.ofLE X ⋯ ≫ X.arrow = 𝟙 (underlying.obj X) ≫ X.arrow

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X : Subobject B
⊢ X.ofLE X ⋯ ≫ X.arrow = 𝟙 (underlying.obj X) ≫ X.arrow
state_after: no goals
Theorem: smul_pos_iff_of_pos_left
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: simpa only [smul_zero] using smul_lt_smul_iff_of_pos_left ha (b₁ := 0) (b₂ := b)
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁶ : Zero α
inst✝⁵ : Zero β
inst✝⁴ : SMulZeroClass α β
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : PosSMulStrictMono α β
inst✝ : PosSMulReflectLT α β
ha : 0 < a
⊢ 0 < a • b ↔ 0 < b
state_after: no goals
Theorem: TopologicalSpace.Opens.mem_sSup
File: Mathlib/Topology/Sets/Opens.lean

tactic: simp_rw [sSup_eq_iSup, mem_iSup, exists_prop]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
Us : Set (Opens α)
x : α
⊢ x ∈ sSup Us ↔ ∃ u ∈ Us, x ∈ u
state_after: no goals
Theorem: Associated.of_pow_associated_of_prime
File: Mathlib/Algebra/Associated.lean

tactic: have : p₁ ∣ p₂ ^ k₂ := by
  rw [← h.dvd_iff_dvd_right]
  apply dvd_pow_self _ hk₁.ne'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p₁ p₂ : α
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₁
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
⊢ p₁ ~ᵤ p₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p₁ p₂ : α
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₁
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
this : p₁ ∣ p₂ ^ k₂
⊢ p₁ ~ᵤ p₂

tactic: rw [← hp₁.dvd_prime_iff_associated hp₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p₁ p₂ : α
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₁
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
this : p₁ ∣ p₂ ^ k₂
⊢ p₁ ~ᵤ p₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p₁ p₂ : α
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₁
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
this : p₁ ∣ p₂ ^ k₂
⊢ p₁ ∣ p₂

tactic: exact hp₁.dvd_of_dvd_pow this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p₁ p₂ : α
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₁
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
this : p₁ ∣ p₂ ^ k₂
⊢ p₁ ∣ p₂
state_after: no goals

tactic: rw [← h.dvd_iff_dvd_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p₁ p₂ : α
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₁
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
⊢ p₁ ∣ p₂ ^ k₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p₁ p₂ : α
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₁
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
⊢ p₁ ∣ p₁ ^ k₁

tactic: apply dvd_pow_self _ hk₁.ne'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p₁ p₂ : α
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₁
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
⊢ p₁ ∣ p₁ ^ k₁
state_after: no goals
Theorem: MeasureTheory.Supermartingale.neg
File: Mathlib/Probability/Martingale/Basic.lean

tactic: refine ⟨hf.1.neg, fun i j hij => ?_, fun i => (hf.2.2 i).neg⟩
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
⊢ Submartingale (-f) ℱ μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
⊢ (-f) i ≤ᶠ[ae μ] μ[(-f) j|↑ℱ i]

tactic: refine EventuallyLE.trans ?_ (condexp_neg (f j)).symm.le
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
⊢ (-f) i ≤ᶠ[ae μ] μ[(-f) j|↑ℱ i]
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
⊢ (-f) i ≤ᶠ[ae μ] -μ[f j|↑ℱ i]

tactic: filter_upwards [hf.2.1 i j hij] with _ _
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
⊢ (-f) i ≤ᶠ[ae μ] -μ[f j|↑ℱ i]
state_after: case h
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
a✝¹ : Ω
a✝ : (μ[f j|↑ℱ i]) a✝¹ ≤ f i a✝¹
⊢ (-f) i a✝¹ ≤ (-μ[f j|↑ℱ i]) a✝¹

tactic: simpa
state_before: case h
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
a✝¹ : Ω
a✝ : (μ[f j|↑ℱ i]) a✝¹ ≤ f i a✝¹
⊢ (-f) i a✝¹ ≤ (-μ[f j|↑ℱ i]) a✝¹
state_after: no goals
Theorem: padicValInt.one
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValInt]
state_before: p : ℕ
⊢ padicValInt p 1 = 0
state_after: no goals
Theorem: CategoryTheory.NatTrans.mapHomotopyCategory_comp
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

tactic: aesop_cat
state_before: R : Type u_1
inst✝⁷ : Semiring R
ι : Type u_2
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : Preadditive V
c✝ : ComplexShape ι
W : Type u_3
inst✝⁴ : Category.{u_4, u_3} W
inst✝³ : Preadditive W
c : ComplexShape ι
F G H : V ⥤ W
inst✝² : F.Additive
inst✝¹ : G.Additive
inst✝ : H.Additive
α : F ⟶ G
β : G ⟶ H
⊢ mapHomotopyCategory (α ≫ β) c = mapHomotopyCategory α c ≫ mapHomotopyCategory β c
state_after: no goals
Theorem: multiplicity.is_greatest'
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rwa [← PartENat.coe_lt_coe, PartENat.natCast_get] at hm
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 : α
m : ℕ
h : Finite a b
hm : (multiplicity a b).get h < m
⊢ multiplicity a b < ↑m
state_after: no goals
Theorem: Ideal.map_prodComm_prod
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: refine Trans.trans (ideal_prod_eq _) ?_
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I I' : Ideal R
J J' : Ideal S
⊢ map (↑RingEquiv.prodComm) (I.prod J) = J.prod I
state_after: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I I' : Ideal R
J J' : Ideal S
⊢ (map (RingHom.fst S R) (map (↑RingEquiv.prodComm) (I.prod J))).prod
      (map (RingHom.snd S R) (map (↑RingEquiv.prodComm) (I.prod J))) =
    J.prod I

tactic: simp [map_map]
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I I' : Ideal R
J J' : Ideal S
⊢ (map (RingHom.fst S R) (map (↑RingEquiv.prodComm) (I.prod J))).prod
      (map (RingHom.snd S R) (map (↑RingEquiv.prodComm) (I.prod J))) =
    J.prod I
state_after: no goals