1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.SimpleFunc.norm_integral_le_integral_norm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: refine (norm_setToSimpleFunc_le_integral_norm _ (fun s _ _ => ?_) hf).trans (one_mul _).le
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type u_5
F' : Type u_6
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ ‖integral μ f‖ ≤ integral μ (map norm f)
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type u_5
F' : Type u_6
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
f : α →ₛ E
hf : Integrable (↑f) μ
s : Set α
x✝¹ : MeasurableSet s
x✝ : μ s < ⊤
⊢ ‖weightedSMul μ s‖ ≤ 1 * (μ s).toReal

tactic: exact (norm_weightedSMul_le s).trans (one_mul _).symm.le
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type u_5
F' : Type u_6
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
f : α →ₛ E
hf : Integrable (↑f) μ
s : Set α
x✝¹ : MeasurableSet s
x✝ : μ s < ⊤
⊢ ‖weightedSMul μ s‖ ≤ 1 * (μ s).toReal
state_after: no goals
Theorem: CategoryTheory.PreOneHypercover.sieve₁'_eq_sieve₁
File: Mathlib/CategoryTheory/Sites/OneHypercover.lean

tactic: rw [← Sieve.pullback_id (S := E.sieve₁' i₁ i₂),
  sieve₁_eq_pullback_sieve₁' _ _ _ pullback.condition]
state_before: C : Type u
inst✝² : Category.{v, u} C
A : Type u_1
inst✝¹ : Category.{?u.11568, u_1} A
S : C
E : PreOneHypercover S
i₁ i₂ : E.I₀
inst✝ : HasPullback (E.f i₁) (E.f i₂)
⊢ E.sieve₁' i₁ i₂ = E.sieve₁ pullback.fst pullback.snd
state_after: C : Type u
inst✝² : Category.{v, u} C
A : Type u_1
inst✝¹ : Category.{?u.11568, u_1} A
S : C
E : PreOneHypercover S
i₁ i₂ : E.I₀
inst✝ : HasPullback (E.f i₁) (E.f i₂)
⊢ Sieve.pullback (𝟙 (pullback (E.f i₁) (E.f i₂))) (E.sieve₁' i₁ i₂) =
    Sieve.pullback (pullback.lift pullback.fst pullback.snd ⋯) (E.sieve₁' i₁ i₂)

tactic: congr
state_before: C : Type u
inst✝² : Category.{v, u} C
A : Type u_1
inst✝¹ : Category.{?u.11568, u_1} A
S : C
E : PreOneHypercover S
i₁ i₂ : E.I₀
inst✝ : HasPullback (E.f i₁) (E.f i₂)
⊢ Sieve.pullback (𝟙 (pullback (E.f i₁) (E.f i₂))) (E.sieve₁' i₁ i₂) =
    Sieve.pullback (pullback.lift pullback.fst pullback.snd ⋯) (E.sieve₁' i₁ i₂)
state_after: case e_h
C : Type u
inst✝² : Category.{v, u} C
A : Type u_1
inst✝¹ : Category.{?u.11568, u_1} A
S : C
E : PreOneHypercover S
i₁ i₂ : E.I₀
inst✝ : HasPullback (E.f i₁) (E.f i₂)
⊢ 𝟙 (pullback (E.f i₁) (E.f i₂)) = pullback.lift pullback.fst pullback.snd ⋯

tactic: aesop_cat
state_before: case e_h
C : Type u
inst✝² : Category.{v, u} C
A : Type u_1
inst✝¹ : Category.{?u.11568, u_1} A
S : C
E : PreOneHypercover S
i₁ i₂ : E.I₀
inst✝ : HasPullback (E.f i₁) (E.f i₂)
⊢ 𝟙 (pullback (E.f i₁) (E.f i₂)) = pullback.lift pullback.fst pullback.snd ⋯
state_after: no goals
Theorem: Finset.orderEmbOfFin_unique
File: Mathlib/Data/Finset/Sort.lean

tactic: apply Fin.strictMono_unique hmono (s.orderEmbOfFin h).strictMono
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
⊢ f = ⇑(s.orderEmbOfFin h)
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
⊢ Set.range f = Set.range ⇑(s.orderEmbOfFin h)

tactic: rw [range_orderEmbOfFin, ← Set.image_univ, ← coe_univ, ← coe_image, coe_inj]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
⊢ Set.range f = Set.range ⇑(s.orderEmbOfFin h)
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
⊢ image f univ = s

tactic: refine eq_of_subset_of_card_le (fun x hx => ?_) ?_
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
⊢ image f univ = s
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
x : α
hx : x ∈ image f univ
⊢ x ∈ s

case refine_2
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
⊢ s.card ≤ (image f univ).card

tactic: rcases mem_image.1 hx with ⟨x, _, rfl⟩
state_before: case refine_1
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
x : α
hx : x ∈ image f univ
⊢ x ∈ s
state_after: case refine_1.intro.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
x : Fin k
left✝ : x ∈ univ
hx : f x ∈ image f univ
⊢ f x ∈ s

tactic: exact hfs x
state_before: case refine_1.intro.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
x : Fin k
left✝ : x ∈ univ
hx : f x ∈ image f univ
⊢ f x ∈ s
state_after: no goals

tactic: rw [h, card_image_of_injective _ hmono.injective, card_univ, Fintype.card_fin]
state_before: case refine_2
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
f : Fin k → α
hfs : ∀ (x : Fin k), f x ∈ s
hmono : StrictMono f
⊢ s.card ≤ (image f univ).card
state_after: no goals
Theorem: List.le_max_of_le
File: Mathlib/Data/List/MinMax.lean

tactic: induction' l with y l IH
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ l : List α
a x : α
hx : x ∈ l
h : a ≤ x
⊢ a ≤ foldr max ⊥ l
state_after: case nil
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
a x : α
h : a ≤ x
hx : x ∈ []
⊢ a ≤ foldr max ⊥ []

case cons
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
hx : x ∈ y :: l
⊢ a ≤ foldr max ⊥ (y :: l)

tactic: exact absurd hx (not_mem_nil _)
state_before: case nil
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
a x : α
h : a ≤ x
hx : x ∈ []
⊢ a ≤ foldr max ⊥ []
state_after: no goals

tactic: obtain hl | hl := hx
state_before: case cons
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
hx : x ∈ y :: l
⊢ a ≤ foldr max ⊥ (y :: l)
state_after: case cons.head
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
⊢ a ≤ foldr max ⊥ (x :: l)

case cons.tail
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
a✝ : Mem x l
⊢ a ≤ foldr max ⊥ (y :: l)

tactic: simp only [foldr, foldr_cons]
state_before: case cons.head
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
⊢ a ≤ foldr max ⊥ (x :: l)
state_after: case cons.head
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
⊢ a ≤ max x (foldr max ⊥ l)

tactic: exact le_max_of_le_left h
state_before: case cons.head
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
⊢ a ≤ max x (foldr max ⊥ l)
state_after: no goals

tactic: exact le_max_of_le_right (IH (by assumption))
state_before: case cons.tail
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
a✝ : Mem x l
⊢ a ≤ foldr max ⊥ (y :: l)
state_after: no goals

tactic: assumption
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
a✝ : Mem x l
⊢ x ∈ l
state_after: no goals
Theorem: Set.Subsingleton.induction_on
File: Mathlib/Data/Set/Subsingleton.lean

tactic: rcases hs.eq_empty_or_singleton with (rfl | ⟨x, rfl⟩)
state_before: α : Type u
a : α
s t : Set α
p : Set α → Prop
hs : s.Subsingleton
he : p ∅
h₁ : ∀ (x : α), p {x}
⊢ p s
state_after: case inl
α : Type u
a : α
t : Set α
p : Set α → Prop
he : p ∅
h₁ : ∀ (x : α), p {x}
hs : ∅.Subsingleton
⊢ p ∅

case inr.intro
α : Type u
a : α
t : Set α
p : Set α → Prop
he : p ∅
h₁ : ∀ (x : α), p {x}
x : α
hs : {x}.Subsingleton
⊢ p {x}

tactic: exacts [he, h₁ _]
state_before: case inl
α : Type u
a : α
t : Set α
p : Set α → Prop
he : p ∅
h₁ : ∀ (x : α), p {x}
hs : ∅.Subsingleton
⊢ p ∅

case inr.intro
α : Type u
a : α
t : Set α
p : Set α → Prop
he : p ∅
h₁ : ∀ (x : α), p {x}
x : α
hs : {x}.Subsingleton
⊢ p {x}
state_after: no goals
Theorem: gauge_def'
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: congrm sInf {r | ?_}
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
⊢ gauge s x = sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • x ∈ s}
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a r : ℝ
⊢ 0 < r ∧ x ∈ r • s ↔ r ∈ Ioi 0 ∧ r⁻¹ • x ∈ s

tactic: exact and_congr_right fun hr => mem_smul_set_iff_inv_smul_mem₀ hr.ne' _ _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a r : ℝ
⊢ 0 < r ∧ x ∈ r • s ↔ r ∈ Ioi 0 ∧ r⁻¹ • x ∈ s
state_after: no goals
Theorem: LocalRing.isUnit_or_isUnit_of_isUnit_add
File: Mathlib/RingTheory/Ideal/LocalRing.lean

tactic: rcases h with ⟨u, hu⟩
state_before: R : Type u
S : Type v
T : Type w
K : Type u'
inst✝¹ : CommSemiring R
inst✝ : LocalRing R
a b : R
h : IsUnit (a + b)
⊢ IsUnit a ∨ IsUnit b
state_after: case intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝¹ : CommSemiring R
inst✝ : LocalRing R
a b : R
u : Rˣ
hu : ↑u = a + b
⊢ IsUnit a ∨ IsUnit b

tactic: rw [← Units.inv_mul_eq_one, mul_add] at hu
state_before: case intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝¹ : CommSemiring R
inst✝ : LocalRing R
a b : R
u : Rˣ
hu : ↑u = a + b
⊢ IsUnit a ∨ IsUnit b
state_after: case intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝¹ : CommSemiring R
inst✝ : LocalRing R
a b : R
u : Rˣ
hu : ↑u⁻¹ * a + ↑u⁻¹ * b = 1
⊢ IsUnit a ∨ IsUnit b

tactic: apply Or.imp _ _ (isUnit_or_isUnit_of_add_one hu) <;> exact isUnit_of_mul_isUnit_right
state_before: case intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝¹ : CommSemiring R
inst✝ : LocalRing R
a b : R
u : Rˣ
hu : ↑u⁻¹ * a + ↑u⁻¹ * b = 1
⊢ IsUnit a ∨ IsUnit b
state_after: no goals
Theorem: Odd.mul
File: Mathlib/Algebra/Ring/Parity.lean

tactic: rintro ⟨a, rfl⟩ ⟨b, rfl⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
⊢ Odd a → Odd b → Odd (a * b)
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : ℕ
a b : α
⊢ Odd ((2 * a + 1) * (2 * b + 1))

tactic: refine ⟨2 * a * b + b + a, ?_⟩
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : ℕ
a b : α
⊢ Odd ((2 * a + 1) * (2 * b + 1))
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : ℕ
a b : α
⊢ (2 * a + 1) * (2 * b + 1) = 2 * (2 * a * b + b + a) + 1

tactic: rw [mul_add, add_mul, mul_one, ← add_assoc, one_mul, mul_assoc, ← mul_add, ← mul_add, ← mul_assoc,
  ← Nat.cast_two, ← Nat.cast_comm]
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : ℕ
a b : α
⊢ (2 * a + 1) * (2 * b + 1) = 2 * (2 * a * b + b + a) + 1
state_after: no goals
Theorem: MeasureTheory.ae_withDensity_iff'
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

tactic: rw [ae_iff, ae_iff, withDensity_apply_eq_zero' hf, iff_iff_eq]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ (∀ᵐ (x : α) ∂μ.withDensity f, p x) ↔ ∀ᵐ (x : α) ∂μ, f x ≠ 0 → p x
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ (μ ({x | f x ≠ 0} ∩ {a | ¬p a}) = 0) = (μ {a | ¬(f a ≠ 0 → p a)} = 0)

tactic: congr
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ (μ ({x | f x ≠ 0} ∩ {a | ¬p a}) = 0) = (μ {a | ¬(f a ≠ 0 → p a)} = 0)
state_after: case e_a.h.e_6.h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ {x | f x ≠ 0} ∩ {a | ¬p a} = {a | ¬(f a ≠ 0 → p a)}

tactic: ext x
state_before: case e_a.h.e_6.h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ {x | f x ≠ 0} ∩ {a | ¬p a} = {a | ¬(f a ≠ 0 → p a)}
state_after: case e_a.h.e_6.h.h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : AEMeasurable f μ
x : α
⊢ x ∈ {x | f x ≠ 0} ∩ {a | ¬p a} ↔ x ∈ {a | ¬(f a ≠ 0 → p a)}

tactic: simp only [exists_prop, mem_inter_iff, iff_self_iff, mem_setOf_eq, not_forall]
state_before: case e_a.h.e_6.h.h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : AEMeasurable f μ
x : α
⊢ x ∈ {x | f x ≠ 0} ∩ {a | ¬p a} ↔ x ∈ {a | ¬(f a ≠ 0 → p a)}
state_after: no goals
Theorem: Int.modEq_and_modEq_iff_modEq_mul
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [modEq_iff_dvd, modEq_iff_dvd] at h
state_before: m✝ n✝ a✝ b✝ c d a b m n : ℤ
hmn : m.natAbs.Coprime n.natAbs
h : a ≡ b [ZMOD m] ∧ a ≡ b [ZMOD n]
⊢ a ≡ b [ZMOD m * n]
state_after: m✝ n✝ a✝ b✝ c d a b m n : ℤ
hmn : m.natAbs.Coprime n.natAbs
h : m ∣ b - a ∧ n ∣ b - a
⊢ a ≡ b [ZMOD m * n]

tactic: rw [modEq_iff_dvd, ← natAbs_dvd, ← dvd_natAbs, natCast_dvd_natCast, natAbs_mul]
state_before: m✝ n✝ a✝ b✝ c d a b m n : ℤ
hmn : m.natAbs.Coprime n.natAbs
h : m ∣ b - a ∧ n ∣ b - a
⊢ a ≡ b [ZMOD m * n]
state_after: m✝ n✝ a✝ b✝ c d a b m n : ℤ
hmn : m.natAbs.Coprime n.natAbs
h : m ∣ b - a ∧ n ∣ b - a
⊢ m.natAbs * n.natAbs ∣ (b - a).natAbs

tactic: refine hmn.mul_dvd_of_dvd_of_dvd ?_ ?_ <;>
  rw [← natCast_dvd_natCast, natAbs_dvd, dvd_natAbs] <;>
  tauto
state_before: m✝ n✝ a✝ b✝ c d a b m n : ℤ
hmn : m.natAbs.Coprime n.natAbs
h : m ∣ b - a ∧ n ∣ b - a
⊢ m.natAbs * n.natAbs ∣ (b - a).natAbs
state_after: no goals
Theorem: HomologicalComplex.Hom.prev_eq
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: obtain rfl := c.prev_eq' w
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
i j : ι
w : c.Rel i j
⊢ f.prev j = (C₁.xPrevIso w).hom ≫ f.f i ≫ (C₂.xPrevIso w).inv
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
j : ι
w : c.Rel (c.prev j) j
⊢ f.prev j = (C₁.xPrevIso w).hom ≫ f.f (c.prev j) ≫ (C₂.xPrevIso w).inv

tactic: simp only [xPrevIso, eqToIso_refl, Iso.refl_hom, Iso.refl_inv, comp_id, id_comp]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
j : ι
w : c.Rel (c.prev j) j
⊢ f.prev j = (C₁.xPrevIso w).hom ≫ f.f (c.prev j) ≫ (C₂.xPrevIso w).inv
state_after: no goals
Theorem: List.sections_eq_nil_of_isEmpty
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

tactic: simp only [any, foldr, Bool.or_eq_true] at h
state_before: α : Type u_1
l : List α
L : List (List α)
h : (l :: L).any isEmpty = true
⊢ (l :: L).sections = []
state_after: α : Type u_1
l : List α
L : List (List α)
h : l.isEmpty = true ∨ L.any isEmpty = true
⊢ (l :: L).sections = []

tactic: match l, h with
| [], .inl rfl => simp; induction sections L <;> simp [*]
| l, .inr h => simp [sections, sections_eq_nil_of_isEmpty h]
state_before: α : Type u_1
l : List α
L : List (List α)
h : l.isEmpty = true ∨ L.any isEmpty = true
⊢ (l :: L).sections = []
state_after: no goals

tactic: simp
state_before: α : Type u_1
l : List α
L : List (List α)
h : l.isEmpty = true ∨ L.any isEmpty = true
⊢ ([] :: L).sections = []
state_after: α : Type u_1
l : List α
L : List (List α)
h : l.isEmpty = true ∨ L.any isEmpty = true
⊢ (L.sections.bind fun s => []) = []

tactic: induction sections L <;> simp [*]
state_before: α : Type u_1
l : List α
L : List (List α)
h : l.isEmpty = true ∨ L.any isEmpty = true
⊢ (L.sections.bind fun s => []) = []
state_after: no goals

tactic: simp [sections, sections_eq_nil_of_isEmpty h]
state_before: α : Type u_1
l✝ : List α
L : List (List α)
h✝ : l✝.isEmpty = true ∨ L.any isEmpty = true
l : List α
h : L.any isEmpty = true
⊢ (l :: L).sections = []
state_after: no goals
Theorem: Relation.TransGen.tail'_iff
File: Mathlib/Logic/Relation.lean

tactic: refine ⟨fun h ↦ ?_, fun ⟨b, hab, hbc⟩ ↦ tail' hab hbc⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ TransGen r a c ↔ ∃ b, ReflTransGen r a b ∧ r b c
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : TransGen r a c
⊢ ∃ b, ReflTransGen r a b ∧ r b c

tactic: cases' h with _ hac b _ hab hbc
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : TransGen r a c
⊢ ∃ b, ReflTransGen r a b ∧ r b c
state_after: case single
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hac : r a c
⊢ ∃ b, ReflTransGen r a b ∧ r b c

case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b✝ c d b : α
hab : TransGen r a b
hbc : r b c
⊢ ∃ b, ReflTransGen r a b ∧ r b c

tactic: exact ⟨_, by rfl, hac⟩
state_before: case single
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hac : r a c
⊢ ∃ b, ReflTransGen r a b ∧ r b c
state_after: no goals

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hac : r a c
⊢ ReflTransGen r a a
state_after: no goals

tactic: exact ⟨_, hab.to_reflTransGen, hbc⟩
state_before: case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b✝ c d b : α
hab : TransGen r a b
hbc : r b c
⊢ ∃ b, ReflTransGen r a b ∧ r b c
state_after: no goals
Theorem: Filter.eventually_atTop_prod_self'
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [eventually_atTop_prod_self, forall_cond_comm]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
p : α × α → Prop
⊢ (∀ᶠ (x : α × α) in atTop, p x) ↔ ∃ a, ∀ k ≥ a, ∀ l ≥ a, p (k, l)
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isintCast
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rintro ⟨⟨⟩⟩
state_before: R : Type u_1
inst✝ : Ring R
n m : ℤ
⊢ IsInt n m → IsInt (↑n) m
state_after: case mk.refl
R : Type u_1
inst✝ : Ring R
m : ℤ
⊢ IsInt (↑↑m) m

tactic: exact ⟨rfl⟩
state_before: case mk.refl
R : Type u_1
inst✝ : Ring R
m : ℤ
⊢ IsInt (↑↑m) m
state_after: no goals
Theorem: UniformFun.comap_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: letI : UniformSpace γ := .comap f ‹_›
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
⊢ uniformSpace α γ = UniformSpace.comap (fun x => f ∘ x) (uniformSpace α β)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
⊢ uniformSpace α γ = UniformSpace.comap (fun x => f ∘ x) (uniformSpace α β)

tactic: exact (UniformFun.postcomp_uniformInducing (f := f) ⟨rfl⟩).comap_uniformSpace.symm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
⊢ uniformSpace α γ = UniformSpace.comap (fun x => f ∘ x) (uniformSpace α β)
state_after: no goals
Theorem: Nat.minFac_le_of_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: by_cases n1 : n = 1 <;> [exact fun m2 _ => n1.symm ▸ le_trans (by simp) m2;
  apply (minFac_has_prop n1).2.2]
state_before: n✝ n : ℕ
⊢ ∀ {m : ℕ}, 2 ≤ m → m ∣ n → n.minFac ≤ m
state_after: no goals

tactic: simp
state_before: n✝ n m✝ : ℕ
n1 : n = 1
m2 : 2 ≤ m✝
x✝ : m✝ ∣ n
⊢ minFac 1 ≤ 2
state_after: no goals
Theorem: MonoidAlgebra.of_mem_span_of_iff
File: Mathlib/RingTheory/FiniteType.lean

tactic: refine ⟨fun h => ?_, fun h => Submodule.subset_span <| Set.mem_image_of_mem (of R M) h⟩
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
⊢ (of R M) m ∈ span R (⇑(of R M) '' S) ↔ m ∈ S
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : (of R M) m ∈ span R (⇑(of R M) '' S)
⊢ m ∈ S

tactic: erw [of, MonoidHom.coe_mk, ← Finsupp.supported_eq_span_single, Finsupp.mem_supported,
  Finsupp.support_single_ne_zero _ (one_ne_zero' R)] at h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : (of R M) m ∈ span R (⇑(of R M) '' S)
⊢ m ∈ S
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : ↑{m} ⊆ S
⊢ m ∈ S

tactic: simpa using h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : ↑{m} ⊆ S
⊢ m ∈ S
state_after: no goals
Theorem: Real.rpow_def_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [rpow_def, Complex.cpow_def]
state_before: x✝ y✝ z x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ x ^ y = if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y)
state_after: x✝ y✝ z x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ (if ↑x = 0 then if ↑y = 0 then 1 else 0 else Complex.exp (Complex.log ↑x * ↑y)).re =
    if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y)

tactic: split_ifs <;>
simp_all [(Complex.ofReal_log hx).symm, -Complex.ofReal_mul, -RCLike.ofReal_mul,
(Complex.ofReal_mul _ _).symm, Complex.exp_ofReal_re, Complex.ofReal_eq_zero]
state_before: x✝ y✝ z x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ (if ↑x = 0 then if ↑y = 0 then 1 else 0 else Complex.exp (Complex.log ↑x * ↑y)).re =
    if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y)
state_after: no goals