1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.factorizationLCMLeft_pos
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: apply Nat.pos_of_ne_zero
state_before: a b m n p : ℕ
⊢ 0 < a.factorizationLCMLeft b
state_after: case a
a b m n p : ℕ
⊢ a.factorizationLCMLeft b ≠ 0

tactic: rw [factorizationLCMLeft, Finsupp.prod_ne_zero_iff]
state_before: case a
a b m n p : ℕ
⊢ a.factorizationLCMLeft b ≠ 0
state_after: case a
a b m n p : ℕ
⊢ ∀ i ∈ (a.lcm b).factorization.support,
    (if b.factorization i ≤ a.factorization i then i ^ (a.lcm b).factorization i else 1) ≠ 0

tactic: intro p _ H
state_before: case a
a b m n p : ℕ
⊢ ∀ i ∈ (a.lcm b).factorization.support,
    (if b.factorization i ≤ a.factorization i then i ^ (a.lcm b).factorization i else 1) ≠ 0
state_after: case a
a b m n p✝ p : ℕ
a✝ : p ∈ (a.lcm b).factorization.support
H : (if b.factorization p ≤ a.factorization p then p ^ (a.lcm b).factorization p else 1) = 0
⊢ False

tactic: by_cases h : b.factorization p ≤ a.factorization p
state_before: case a
a b m n p✝ p : ℕ
a✝ : p ∈ (a.lcm b).factorization.support
H : (if b.factorization p ≤ a.factorization p then p ^ (a.lcm b).factorization p else 1) = 0
⊢ False
state_after: case pos
a b m n p✝ p : ℕ
a✝ : p ∈ (a.lcm b).factorization.support
H : (if b.factorization p ≤ a.factorization p then p ^ (a.lcm b).factorization p else 1) = 0
h : b.factorization p ≤ a.factorization p
⊢ False

case neg
a b m n p✝ p : ℕ
a✝ : p ∈ (a.lcm b).factorization.support
H : (if b.factorization p ≤ a.factorization p then p ^ (a.lcm b).factorization p else 1) = 0
h : ¬b.factorization p ≤ a.factorization p
⊢ False

tactic: simp only [h, reduceIte, pow_eq_zero_iff', ne_eq] at H
state_before: case pos
a b m n p✝ p : ℕ
a✝ : p ∈ (a.lcm b).factorization.support
H : (if b.factorization p ≤ a.factorization p then p ^ (a.lcm b).factorization p else 1) = 0
h : b.factorization p ≤ a.factorization p
⊢ False
state_after: case pos
a b m n p✝ p : ℕ
a✝ : p ∈ (a.lcm b).factorization.support
h : b.factorization p ≤ a.factorization p
H : p = 0 ∧ ¬(a.lcm b).factorization p = 0
⊢ False

tactic: simpa [H.1] using H.2
state_before: case pos
a b m n p✝ p : ℕ
a✝ : p ∈ (a.lcm b).factorization.support
h : b.factorization p ≤ a.factorization p
H : p = 0 ∧ ¬(a.lcm b).factorization p = 0
⊢ False
state_after: no goals

tactic: simp only [h, reduceIte, one_ne_zero] at H
state_before: case neg
a b m n p✝ p : ℕ
a✝ : p ∈ (a.lcm b).factorization.support
H : (if b.factorization p ≤ a.factorization p then p ^ (a.lcm b).factorization p else 1) = 0
h : ¬b.factorization p ≤ a.factorization p
⊢ False
state_after: no goals
Theorem: Action.leftUnitor_hom_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

tactic: dsimp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ (λ_ X).hom.hom = (λ_ X.V).hom
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ ((𝟙 (𝟙_ V) ⊗ 𝟙 X.V) ≫ (λ_ X.V).hom) ≫ 𝟙 X.V = (λ_ X.V).hom

tactic: simp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ ((𝟙 (𝟙_ V) ⊗ 𝟙 X.V) ≫ (λ_ X.V).hom) ≫ 𝟙 X.V = (λ_ X.V).hom
state_after: no goals
Theorem: HahnSeries.mul_single_zero_coeff
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

tactic: rw [← add_zero a, mul_single_coeff_add, add_zero]
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
r : R
x : HahnSeries Γ R
a : Γ
⊢ (x * (single 0) r).coeff a = x.coeff a * r
state_after: no goals
Theorem: Polynomial.Chebyshev.induct
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: simpa only [Int.negSucc_eq, neg_add] using neg_add_one n hn hnm
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
motive : ℤ → Prop
zero : motive 0
one : motive 1
add_two : ∀ (n : ℕ), motive (↑n + 1) → motive ↑n → motive (↑n + 2)
neg_add_one : ∀ (n : ℕ), motive (-↑n) → motive (-↑n + 1) → motive (-↑n - 1)
n : ℕ
hn : motive (-↑n)
hnm : motive (-↑n + 1)
⊢ motive (Int.negSucc n)
state_after: no goals
Theorem: AlgebraicGeometry.LocallyRingedSpace.not_mem_prime_iff_unit_in_stalk
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

tactic: erw [LocalRing.mem_maximalIdeal, Classical.not_not]
state_before: X : LocallyRingedSpace
r : ↑(Γ.obj { unop := X })
x : ↑X.toTopCat
⊢ r ∉ (X.toΓSpecFun x).asIdeal ↔ IsUnit ((X.ΓToStalk x) r)
state_after: no goals
Theorem: CategoryTheory.Limits.Types.Pushout.Rel'.symm
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

tactic: obtain _|⟨_, _, h⟩|_|_ := h
state_before: S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
x y : X₁ ⊕ X₂
h : Rel' f g x y
⊢ Rel' f g y x
state_after: case refl
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
x : X₁ ⊕ X₂
⊢ Rel' f g x x

case inl_inl
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
x₀✝ y₀✝ : S
h : g x₀✝ = g y₀✝
⊢ Rel' f g (Sum.inl (f y₀✝)) (Sum.inl (f x₀✝))

case inl_inr
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
s✝ : S
⊢ Rel' f g (Sum.inr (g s✝)) (Sum.inl (f s✝))

case inr_inl
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
s✝ : S
⊢ Rel' f g (Sum.inl (f s✝)) (Sum.inr (g s✝))

tactic: apply Rel'.refl
state_before: case refl
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
x : X₁ ⊕ X₂
⊢ Rel' f g x x
state_after: no goals

tactic: exact Rel'.inl_inl _ _ h.symm
state_before: case inl_inl
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
x₀✝ y₀✝ : S
h : g x₀✝ = g y₀✝
⊢ Rel' f g (Sum.inl (f y₀✝)) (Sum.inl (f x₀✝))
state_after: no goals

tactic: exact Rel'.inr_inl _
state_before: case inl_inr
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
s✝ : S
⊢ Rel' f g (Sum.inr (g s✝)) (Sum.inl (f s✝))
state_after: no goals

tactic: exact Rel'.inl_inr _
state_before: case inr_inl
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
s✝ : S
⊢ Rel' f g (Sum.inl (f s✝)) (Sum.inr (g s✝))
state_after: no goals
Theorem: CategoryTheory.ShortComplex.leftRightHomologyComparison'_compatibility
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: rw [leftRightHomologyComparison'_naturality_assoc (𝟙 S) h₁ h₂ h₁' h₂',
  ← rightHomologyMap'_comp, comp_id, rightHomologyMap'_id, comp_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
h₁ h₁' : S.LeftHomologyData
h₂ h₂' : S.RightHomologyData
⊢ leftRightHomologyComparison' h₁ h₂ =
    leftHomologyMap' (𝟙 S) h₁ h₁' ≫ leftRightHomologyComparison' h₁' h₂' ≫ rightHomologyMap' (𝟙 S) h₂' h₂
state_after: no goals
Theorem: TopologicalSpace.exists_countable_basis
File: Mathlib/Topology/Bases.lean

tactic: obtain ⟨b, hb₁, hb₂⟩ := @SecondCountableTopology.is_open_generated_countable α _ _
state_before: α : Type u
t : TopologicalSpace α
inst✝ : SecondCountableTopology α
⊢ ∃ b, b.Countable ∧ ∅ ∉ b ∧ IsTopologicalBasis b
state_after: case intro.intro
α : Type u
t : TopologicalSpace α
inst✝ : SecondCountableTopology α
b : Set (Set α)
hb₁ : b.Countable
hb₂ : t = generateFrom b
⊢ ∃ b, b.Countable ∧ ∅ ∉ b ∧ IsTopologicalBasis b

tactic: refine ⟨_, ?_, not_mem_diff_of_mem ?_, (isTopologicalBasis_of_subbasis hb₂).diff_empty⟩
state_before: case intro.intro
α : Type u
t : TopologicalSpace α
inst✝ : SecondCountableTopology α
b : Set (Set α)
hb₁ : b.Countable
hb₂ : t = generateFrom b
⊢ ∃ b, b.Countable ∧ ∅ ∉ b ∧ IsTopologicalBasis b
state_after: case intro.intro.refine_1
α : Type u
t : TopologicalSpace α
inst✝ : SecondCountableTopology α
b : Set (Set α)
hb₁ : b.Countable
hb₂ : t = generateFrom b
⊢ ((fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ b} \ {∅}).Countable

case intro.intro.refine_2
α : Type u
t : TopologicalSpace α
inst✝ : SecondCountableTopology α
b : Set (Set α)
hb₁ : b.Countable
hb₂ : t = generateFrom b
⊢ ∅ ∈ {∅}

tactic: exacts [((countable_setOf_finite_subset hb₁).image _).mono diff_subset, rfl]
state_before: case intro.intro.refine_1
α : Type u
t : TopologicalSpace α
inst✝ : SecondCountableTopology α
b : Set (Set α)
hb₁ : b.Countable
hb₂ : t = generateFrom b
⊢ ((fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ b} \ {∅}).Countable

case intro.intro.refine_2
α : Type u
t : TopologicalSpace α
inst✝ : SecondCountableTopology α
b : Set (Set α)
hb₁ : b.Countable
hb₂ : t = generateFrom b
⊢ ∅ ∈ {∅}
state_after: no goals
Theorem: Polynomial.roots_C_mul
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: by_cases hp : p = 0 <;>
  simp only [roots_mul, *, Ne, mul_eq_zero, C_eq_zero, or_self_iff, not_false_iff, roots_C,
    zero_add, mul_zero]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
ha : a ≠ 0
⊢ (C a * p).roots = p.roots
state_after: no goals
Theorem: Finset.mulEnergy_comm
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: rw [mulEnergy, ← Finset.card_map (Equiv.prodComm _ _).toEmbedding, map_filter]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ Eₘ[s, t] = Eₘ[t, s]
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ (filter ((fun x => x.1.1 * x.2.1 = x.1.2 * x.2.2) ∘ ⇑(Equiv.prodComm (α × α) (α × α)).symm)
        (map (Equiv.prodComm (α × α) (α × α)).toEmbedding ((s ×ˢ s) ×ˢ t ×ˢ t))).card =
    Eₘ[t, s]

tactic: simp [-Finset.card_map, eq_comm, mulEnergy, mul_comm, map_eq_image, Function.comp]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ (filter ((fun x => x.1.1 * x.2.1 = x.1.2 * x.2.2) ∘ ⇑(Equiv.prodComm (α × α) (α × α)).symm)
        (map (Equiv.prodComm (α × α) (α × α)).toEmbedding ((s ×ˢ s) ×ˢ t ×ˢ t))).card =
    Eₘ[t, s]
state_after: no goals
Theorem: isRegular_mul_iff
File: Mathlib/Algebra/Regular/Basic.lean

tactic: refine Iff.trans ?_ isRegular_mul_and_mul_iff
state_before: R : Type u_1
inst✝ : CommSemigroup R
a b : R
⊢ IsRegular (a * b) ↔ IsRegular a ∧ IsRegular b
state_after: R : Type u_1
inst✝ : CommSemigroup R
a b : R
⊢ IsRegular (a * b) ↔ IsRegular (a * b) ∧ IsRegular (b * a)

tactic: exact ⟨fun ab => ⟨ab, by rwa [mul_comm]⟩, fun rab => rab.1⟩
state_before: R : Type u_1
inst✝ : CommSemigroup R
a b : R
⊢ IsRegular (a * b) ↔ IsRegular (a * b) ∧ IsRegular (b * a)
state_after: no goals

tactic: rwa [mul_comm]
state_before: R : Type u_1
inst✝ : CommSemigroup R
a b : R
ab : IsRegular (a * b)
⊢ IsRegular (b * a)
state_after: no goals
Theorem: continuousWithinAt_Icc_iff_Iic
File: Mathlib/Topology/Order/OrderClosed.lean

tactic: simp only [ContinuousWithinAt, nhdsWithin_Icc_eq_nhdsWithin_Iic h]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : ClosedIicTopology α
inst✝ : TopologicalSpace β
a b c : α
f : α → β
h : a < b
⊢ ContinuousWithinAt f (Icc a b) b ↔ ContinuousWithinAt f (Iic b) b
state_after: no goals
Theorem: WithTop.LinearOrderedAddCommGroup.top_sub
File: Mathlib/Algebra/Order/Group/WithTop.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d : α
a : WithTop α
⊢ ⊤ - a = ⊤
state_after: no goals
Theorem: RelSeries.head_smash
File: Mathlib/Order/RelSeries.lean

tactic: delta head smash
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
⊢ (p.smash q h).head = p.head
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
⊢ { length := p.length + q.length,
          toFun := fun i => if H : ↑i < p.length then p.toFun ⟨↑i, ⋯⟩ else q.toFun ⟨↑i - p.length, ⋯⟩, step := ⋯ }.toFun
      0 =
    p.toFun 0

tactic: simp only [Fin.val_zero, Fin.zero_eta, ge_iff_le, zero_le, tsub_eq_zero_of_le, dite_eq_ite,
  ite_eq_left_iff, not_lt, nonpos_iff_eq_zero]
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
⊢ { length := p.length + q.length,
          toFun := fun i => if H : ↑i < p.length then p.toFun ⟨↑i, ⋯⟩ else q.toFun ⟨↑i - p.length, ⋯⟩, step := ⋯ }.toFun
      0 =
    p.toFun 0
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
⊢ p.length = 0 → q.toFun 0 = p.toFun 0

tactic: intro H
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
⊢ p.length = 0 → q.toFun 0 = p.toFun 0
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
H : p.length = 0
⊢ q.toFun 0 = p.toFun 0

tactic: convert h.symm
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
H : p.length = 0
⊢ q.toFun 0 = p.toFun 0
state_after: case h.e'_3
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
H : p.length = 0
⊢ p.toFun 0 = p.last

tactic: congr
state_before: case h.e'_3
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
H : p.length = 0
⊢ p.toFun 0 = p.last
state_after: case h.e'_3.e_a
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
H : p.length = 0
⊢ 0 = Fin.last p.length

tactic: aesop
state_before: case h.e'_3.e_a
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
H : p.length = 0
⊢ 0 = Fin.last p.length
state_after: no goals
Theorem: MeasureTheory.setToFun_zero
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: erw [setToFun_eq hT (integrable_zero _ _ _), Integrable.toL1_zero, ContinuousLinearMap.map_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
⊢ setToFun μ T hT 0 = 0
state_after: no goals
Theorem: Set.image_sub_const_Iic
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_neg_add]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) '' Iic b = Iic (b - a)
state_after: no goals
Theorem: List.Ico.nodup
File: Mathlib/Data/List/Intervals.lean

tactic: dsimp [Ico]
state_before: n m : ℕ
⊢ (Ico n m).Nodup
state_after: n m : ℕ
⊢ (range' n (m - n)).Nodup

tactic: simp [nodup_range', autoParam]
state_before: n m : ℕ
⊢ (range' n (m - n)).Nodup
state_after: no goals
Theorem: Complex.isTheta_exp_arg_mul_im
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: rcases hl with ⟨b, hb⟩
state_before: α : Type u_1
l : Filter α
f g : α → ℂ
hl : IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => |(g x).im|
⊢ (fun x => rexp ((f x).arg * (g x).im)) =Θ[l] fun x => 1
state_after: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (x : ℝ) in Filter.map (fun x => |(g x).im|) l, (fun x x_1 => x ≤ x_1) x b
⊢ (fun x => rexp ((f x).arg * (g x).im)) =Θ[l] fun x => 1

tactic: refine Real.isTheta_exp_comp_one.2 ⟨π * b, ?_⟩
state_before: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (x : ℝ) in Filter.map (fun x => |(g x).im|) l, (fun x x_1 => x ≤ x_1) x b
⊢ (fun x => rexp ((f x).arg * (g x).im)) =Θ[l] fun x => 1
state_after: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (x : ℝ) in Filter.map (fun x => |(g x).im|) l, (fun x x_1 => x ≤ x_1) x b
⊢ ∀ᶠ (x : ℝ) in Filter.map (fun x => |(f x).arg * (g x).im|) l, (fun x x_1 => x ≤ x_1) x (π * b)

tactic: rw [eventually_map] at hb ⊢
state_before: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (x : ℝ) in Filter.map (fun x => |(g x).im|) l, (fun x x_1 => x ≤ x_1) x b
⊢ ∀ᶠ (x : ℝ) in Filter.map (fun x => |(f x).arg * (g x).im|) l, (fun x x_1 => x ≤ x_1) x (π * b)
state_after: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) |(g a).im| b
⊢ ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) |(f a).arg * (g a).im| (π * b)

tactic: refine hb.mono fun x hx => ?_
state_before: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) |(g a).im| b
⊢ ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) |(f a).arg * (g a).im| (π * b)
state_after: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) |(g a).im| b
x : α
hx : (fun x x_1 => x ≤ x_1) |(g x).im| b
⊢ (fun x x_1 => x ≤ x_1) |(f x).arg * (g x).im| (π * b)

tactic: erw [abs_mul]
state_before: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) |(g a).im| b
x : α
hx : (fun x x_1 => x ≤ x_1) |(g x).im| b
⊢ (fun x x_1 => x ≤ x_1) |(f x).arg * (g x).im| (π * b)
state_after: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) |(g a).im| b
x : α
hx : (fun x x_1 => x ≤ x_1) |(g x).im| b
⊢ (fun x x_1 => x ≤ x_1) (|(f x).arg| * |(g x).im|) (π * b)

tactic: exact mul_le_mul (abs_arg_le_pi _) hx (abs_nonneg _) Real.pi_pos.le
state_before: case intro
α : Type u_1
l : Filter α
f g : α → ℂ
b : ℝ
hb : ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) |(g a).im| b
x : α
hx : (fun x x_1 => x ≤ x_1) |(g x).im| b
⊢ (fun x x_1 => x ≤ x_1) (|(f x).arg| * |(g x).im|) (π * b)
state_after: no goals
Theorem: ArithmeticFunction.IsMultiplicative.intCast
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp [h]
state_before: R : Type u_1
f : ArithmeticFunction ℤ
inst✝ : Ring R
h : f.IsMultiplicative
⊢ ↑f 1 = 1
state_after: no goals

tactic: simp [h.2 cop]
state_before: R : Type u_1
f : ArithmeticFunction ℤ
inst✝ : Ring R
h : f.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ ↑f (m * n) = ↑f m * ↑f n
state_after: no goals
Theorem: QuaternionAlgebra.algebraMap_injective
File: Mathlib/Algebra/Quaternion.lean

tactic: simp [algebraMap_eq]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
x✝¹ x✝ : R
⊢ (algebraMap R ℍ[R,c₁,c₂]) x✝¹ = (algebraMap R ℍ[R,c₁,c₂]) x✝ → x✝¹ = x✝
state_after: no goals
Theorem: IntermediateField.exists_finset_of_mem_iSup
File: Mathlib/FieldTheory/Adjoin.lean

tactic: have := (adjoin_simple_isCompactElement x).exists_finset_of_le_iSup (IntermediateField F E) f
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
this : F⟮x⟯ ≤ ⨆ i, f i → ∃ s, F⟮x⟯ ≤ ⨆ i ∈ s, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i

tactic: simp only [adjoin_simple_le_iff] at this
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
this : F⟮x⟯ ≤ ⨆ i, f i → ∃ s, F⟮x⟯ ≤ ⨆ i ∈ s, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
this : x ∈ ⨆ i, f i → ∃ s, x ∈ ⨆ i ∈ s, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i

tactic: exact this hx
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
this : x ∈ ⨆ i, f i → ∃ s, x ∈ ⨆ i ∈ s, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i
state_after: no goals
Theorem: Hyperreal.gt_of_tendsto_zero_of_neg
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [← neg_neg r, coe_neg]
state_before: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r : ℝ
hr : r < 0
⊢ ↑r < ofSeq f
state_after: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r : ℝ
hr : r < 0
⊢ -↑(-r) < ofSeq f

tactic: exact neg_lt_of_tendsto_zero_of_pos hf (neg_pos.mpr hr)
state_before: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r : ℝ
hr : r < 0
⊢ -↑(-r) < ofSeq f
state_after: no goals
Theorem: ArithmeticFunction.moebius_sq
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: split_ifs with h
state_before: R : Type u_1
n : ℕ
⊢ μ n ^ 2 = if Squarefree n then 1 else 0
state_after: case pos
R : Type u_1
n : ℕ
h : Squarefree n
⊢ μ n ^ 2 = 1

case neg
R : Type u_1
n : ℕ
h : ¬Squarefree n
⊢ μ n ^ 2 = 0

tactic: exact moebius_sq_eq_one_of_squarefree h
state_before: case pos
R : Type u_1
n : ℕ
h : Squarefree n
⊢ μ n ^ 2 = 1
state_after: no goals

tactic: simp only [pow_eq_zero_iff, moebius_eq_zero_of_not_squarefree h,
zero_pow (show 2 ≠ 0 by norm_num)]
state_before: case neg
R : Type u_1
n : ℕ
h : ¬Squarefree n
⊢ μ n ^ 2 = 0
state_after: no goals

tactic: norm_num
state_before: R : Type u_1
n : ℕ
h : ¬Squarefree n
⊢ 2 ≠ 0
state_after: no goals
Theorem: Finset.pairwise_cons'
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [pairwise_subtype_iff_pairwise_finset', Finset.coe_cons, Set.pairwise_insert,
  Finset.mem_coe, and_congr_right_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
⊢ _root_.Pairwise (r on fun a_1 => f ↑a_1) ↔
    _root_.Pairwise (r on fun a => f ↑a) ∧ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
⊢ (↑s).Pairwise (r on f) → ((∀ b ∈ s, a ≠ b → (r on f) a b ∧ (r on f) b a) ↔ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a))

tactic: exact fun _ =>
  ⟨fun h b hb =>
    h b hb <| by
      rintro rfl
      contradiction,
    fun h b hb _ => h b hb⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
⊢ (↑s).Pairwise (r on f) → ((∀ b ∈ s, a ≠ b → (r on f) a b ∧ (r on f) b a) ↔ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a))
state_after: no goals

tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
x✝ : (↑s).Pairwise (r on f)
h : ∀ b ∈ s, a ≠ b → (r on f) a b ∧ (r on f) b a
b : α
hb : b ∈ s
⊢ a ≠ b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
x✝ : (↑s).Pairwise (r on f)
h : ∀ b ∈ s, a ≠ b → (r on f) a b ∧ (r on f) b a
hb : a ∈ s
⊢ False

tactic: contradiction
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
x✝ : (↑s).Pairwise (r on f)
h : ∀ b ∈ s, a ≠ b → (r on f) a b ∧ (r on f) b a
hb : a ∈ s
⊢ False
state_after: no goals
Theorem: exists_monotone_Icc_subset_open_cover_unitInterval
File: Mathlib/Topology/UnitInterval.lean

tactic: simp_rw [← Subtype.coe_inj]
state_before: ι : Sort u_1
c : ι → Set ↑I
hc₁ : ∀ (i : ι), IsOpen (c i)
hc₂ : univ ⊆ ⋃ i, c i
⊢ ∃ t, t 0 = 0 ∧ Monotone t ∧ (∃ n, ∀ m ≥ n, t m = 1) ∧ ∀ (n : ℕ), ∃ i, Icc (t n) (t (n + 1)) ⊆ c i
state_after: ι : Sort u_1
c : ι → Set ↑I
hc₁ : ∀ (i : ι), IsOpen (c i)
hc₂ : univ ⊆ ⋃ i, c i
⊢ ∃ t, ↑(t 0) = ↑0 ∧ Monotone t ∧ (∃ n, ∀ m ≥ n, ↑(t m) = ↑1) ∧ ∀ (n : ℕ), ∃ i, Icc (t n) (t (n + 1)) ⊆ c i

tactic: exact exists_monotone_Icc_subset_open_cover_Icc zero_le_one hc₁ hc₂
state_before: ι : Sort u_1
c : ι → Set ↑I
hc₁ : ∀ (i : ι), IsOpen (c i)
hc₂ : univ ⊆ ⋃ i, c i
⊢ ∃ t, ↑(t 0) = ↑0 ∧ Monotone t ∧ (∃ n, ∀ m ≥ n, ↑(t m) = ↑1) ∧ ∀ (n : ℕ), ∃ i, Icc (t n) (t (n + 1)) ⊆ c i
state_after: no goals
Theorem: AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_le_nat
File: Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean

tactic: obtain ⟨c, hc_mem, hc⟩ := hf.eventually_atTop_le hb
state_before: f : ℝ → ℝ
b : ℝ
hb : b ∈ Set.Ioo 0 1
hf : GrowsPolynomially f
⊢ ∃ c > 0, ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (b * ↑n) ↑n, f u ≤ c * f ↑n
state_after: case intro.intro
f : ℝ → ℝ
b : ℝ
hb : b ∈ Set.Ioo 0 1
hf : GrowsPolynomially f
c : ℝ
hc_mem : c > 0
hc : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ≤ c * f x
⊢ ∃ c > 0, ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (b * ↑n) ↑n, f u ≤ c * f ↑n

tactic: exact ⟨c, hc_mem, hc.natCast_atTop⟩
state_before: case intro.intro
f : ℝ → ℝ
b : ℝ
hb : b ∈ Set.Ioo 0 1
hf : GrowsPolynomially f
c : ℝ
hc_mem : c > 0
hc : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ≤ c * f x
⊢ ∃ c > 0, ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (b * ↑n) ↑n, f u ≤ c * f ↑n
state_after: no goals