1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MonoidAlgebra.mem_closure_of_mem_span_closure
File: Mathlib/RingTheory/FiniteType.lean

tactic: rw [← MonoidHom.map_mclosure] 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 ↑(closure (⇑(of R M) '' S))
⊢ m ∈ closure 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 ↑(Submonoid.map (of R M) (closure S))
⊢ m ∈ closure S

tactic: simpa using of_mem_span_of_iff.1 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 ↑(Submonoid.map (of R M) (closure S))
⊢ m ∈ closure S
state_after: no goals
Theorem: Bundle.TotalSpace.mk_cast
File: Mathlib/Data/Bundle.lean

tactic: subst h
state_before: B : Type u_1
F : Type u_2
E : B → Type u_3
x x' : B
h : x = x'
b : E x
⊢ mk' F x' (cast ⋯ b) = { proj := x, snd := b }
state_after: B : Type u_1
F : Type u_2
E : B → Type u_3
x : B
b : E x
⊢ mk' F x (cast ⋯ b) = { proj := x, snd := b }

tactic: rfl
state_before: B : Type u_1
F : Type u_2
E : B → Type u_3
x : B
b : E x
⊢ mk' F x (cast ⋯ b) = { proj := x, snd := b }
state_after: no goals
Theorem: QuaternionGroup.card
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: rw [← Fintype.card_eq.mpr ⟨fintypeHelper⟩, Fintype.card_sum, ZMod.card, two_mul]
state_before: n : ℕ
inst✝ : NeZero n
⊢ Fintype.card (QuaternionGroup n) = 4 * n
state_after: n : ℕ
inst✝ : NeZero n
⊢ n + n + (n + n) = 4 * n

tactic: ring
state_before: n : ℕ
inst✝ : NeZero n
⊢ n + n + (n + n) = 4 * n
state_after: no goals
Theorem: OnePoint.isClosed_iff_of_mem
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: have : ∞ ∉ sᶜ := fun H => H h
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ∞ ∈ s
⊢ IsClosed s ↔ IsClosed (some ⁻¹' s)
state_after: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ∞ ∈ s
this : ∞ ∉ sᶜ
⊢ IsClosed s ↔ IsClosed (some ⁻¹' s)

tactic: rw [← isOpen_compl_iff, isOpen_iff_of_not_mem this, ← isOpen_compl_iff, preimage_compl]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ∞ ∈ s
this : ∞ ∉ sᶜ
⊢ IsClosed s ↔ IsClosed (some ⁻¹' s)
state_after: no goals
Theorem: Rat.intCast_inj
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: constructor
state_before: a b : Int
⊢ ↑a = ↑b ↔ a = b
state_after: case mp
a b : Int
⊢ ↑a = ↑b → a = b

case mpr
a b : Int
⊢ a = b → ↑a = ↑b

tactic: rintro ⟨⟩
state_before: case mp
a b : Int
⊢ ↑a = ↑b → a = b
state_after: case mp.refl
a : Int
⊢ a = a

tactic: rfl
state_before: case mp.refl
a : Int
⊢ a = a
state_after: no goals

tactic: simp_all
state_before: case mpr
a b : Int
⊢ a = b → ↑a = ↑b
state_after: no goals
Theorem: IsLocalMin.hasDerivAt_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr/Basic.lean

tactic: simpa using DFunLike.congr_fun (h.hasFDerivAt_eq_zero (hasDerivAt_iff_hasFDerivAt.1 hf)) 1
state_before: f : ℝ → ℝ
f' a b : ℝ
h : IsLocalMin f a
hf : HasDerivAt f f' a
⊢ f' = 0
state_after: no goals
Theorem: AlgHom.map_algebraMap
File: Mathlib/Algebra/Algebra/Tower.lean

tactic: rw [algebraMap_apply R S A r, f.commutes, ← algebraMap_apply R S B]
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra S A
inst✝⁴ : Algebra S B
inst✝³ : Algebra R A
inst✝² : Algebra R B
inst✝¹ : IsScalarTower R S A
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
r : R
⊢ f ((algebraMap R A) r) = (algebraMap R B) r
state_after: no goals
Theorem: PEquiv.toMatrix_swap
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: ext
state_before: k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝¹ : DecidableEq n
inst✝ : Ring α
i j : n
⊢ (Equiv.toPEquiv (Equiv.swap i j)).toMatrix =
    1 - (single i i).toMatrix - (single j j).toMatrix + (single i j).toMatrix + (single j i).toMatrix
state_after: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝¹ : DecidableEq n
inst✝ : Ring α
i j i✝ j✝ : n
⊢ (Equiv.toPEquiv (Equiv.swap i j)).toMatrix i✝ j✝ =
    (1 - (single i i).toMatrix - (single j j).toMatrix + (single i j).toMatrix + (single j i).toMatrix) i✝ j✝

tactic: dsimp [toMatrix, single, Equiv.swap_apply_def, Equiv.toPEquiv, one_apply]
state_before: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝¹ : DecidableEq n
inst✝ : Ring α
i j i✝ j✝ : n
⊢ (Equiv.toPEquiv (Equiv.swap i j)).toMatrix i✝ j✝ =
    (1 - (single i i).toMatrix - (single j j).toMatrix + (single i j).toMatrix + (single j i).toMatrix) i✝ j✝
state_after: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝¹ : DecidableEq n
inst✝ : Ring α
i j i✝ j✝ : n
⊢ (if j✝ ∈ some (if i✝ = i then j else if i✝ = j then i else i✝) then 1 else 0) =
    ((((if i✝ = j✝ then 1 else 0) - if j✝ ∈ if i✝ = i then some i else none then 1 else 0) -
          if j✝ ∈ if i✝ = j then some j else none then 1 else 0) +
        if j✝ ∈ if i✝ = i then some j else none then 1 else 0) +
      if j✝ ∈ if i✝ = j then some i else none then 1 else 0

tactic: split_ifs <;> simp_all
state_before: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝¹ : DecidableEq n
inst✝ : Ring α
i j i✝ j✝ : n
⊢ (if j✝ ∈ some (if i✝ = i then j else if i✝ = j then i else i✝) then 1 else 0) =
    ((((if i✝ = j✝ then 1 else 0) - if j✝ ∈ if i✝ = i then some i else none then 1 else 0) -
          if j✝ ∈ if i✝ = j then some j else none then 1 else 0) +
        if j✝ ∈ if i✝ = i then some j else none then 1 else 0) +
      if j✝ ∈ if i✝ = j then some i else none then 1 else 0
state_after: no goals
Theorem: Filter.mem_of_eq_bot
File: Mathlib/Order/Filter/Basic.lean

tactic: rwa [inf_principal_eq_bot, compl_compl] at h
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : Filter α
s : Set α
h : f ⊓ 𝓟 sᶜ = ⊥
⊢ s ∈ f
state_after: no goals
Theorem: ExistsUnique.elim₂
File: Mathlib/Logic/Basic.lean

tactic: simp only [exists_unique_iff_exists] at h₂
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q✝ : α✝ → Prop
α : Sort u_3
p : α → Sort u_4
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
b : Prop
h₂ : ∃! x, ∃! h, q x h
h₁ : ∀ (x : α) (h : p x), q x h → (∀ (y : α) (hy : p y), q y hy → y = x) → b
⊢ b
state_after: α✝ : Sort u_1
β : Sort u_2
p✝ q✝ : α✝ → Prop
α : Sort u_3
p : α → Sort u_4
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
b : Prop
h₁ : ∀ (x : α) (h : p x), q x h → (∀ (y : α) (hy : p y), q y hy → y = x) → b
h₂ : ∃! x, ∃ h, q x h
⊢ b

tactic: apply h₂.elim
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q✝ : α✝ → Prop
α : Sort u_3
p : α → Sort u_4
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
b : Prop
h₁ : ∀ (x : α) (h : p x), q x h → (∀ (y : α) (hy : p y), q y hy → y = x) → b
h₂ : ∃! x, ∃ h, q x h
⊢ b
state_after: α✝ : Sort u_1
β : Sort u_2
p✝ q✝ : α✝ → Prop
α : Sort u_3
p : α → Sort u_4
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
b : Prop
h₁ : ∀ (x : α) (h : p x), q x h → (∀ (y : α) (hy : p y), q y hy → y = x) → b
h₂ : ∃! x, ∃ h, q x h
⊢ ∀ (x : α), (∃ h, q x h) → (∀ (y : α), (∃ h, q y h) → y = x) → b

tactic: exact fun x ⟨hxp, hxq⟩ H ↦ h₁ x hxp hxq fun y hyp hyq ↦ H y ⟨hyp, hyq⟩
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q✝ : α✝ → Prop
α : Sort u_3
p : α → Sort u_4
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
b : Prop
h₁ : ∀ (x : α) (h : p x), q x h → (∀ (y : α) (hy : p y), q y hy → y = x) → b
h₂ : ∃! x, ∃ h, q x h
⊢ ∀ (x : α), (∃ h, q x h) → (∀ (y : α), (∃ h, q y h) → y = x) → b
state_after: no goals
Theorem: HasFPowerSeriesAt.locally_zero_iff
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

tactic: rwa [h] at hp
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hp : HasFPowerSeriesAt f p z₀
h : p = 0
⊢ HasFPowerSeriesAt f 0 z₀
state_after: no goals
Theorem: ZetaAsymptotics.term_welldef
File: Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean

tactic: rw [intervalIntegrable_iff_integrableOn_Icc_of_le (by linarith)]
state_before: n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
⊢ IntervalIntegrable (fun x => (x - ↑n) / x ^ (s + 1)) volume (↑n) (↑n + 1)
state_after: n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
⊢ IntegrableOn (fun x => (x - ↑n) / x ^ (s + 1)) (Icc (↑n) (↑n + 1)) volume

tactic: refine (ContinuousAt.continuousOn fun x hx ↦ ContinuousAt.div ?_ ?_ ?_).integrableOn_Icc
state_before: n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
⊢ IntegrableOn (fun x => (x - ↑n) / x ^ (s + 1)) (Icc (↑n) (↑n + 1)) volume
state_after: case refine_1
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ ContinuousAt (fun x => x - ↑n) x

case refine_2
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ ContinuousAt (fun x => x ^ (s + 1)) x

case refine_3
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ x ^ (s + 1) ≠ 0

tactic: linarith
state_before: n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
⊢ ↑n ≤ ↑n + 1
state_after: no goals

tactic: fun_prop
state_before: case refine_1
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ ContinuousAt (fun x => x - ↑n) x
state_after: no goals

tactic: apply continuousAt_id.rpow_const (Or.inr <| by linarith)
state_before: case refine_2
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ ContinuousAt (fun x => x ^ (s + 1)) x
state_after: no goals

tactic: linarith
state_before: n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ 0 ≤ s + 1
state_after: no goals

tactic: exact (rpow_pos_of_pos ((Nat.cast_pos.mpr hn).trans_le hx.1) _).ne'
state_before: case refine_3
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ x ^ (s + 1) ≠ 0
state_after: no goals
Theorem: IsGroupHom.preimage
File: Mathlib/Deprecated/Subgroup.lean

tactic: simp [hf.map_one, hs.one_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsSubgroup s
⊢ 1 ∈ f ⁻¹' s
state_after: no goals

tactic: simp_all [hf.map_mul, hs.mul_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsSubgroup s
⊢ ∀ {a b : G}, a ∈ f ⁻¹' s → b ∈ f ⁻¹' s → a * b ∈ f ⁻¹' s
state_after: no goals

tactic: simp_all [hf.map_inv]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsSubgroup s
⊢ ∀ {a : G}, a ∈ f ⁻¹' s → a⁻¹ ∈ f ⁻¹' s
state_after: no goals
Theorem: Real.cauchy_add
File: Mathlib/Data/Real/Basic.lean

tactic: rw [add_def]
state_before: x y : ℝ
a b : Cauchy abs
⊢ (Real.add { cauchy := a } { cauchy := b }).cauchy = { cauchy := a }.cauchy + { cauchy := b }.cauchy
state_after: no goals
Theorem: TorusIntegrable.torusIntegrable_zero_radius
File: Mathlib/MeasureTheory/Integral/TorusIntegral.lean

tactic: rw [TorusIntegrable, torusMap_zero_radius]
state_before: n : ℕ
E : Type u_1
inst✝ : NormedAddCommGroup E
f✝ g : (Fin n → ℂ) → E
c✝ : Fin n → ℂ
R : Fin n → ℝ
f : (Fin n → ℂ) → E
c : Fin n → ℂ
⊢ TorusIntegrable f c 0
state_after: n : ℕ
E : Type u_1
inst✝ : NormedAddCommGroup E
f✝ g : (Fin n → ℂ) → E
c✝ : Fin n → ℂ
R : Fin n → ℝ
f : (Fin n → ℂ) → E
c : Fin n → ℂ
⊢ IntegrableOn (fun θ => f (const (Fin n → ℝ) c θ)) (Icc 0 fun x => 2 * π) volume

tactic: apply torusIntegrable_const (f c) c 0
state_before: n : ℕ
E : Type u_1
inst✝ : NormedAddCommGroup E
f✝ g : (Fin n → ℂ) → E
c✝ : Fin n → ℂ
R : Fin n → ℝ
f : (Fin n → ℂ) → E
c : Fin n → ℂ
⊢ IntegrableOn (fun θ => f (const (Fin n → ℝ) c θ)) (Icc 0 fun x => 2 * π) volume
state_after: no goals
Theorem: Polynomial.ofFinsupp_erase
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q : R[X]
p : R[ℕ]
n : ℕ
⊢ { toFinsupp := Finsupp.erase n p } = erase n { toFinsupp := p }
state_after: case mk
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
support✝ : Finset ℕ
toFun✝ : ℕ → R
mem_support_toFun✝ : ∀ (a : ℕ), a ∈ support✝ ↔ toFun✝ a ≠ 0
⊢ { toFinsupp := Finsupp.erase n { support := support✝, toFun := toFun✝, mem_support_toFun := mem_support_toFun✝ } } =
    erase n { toFinsupp := { support := support✝, toFun := toFun✝, mem_support_toFun := mem_support_toFun✝ } }

tactic: simp only [erase_def]
state_before: case mk
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
support✝ : Finset ℕ
toFun✝ : ℕ → R
mem_support_toFun✝ : ∀ (a : ℕ), a ∈ support✝ ↔ toFun✝ a ≠ 0
⊢ { toFinsupp := Finsupp.erase n { support := support✝, toFun := toFun✝, mem_support_toFun := mem_support_toFun✝ } } =
    erase n { toFinsupp := { support := support✝, toFun := toFun✝, mem_support_toFun := mem_support_toFun✝ } }
state_after: no goals
Theorem: Matrix.PosSemidef.submatrix
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

tactic: classical
rw [(by simp : M = 1 * M * 1), submatrix_mul (he₂ := Function.bijective_id),
  submatrix_mul (he₂ := Function.bijective_id), submatrix_id_id]
simpa only [conjTranspose_submatrix, conjTranspose_one] using
  conjTranspose_mul_mul_same hM (Matrix.submatrix 1 id e)
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosSemidef
e : m → n
⊢ (M.submatrix e e).PosSemidef
state_after: no goals

tactic: rw [(by simp : M = 1 * M * 1), submatrix_mul (he₂ := Function.bijective_id),
  submatrix_mul (he₂ := Function.bijective_id), submatrix_id_id]
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosSemidef
e : m → n
⊢ (M.submatrix e e).PosSemidef
state_after: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosSemidef
e : m → n
⊢ (Matrix.submatrix 1 e id * M * Matrix.submatrix 1 id e).PosSemidef

tactic: simpa only [conjTranspose_submatrix, conjTranspose_one] using
  conjTranspose_mul_mul_same hM (Matrix.submatrix 1 id e)
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosSemidef
e : m → n
⊢ (Matrix.submatrix 1 e id * M * Matrix.submatrix 1 id e).PosSemidef
state_after: no goals

tactic: simp
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosSemidef
e : m → n
⊢ M = 1 * M * 1
state_after: no goals
Theorem: Complex.volume_closedBall
File: Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean

tactic: rw [addHaar_closedBall_eq_addHaar_ball, Complex.volume_ball]
state_before: a : ℂ
r : ℝ
⊢ volume (Metric.closedBall a r) = ENNReal.ofReal r ^ 2 * ↑NNReal.pi
state_after: no goals
Theorem: mellin_cpow_smul
File: Mathlib/Analysis/MellinTransform.lean

tactic: refine setIntegral_congr measurableSet_Ioi fun t ht => ?_
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s a : ℂ
⊢ mellin (fun t => ↑t ^ a • f t) s = mellin f (s + a)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s a : ℂ
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑t ^ (s - 1) • (fun t => ↑t ^ a • f t) t = ↑t ^ (s + a - 1) • f t

tactic: simp_rw [← sub_add_eq_add_sub, cpow_add _ _ (ofReal_ne_zero.2 <| ne_of_gt ht), mul_smul]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s a : ℂ
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑t ^ (s - 1) • (fun t => ↑t ^ a • f t) t = ↑t ^ (s + a - 1) • f t
state_after: no goals
Theorem: Polynomial.natDegree_add_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: cases' le_max_iff.1 (degree_add_le p q) with h h <;> simp [natDegree_le_natDegree h]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
⊢ (p + q).natDegree ≤ max p.natDegree q.natDegree
state_after: no goals
Theorem: LinearMap.BilinForm.apply_dualBasis_left
File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

tactic: have := FiniteDimensional.of_fintype_basis b
state_before: R : Type u_1
M : Type u_2
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : CommRing R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝¹¹ : Field K
inst✝¹⁰ : AddCommGroup V
inst✝⁹ : Module K V
M'✝ : Type u_7
M'' : Type u_8
inst✝⁸ : AddCommMonoid M'✝
inst✝⁷ : AddCommMonoid M''
inst✝⁶ : Module R M'✝
inst✝⁵ : Module R M''
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_9
inst✝⁴ : AddCommMonoid M'
inst✝³ : Module R M'
inst✝² : FiniteDimensional K V
ι : Type u_10
inst✝¹ : DecidableEq ι
inst✝ : Finite ι
B : BilinForm K V
hB : B.Nondegenerate
b : Basis ι K V
i j : ι
⊢ (B ((B.dualBasis hB b) i)) (b j) = if j = i then 1 else 0
state_after: R : Type u_1
M : Type u_2
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : CommRing R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝¹¹ : Field K
inst✝¹⁰ : AddCommGroup V
inst✝⁹ : Module K V
M'✝ : Type u_7
M'' : Type u_8
inst✝⁸ : AddCommMonoid M'✝
inst✝⁷ : AddCommMonoid M''
inst✝⁶ : Module R M'✝
inst✝⁵ : Module R M''
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_9
inst✝⁴ : AddCommMonoid M'
inst✝³ : Module R M'
inst✝² : FiniteDimensional K V
ι : Type u_10
inst✝¹ : DecidableEq ι
inst✝ : Finite ι
B : BilinForm K V
hB : B.Nondegenerate
b : Basis ι K V
i j : ι
this : FiniteDimensional K V
⊢ (B ((B.dualBasis hB b) i)) (b j) = if j = i then 1 else 0

tactic: rw [dualBasis, Basis.map_apply, Basis.coe_dualBasis, ← toDual_def hB,
  LinearEquiv.apply_symm_apply, Basis.coord_apply, Basis.repr_self, Finsupp.single_apply]
state_before: R : Type u_1
M : Type u_2
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : CommRing R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝¹¹ : Field K
inst✝¹⁰ : AddCommGroup V
inst✝⁹ : Module K V
M'✝ : Type u_7
M'' : Type u_8
inst✝⁸ : AddCommMonoid M'✝
inst✝⁷ : AddCommMonoid M''
inst✝⁶ : Module R M'✝
inst✝⁵ : Module R M''
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_9
inst✝⁴ : AddCommMonoid M'
inst✝³ : Module R M'
inst✝² : FiniteDimensional K V
ι : Type u_10
inst✝¹ : DecidableEq ι
inst✝ : Finite ι
B : BilinForm K V
hB : B.Nondegenerate
b : Basis ι K V
i j : ι
this : FiniteDimensional K V
⊢ (B ((B.dualBasis hB b) i)) (b j) = if j = i then 1 else 0
state_after: no goals
Theorem: NormedAddGroupHom.le_opNorm_of_le
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: gcongr
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
c : ℝ
x : V₁
h : ‖x‖ ≤ c
⊢ ‖f‖ * ‖x‖ ≤ ‖f‖ * c
state_after: case a0
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
c : ℝ
x : V₁
h : ‖x‖ ≤ c
⊢ 0 ≤ ‖f‖

tactic: exact f.opNorm_nonneg
state_before: case a0
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
c : ℝ
x : V₁
h : ‖x‖ ≤ c
⊢ 0 ≤ ‖f‖
state_after: no goals
Theorem: MeasureTheory.setIntegral_condexpIndSMul
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean

tactic: rw [setIntegral_condexpL2_indicator hs ht hμs hμt]
state_before: α : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹⁹ : RCLike 𝕜
inst✝¹⁸ : NormedAddCommGroup E
inst✝¹⁷ : InnerProductSpace 𝕜 E
inst✝¹⁶ : CompleteSpace E
inst✝¹⁵ : NormedAddCommGroup E'
inst✝¹⁴ : InnerProductSpace 𝕜 E'
inst✝¹³ : CompleteSpace E'
inst✝¹² : NormedSpace ℝ E'
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup G'
inst✝⁷ : NormedSpace ℝ G'
inst✝⁶ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
E'' : Type u_8
𝕜' : Type u_9
inst✝⁵ : RCLike 𝕜'
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : InnerProductSpace 𝕜' E''
inst✝² : CompleteSpace E''
inst✝¹ : NormedSpace ℝ E''
inst✝ : NormedSpace ℝ G
hm : m ≤ m0
hs : MeasurableSet s
ht : MeasurableSet t
hμs : μ s ≠ ⊤
hμt : μ t ≠ ⊤
x : G'
⊢ (∫ (a : α) in s, ↑↑↑((condexpL2 ℝ ℝ hm) (indicatorConstLp 2 ht hμt 1)) a ∂μ) • x = (μ (t ∩ s)).toReal • x
state_after: no goals
Theorem: LocalizedModule.liftOn₂_mk
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: convert Quotient.liftOn₂_mk f wd _ _
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
α : Type u_2
f : M × ↥S → M × ↥S → α
wd : ∀ (p q p' q' : M × ↥S), p ≈ p' → q ≈ q' → f p q = f p' q'
m m' : M
s s' : ↥S
⊢ (mk m s).liftOn₂ (mk m' s') f wd = f (m, s) (m', s')
state_after: no goals
Theorem: Submonoid.closure_eq_image_prod
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: rw [closure_eq_mrange, coe_mrange, ← Set.range_list_map_coe, ← Set.range_comp]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
s : Set M
⊢ ↑(closure s) = List.prod '' {l | ∀ x ∈ l, x ∈ s}
state_after: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
s : Set M
⊢ Set.range ⇑(FreeMonoid.lift Subtype.val) = Set.range (List.prod ∘ List.map Subtype.val)

tactic: exact congrArg _ (funext <| FreeMonoid.lift_apply _)
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
s : Set M
⊢ Set.range ⇑(FreeMonoid.lift Subtype.val) = Set.range (List.prod ∘ List.map Subtype.val)
state_after: no goals
Theorem: CategoryTheory.NonPreadditiveAbelian.neg_sub
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: conv_lhs => rw [neg_def, ← sub_zero b, sub_sub_sub, sub_zero, ← neg_def]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ -a - b = -b - a
state_after: no goals
Theorem: inf_mul_sup
File: Mathlib/Algebra/Order/Group/Lattice.lean

tactic: rw [mul_sup b⁻¹ a⁻¹ (a * b), mul_inv_cancel_right, mul_inv_cancel_comm]
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a ⊓ b) * (a ⊔ b) = (a ⊓ b) * (a * b * (b⁻¹ ⊔ a⁻¹))
state_after: no goals

tactic: rw [inv_inf, sup_comm]
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a ⊓ b) * (a * b * (b⁻¹ ⊔ a⁻¹)) = (a ⊓ b) * (a * b * (a ⊓ b)⁻¹)
state_after: no goals

tactic: rw [mul_comm, inv_mul_cancel_right]
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a ⊓ b) * (a * b * (a ⊓ b)⁻¹) = a * b
state_after: no goals