1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.rpow_def_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_def, Complex.cpow_def, if_neg]
state_before: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ x ^ y = rexp (log x * y) * cos (y * π)
state_after: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ (Complex.exp (Complex.log ↑x * ↑y)).re = rexp (log x * y) * cos (y * π)

case hnc
x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ ¬↑x = 0

tactic: have : Complex.log x * y = ↑(log (-x) * y) + ↑(y * π) * Complex.I := by
  simp only [Complex.log, abs_of_neg hx, Complex.arg_ofReal_of_neg hx, Complex.abs_ofReal,
    Complex.ofReal_mul]
  ring
state_before: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ (Complex.exp (Complex.log ↑x * ↑y)).re = rexp (log x * y) * cos (y * π)
state_after: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
this : Complex.log ↑x * ↑y = ↑(log (-x) * y) + ↑(y * π) * Complex.I
⊢ (Complex.exp (Complex.log ↑x * ↑y)).re = rexp (log x * y) * cos (y * π)

tactic: rw [this, Complex.exp_add_mul_I, ← Complex.ofReal_exp, ← Complex.ofReal_cos, ←
  Complex.ofReal_sin, mul_add, ← Complex.ofReal_mul, ← mul_assoc, ← Complex.ofReal_mul,
  Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.I_re, Complex.ofReal_im,
  Real.log_neg_eq_log]
state_before: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
this : Complex.log ↑x * ↑y = ↑(log (-x) * y) + ↑(y * π) * Complex.I
⊢ (Complex.exp (Complex.log ↑x * ↑y)).re = rexp (log x * y) * cos (y * π)
state_after: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
this : Complex.log ↑x * ↑y = ↑(log (-x) * y) + ↑(y * π) * Complex.I
⊢ rexp (log x * y) * cos (y * π) + ((↑(rexp (log x * y) * sin (y * π))).re * 0 - 0 * Complex.I.im) =
    rexp (log x * y) * cos (y * π)

tactic: ring
state_before: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
this : Complex.log ↑x * ↑y = ↑(log (-x) * y) + ↑(y * π) * Complex.I
⊢ rexp (log x * y) * cos (y * π) + ((↑(rexp (log x * y) * sin (y * π))).re * 0 - 0 * Complex.I.im) =
    rexp (log x * y) * cos (y * π)
state_after: no goals

tactic: simp only [Complex.log, abs_of_neg hx, Complex.arg_ofReal_of_neg hx, Complex.abs_ofReal,
  Complex.ofReal_mul]
state_before: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ Complex.log ↑x * ↑y = ↑(log (-x) * y) + ↑(y * π) * Complex.I
state_after: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ (↑(log (-x)) + ↑π * Complex.I) * ↑y = ↑(log (-x)) * ↑y + ↑y * ↑π * Complex.I

tactic: ring
state_before: x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ (↑(log (-x)) + ↑π * Complex.I) * ↑y = ↑(log (-x)) * ↑y + ↑y * ↑π * Complex.I
state_after: no goals

tactic: rw [Complex.ofReal_eq_zero]
state_before: case hnc
x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ ¬↑x = 0
state_after: case hnc
x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ ¬x = 0

tactic: exact ne_of_lt hx
state_before: case hnc
x✝ y✝ z x : ℝ
hx : x < 0
y : ℝ
⊢ ¬x = 0
state_after: no goals
Theorem: FermatLastTheoremWith.mono
File: Mathlib/NumberTheory/FLT/Basic.lean

tactic: rintro a b c ha hb hc
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n : ℕ
hmn : m ∣ n
hm : FermatLastTheoremWith α m
⊢ FermatLastTheoremWith α n
state_after: α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n : ℕ
hmn : m ∣ n
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
⊢ a ^ n + b ^ n ≠ c ^ n

tactic: obtain ⟨k, rfl⟩ := hmn
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n : ℕ
hmn : m ∣ n
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
⊢ a ^ n + b ^ n ≠ c ^ n
state_after: case intro
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m : ℕ
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
k : ℕ
⊢ a ^ (m * k) + b ^ (m * k) ≠ c ^ (m * k)

tactic: simp_rw [pow_mul']
state_before: case intro
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m : ℕ
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
k : ℕ
⊢ a ^ (m * k) + b ^ (m * k) ≠ c ^ (m * k)
state_after: case intro
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m : ℕ
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
k : ℕ
⊢ (a ^ k) ^ m + (b ^ k) ^ m ≠ (c ^ k) ^ m

tactic: refine hm _ _ _ ?_ ?_ ?_ <;> exact pow_ne_zero _ ‹_›
state_before: case intro
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m : ℕ
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
k : ℕ
⊢ (a ^ k) ^ m + (b ^ k) ^ m ≠ (c ^ k) ^ m
state_after: no goals
Theorem: AddCommGrp.image.lift_fac
File: Mathlib/Algebra/Category/Grp/Images.lean

tactic: ext x
state_before: G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
⊢ lift F' ≫ F'.m = ι f
state_after: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ (lift F' ≫ F'.m) x = (ι f) x

tactic: change (F'.e ≫ F'.m) _ = _
state_before: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ (lift F' ≫ F'.m) x = (ι f) x
state_after: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ (F'.e ≫ F'.m) ↑(Classical.indefiniteDescription (fun x_1 => f x_1 = ↑x) ⋯) = (ι f) x

tactic: rw [F'.fac, (Classical.indefiniteDescription _ x.2).2]
state_before: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ (F'.e ≫ F'.m) ↑(Classical.indefiniteDescription (fun x_1 => f x_1 = ↑x) ⋯) = (ι f) x
state_after: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ ↑x = (ι f) x

tactic: rfl
state_before: case w
G H : AddCommGrp
f : G ⟶ H
F' : MonoFactorisation f
x : ↑(image f)
⊢ ↑x = (ι f) x
state_after: no goals
Theorem: LocalRing.of_surjective
File: Mathlib/RingTheory/Ideal/LocalRing.lean

tactic: intro a b hab
state_before: R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
⊢ ∀ (a b : S), IsUnit (a + b) → IsUnit a ∨ IsUnit b
state_after: R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
a b : S
hab : IsUnit (a + b)
⊢ IsUnit a ∨ IsUnit b

tactic: obtain ⟨a, rfl⟩ := hf a
state_before: R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
a b : S
hab : 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
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
b : S
a : R
hab : IsUnit (f a + b)
⊢ IsUnit (f a) ∨ IsUnit b

tactic: obtain ⟨b, rfl⟩ := hf b
state_before: case intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
b : S
a : R
hab : IsUnit (f a + b)
⊢ IsUnit (f a) ∨ IsUnit b
state_after: case intro.intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
a b : R
hab : IsUnit (f a + f b)
⊢ IsUnit (f a) ∨ IsUnit (f b)

tactic: rw [← map_add] at hab
state_before: case intro.intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
a b : R
hab : IsUnit (f a + f b)
⊢ IsUnit (f a) ∨ IsUnit (f b)
state_after: case intro.intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
a b : R
hab : IsUnit (f (a + b))
⊢ IsUnit (f a) ∨ IsUnit (f b)

tactic: exact
  (isUnit_or_isUnit_of_isUnit_add <| IsLocalRingHom.map_nonunit _ hab).imp f.isUnit_map
    f.isUnit_map
state_before: case intro.intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ⇑f
a b : R
hab : IsUnit (f (a + b))
⊢ IsUnit (f a) ∨ IsUnit (f b)
state_after: no goals
Theorem: isClosed_sum_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp only [← isOpen_compl_iff, isOpen_sum_iff, preimage_compl]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
s : Set (X ⊕ Y)
⊢ IsClosed s ↔ IsClosed (inl ⁻¹' s) ∧ IsClosed (inr ⁻¹' s)
state_after: no goals
Theorem: Finset.mem_mulSpan
File: Mathlib/Combinatorics/Additive/Dissociation.lean

tactic: simp [mulSpan]
state_before: α : Type u_1
β : Type u_2
inst✝³ : CommGroup α
inst✝² : CommGroup β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s t u : Finset α
a : α
d : ℕ
⊢ a ∈ s.mulSpan ↔ ∃ ε, (∀ (a : α), ε a = -1 ∨ ε a = 0 ∨ ε a = 1) ∧ ∏ a ∈ s, a ^ ε a = a
state_after: no goals
Theorem: StarSubalgebra.coe_isUnit
File: Mathlib/Analysis/NormedSpace/Star/ContinuousFunctionalCalculus.lean

tactic: refine ⟨fun hx =>
         ⟨⟨x, ⟨(↑hx.unit⁻¹ : A), StarSubalgebra.isUnit_coe_inv_mem hS hx x.prop⟩, ?_, ?_⟩, rfl⟩,
        fun hx => hx.map S.subtype⟩
state_before: A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
⊢ IsUnit ↑x ↔ IsUnit x
state_after: case refine_1
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ x * ⟨↑hx.unit⁻¹, ⋯⟩ = 1

case refine_2
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ ⟨↑hx.unit⁻¹, ⋯⟩ * x = 1

tactic: exacts [Subtype.coe_injective hx.mul_val_inv, Subtype.coe_injective hx.val_inv_mul]
state_before: case refine_1
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ x * ⟨↑hx.unit⁻¹, ⋯⟩ = 1

case refine_2
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ ⟨↑hx.unit⁻¹, ⋯⟩ * x = 1
state_after: no goals
Theorem: Finset.diag_mem_sym2_iff
File: Mathlib/Data/Finset/Sym.lean

tactic: simp [diag_mem_sym2_mem_iff]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ Sym2.diag a ∈ s.sym2 ↔ a ∈ s
state_after: no goals
Theorem: PosNum.cast_mul
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_nat, mul_to_nat, Nat.cast_mul, cast_to_nat, cast_to_nat]
state_before: α : Type u_1
inst✝ : Semiring α
m n : PosNum
⊢ ↑(m * n) = ↑m * ↑n
state_after: no goals
Theorem: WeierstrassCurve.Affine.addY_sub_negY_addY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: simp_rw [addY, negY, eq_div_iff (sub_ne_zero.mpr hx.symm)]
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ ≠ x₂
⊢ W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂) -
      W.negY (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) (W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂)) =
    ((y₂ - W.negY x₂ y₂) * (x₁ - W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) -
        (y₁ - W.negY x₁ y₁) * (x₂ - W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) /
      (x₂ - x₁)
state_after: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ ≠ x₂
⊢ (-W.negAddY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂) - W.a₁ * W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - W.a₃ -
        (-(-W.negAddY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂) - W.a₁ * W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - W.a₃) -
            W.a₁ * W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) -
          W.a₃)) *
      (x₂ - x₁) =
    (y₂ - (-y₂ - W.a₁ * x₂ - W.a₃)) * (x₁ - W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) -
      (y₁ - (-y₁ - W.a₁ * x₁ - W.a₃)) * (x₂ - W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))

tactic: linear_combination 2 * cyclic_sum_Y_mul_X_sub_X y₁ y₂ hx
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ ≠ x₂
⊢ (-W.negAddY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂) - W.a₁ * W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - W.a₃ -
        (-(-W.negAddY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂) - W.a₁ * W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - W.a₃) -
            W.a₁ * W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) -
          W.a₃)) *
      (x₂ - x₁) =
    (y₂ - (-y₂ - W.a₁ * x₂ - W.a₃)) * (x₁ - W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) -
      (y₁ - (-y₁ - W.a₁ * x₁ - W.a₃)) * (x₂ - W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))
state_after: no goals
Theorem: Polynomial.smeval_smul
File: Mathlib/Algebra/Polynomial/Smeval.lean

tactic: induction p using Polynomial.induction_on' with
| h_add p q ph qh =>
  rw [smul_add, smeval_add, ph, qh, ← smul_add, smeval_add]
| h_monomial n a =>
  rw [smul_monomial, smeval_monomial, smeval_monomial, smul_assoc]
state_before: R : Type u_1
inst✝³ : Semiring R
p q : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : Module R S
x : S
r : R
⊢ (r • p).smeval x = r • p.smeval x
state_after: no goals

tactic: rw [smul_add, smeval_add, ph, qh, ← smul_add, smeval_add]
state_before: case h_add
R : Type u_1
inst✝³ : Semiring R
p✝ q✝ : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : Module R S
x : S
r : R
p q : R[X]
ph : (r • p).smeval x = r • p.smeval x
qh : (r • q).smeval x = r • q.smeval x
⊢ (r • (p + q)).smeval x = r • (p + q).smeval x
state_after: no goals

tactic: rw [smul_monomial, smeval_monomial, smeval_monomial, smul_assoc]
state_before: case h_monomial
R : Type u_1
inst✝³ : Semiring R
p q : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : Module R S
x : S
r : R
n : ℕ
a : R
⊢ (r • (monomial n) a).smeval x = r • ((monomial n) a).smeval x
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.measure_support_lt_top
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: rw [support_eq]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
inst✝ : Zero β
f : α →ₛ β
hf : ∀ (y : β), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤
⊢ μ (support ↑f) < ⊤
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
inst✝ : Zero β
f : α →ₛ β
hf : ∀ (y : β), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤
⊢ μ (⋃ y ∈ filter (fun y => y ≠ 0) f.range, ↑f ⁻¹' {y}) < ⊤

tactic: refine (measure_biUnion_finset_le _ _).trans_lt (ENNReal.sum_lt_top_iff.mpr fun y hy => ?_)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
inst✝ : Zero β
f : α →ₛ β
hf : ∀ (y : β), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤
⊢ μ (⋃ y ∈ filter (fun y => y ≠ 0) f.range, ↑f ⁻¹' {y}) < ⊤
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
inst✝ : Zero β
f : α →ₛ β
hf : ∀ (y : β), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤
y : β
hy : y ∈ filter (fun y => y ≠ 0) f.range
⊢ μ (↑f ⁻¹' {y}) < ⊤

tactic: rw [Finset.mem_filter] at hy
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
inst✝ : Zero β
f : α →ₛ β
hf : ∀ (y : β), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤
y : β
hy : y ∈ filter (fun y => y ≠ 0) f.range
⊢ μ (↑f ⁻¹' {y}) < ⊤
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
inst✝ : Zero β
f : α →ₛ β
hf : ∀ (y : β), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤
y : β
hy : y ∈ f.range ∧ y ≠ 0
⊢ μ (↑f ⁻¹' {y}) < ⊤

tactic: exact hf y hy.2
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
inst✝ : Zero β
f : α →ₛ β
hf : ∀ (y : β), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤
y : β
hy : y ∈ f.range ∧ y ≠ 0
⊢ μ (↑f ⁻¹' {y}) < ⊤
state_after: no goals
Theorem: Equiv.bijOn
File: Mathlib/Data/Set/Function.lean

tactic: rwa [apply_symm_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
e : α ≃ β
s : Set α
t : Set β
h : ∀ (a : α), e a ∈ t ↔ a ∈ s
b : β
hb : b ∈ t
⊢ e (e.symm b) ∈ t
state_after: no goals
Theorem: Submodule.finrank_add_eq_of_isCompl
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← finrank_sup_add_finrank_inf_eq, h.codisjoint.eq_top, h.disjoint.eq_bot, finrank_bot,
  add_zero]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
U W : Submodule K V
h : IsCompl U W
⊢ finrank K ↥U + finrank K ↥W = finrank K V
state_after: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
U W : Submodule K V
h : IsCompl U W
⊢ finrank K ↥⊤ = finrank K V

tactic: exact finrank_top _ _
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
U W : Submodule K V
h : IsCompl U W
⊢ finrank K ↥⊤ = finrank K V
state_after: no goals
Theorem: integral_sin_pow_mul_cos_pow_odd
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: fun_prop
state_before: a b : ℝ
n✝ m n : ℕ
⊢ Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
state_after: no goals

tactic: simp only [_root_.pow_zero, _root_.pow_succ, mul_assoc, pow_mul, one_mul]
state_before: a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
⊢ ∫ (x : ℝ) in a..b, sin x ^ m * cos x ^ (2 * n + 1) = ∫ (x : ℝ) in a..b, sin x ^ m * (1 - sin x ^ 2) ^ n * cos x
state_after: a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
⊢ ∫ (x : ℝ) in a..b, sin x ^ m * ((cos x * cos x) ^ n * cos x) =
    ∫ (x : ℝ) in a..b, sin x ^ m * ((1 - sin x * sin x) ^ n * cos x)

tactic: congr! 5
state_before: a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
⊢ ∫ (x : ℝ) in a..b, sin x ^ m * ((cos x * cos x) ^ n * cos x) =
    ∫ (x : ℝ) in a..b, sin x ^ m * ((1 - sin x * sin x) ^ n * cos x)
state_after: case h.e'_4.h.h.e'_6.h.e'_5.h.e'_5
a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
x✝ : ℝ
⊢ cos x✝ * cos x✝ = 1 - sin x✝ * sin x✝

tactic: rw [← sq, ← sq, cos_sq']
state_before: case h.e'_4.h.h.e'_6.h.e'_5.h.e'_5
a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
x✝ : ℝ
⊢ cos x✝ * cos x✝ = 1 - sin x✝ * sin x✝
state_after: no goals

tactic: exact integral_comp_mul_deriv (fun x _ => hasDerivAt_sin x) continuousOn_cos hc
state_before: a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
⊢ ∫ (x : ℝ) in a..b, sin x ^ m * (1 - sin x ^ 2) ^ n * cos x = ∫ (u : ℝ) in sin a..sin b, u ^ m * (1 - u ^ 2) ^ n
state_after: no goals
Theorem: List.Ico.filter_lt_of_le_bot
File: Mathlib/Data/List/Intervals.lean

tactic: simp only [decide_eq_true_eq, not_lt]
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ ¬decide (k < l) = true
state_after: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ l ≤ k

tactic: apply le_trans hln
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ l ≤ k
state_after: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ n ≤ k

tactic: exact (mem.1 hk).1
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ n ≤ k
state_after: no goals
Theorem: StarSubalgebra.mem_iInf
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
state_before: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
ι : Sort u_5
S : ι → StarSubalgebra R A
x : A
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
Theorem: CategoryTheory.monoidalOfHasFiniteProducts.associator_inv_fst_fst
File: Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean

tactic: simp [associator_inv]
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y Z : C
⊢ (α_ X Y Z).inv ≫ prod.fst ≫ prod.fst = prod.fst
state_after: no goals
Theorem: Turing.Tape.write_move_right_n
File: Mathlib/Computability/TuringMachine.lean

tactic: induction' n with n IH generalizing L R
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
f : Γ → Γ
L R : ListBlank Γ
n : ℕ
⊢ write (f (R.nth n)) ((move Dir.right)^[n] (mk' L R)) = (move Dir.right)^[n] (mk' L (ListBlank.modifyNth f n R))
state_after: case zero
Γ : Type u_1
inst✝ : Inhabited Γ
f : Γ → Γ
L R : ListBlank Γ
⊢ write (f (R.nth 0)) ((move Dir.right)^[0] (mk' L R)) = (move Dir.right)^[0] (mk' L (ListBlank.modifyNth f 0 R))

case succ
Γ : Type u_1
inst✝ : Inhabited Γ
f : Γ → Γ
n : ℕ
IH :
  ∀ (L R : ListBlank Γ),
    write (f (R.nth n)) ((move Dir.right)^[n] (mk' L R)) = (move Dir.right)^[n] (mk' L (ListBlank.modifyNth f n R))
L R : ListBlank Γ
⊢ write (f (R.nth (n + 1))) ((move Dir.right)^[n + 1] (mk' L R)) =
    (move Dir.right)^[n + 1] (mk' L (ListBlank.modifyNth f (n + 1) R))

tactic: simp only [ListBlank.head_cons, ListBlank.nth_succ, ListBlank.modifyNth, Tape.move_right_mk',
  ListBlank.tail_cons, iterate_succ_apply, IH]
state_before: case succ
Γ : Type u_1
inst✝ : Inhabited Γ
f : Γ → Γ
n : ℕ
IH :
  ∀ (L R : ListBlank Γ),
    write (f (R.nth n)) ((move Dir.right)^[n] (mk' L R)) = (move Dir.right)^[n] (mk' L (ListBlank.modifyNth f n R))
L R : ListBlank Γ
⊢ write (f (R.nth (n + 1))) ((move Dir.right)^[n + 1] (mk' L R)) =
    (move Dir.right)^[n + 1] (mk' L (ListBlank.modifyNth f (n + 1) R))
state_after: no goals

tactic: simp only [ListBlank.nth_zero, ListBlank.modifyNth, iterate_zero_apply, Nat.zero_eq]
state_before: case zero
Γ : Type u_1
inst✝ : Inhabited Γ
f : Γ → Γ
L R : ListBlank Γ
⊢ write (f (R.nth 0)) ((move Dir.right)^[0] (mk' L R)) = (move Dir.right)^[0] (mk' L (ListBlank.modifyNth f 0 R))
state_after: case zero
Γ : Type u_1
inst✝ : Inhabited Γ
f : Γ → Γ
L R : ListBlank Γ
⊢ write (f R.head) (mk' L R) = mk' L (ListBlank.cons (f R.head) R.tail)

tactic: rw [← Tape.write_mk', ListBlank.cons_head_tail]
state_before: case zero
Γ : Type u_1
inst✝ : Inhabited Γ
f : Γ → Γ
L R : ListBlank Γ
⊢ write (f R.head) (mk' L R) = mk' L (ListBlank.cons (f R.head) R.tail)
state_after: no goals