ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddLECancellable.lt_tsub_iff_left_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
⊢ a < b - c ↔ c + a < b
state_after: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
⊢ a < b - c ↔ a + c < b
tactic: rw [add_comm]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
⊢ a < b - c ↔ a + c < b
state_after: no goals
tactic: exact hc.lt_tsub_iff_right_of_le h
Theorem: Set.pi_def
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
π : α → Type u_11
i : Set α
s : (a : α) → Set (π a)
⊢ i.pi s = ⋂ a ∈ i, eval a ⁻¹' s a
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
π : α → Type u_11
i : Set α
s : (a : α) → Set (π a)
x✝ : (i : α) → π i
⊢ x✝ ∈ i.pi s ↔ x✝ ∈ ⋂ a ∈ i, eval a ⁻¹' s a
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
π : α → Type u_11
i : Set α
s : (a : α) → Set (π a)
x✝ : (i : α) → π i
⊢ x✝ ∈ i.pi s ↔ x✝ ∈ ⋂ a ∈ i, eval a ⁻¹' s a
state_after: no goals
tactic: simp
Theorem: cfc_add
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ g✝ : R → R
a : A
ha : autoParam (p a) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a)) _auto✝
hg✝ : autoParam (ContinuousOn g✝ (spectrum R a)) _auto✝
f g : R → R
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
⊢ cfc (fun x => f x + g x) a = cfc f a + cfc g a
state_after: case pos
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ g✝ : R → R
a : A
ha✝ : autoParam (p a) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a)) _auto✝
hg✝ : autoParam (ContinuousOn g✝ (spectrum R a)) _auto✝
f g : R → R
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : p a
⊢ cfc (fun x => f x + g x) a = cfc f a + cfc g a

case neg
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ g✝ : R → R
a : A
ha✝ : autoParam (p a) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a)) _auto✝
hg✝ : autoParam (ContinuousOn g✝ (spectrum R a)) _auto✝
f g : R → R
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : ¬p a
⊢ cfc (fun x => f x + g x) a = cfc f a + cfc g a
tactic: by_cases ha : p a
Theorem: MeasureTheory.Measure.sum_smul_dirac
File: Mathlib/MeasureTheory/Measure/Dirac.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
s : Set α
a : α
inst✝¹ : Countable α
inst✝ : MeasurableSingletonClass α
μ : Measure α
⊢ (sum fun a => μ {a} • dirac a) = μ
state_after: no goals
tactic: simpa using (map_eq_sum μ id measurable_id).symm
Theorem: MeasureTheory.absolutelyContinuous_map_mul_right
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun x => x * g) μ
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
s : Set G
hs : MeasurableSet s
⊢ (map (fun x => x * g) μ) s = 0 → μ s = 0
tactic: refine AbsolutelyContinuous.mk fun s hs => ?_
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
s : Set G
hs : MeasurableSet s
⊢ (map (fun x => x * g) μ) s = 0 → μ s = 0
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
s : Set G
hs : MeasurableSet s
⊢ μ s = 0 → μ s = 0
tactic: rw [map_apply (measurable_mul_const g) hs, measure_mul_right_null]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
s : Set G
hs : MeasurableSet s
⊢ μ s = 0 → μ s = 0
state_after: no goals
tactic: exact id
Theorem: NonUnitalRingHom.range_eq_map
File: Mathlib/RingTheory/NonUnitalSubring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type u_1
inst✝² : NonUnitalNonAssocRing R
inst✝¹ : NonUnitalNonAssocRing S
inst✝ : NonUnitalNonAssocRing T
g : S →ₙ+* T
f✝ f : R →ₙ+* S
⊢ f.range = NonUnitalSubring.map f ⊤
state_after: case h
R : Type u
S : Type v
T : Type u_1
inst✝² : NonUnitalNonAssocRing R
inst✝¹ : NonUnitalNonAssocRing S
inst✝ : NonUnitalNonAssocRing T
g : S →ₙ+* T
f✝ f : R →ₙ+* S
x✝ : S
⊢ x✝ ∈ f.range ↔ x✝ ∈ NonUnitalSubring.map f ⊤
tactic: ext
state_before: case h
R : Type u
S : Type v
T : Type u_1
inst✝² : NonUnitalNonAssocRing R
inst✝¹ : NonUnitalNonAssocRing S
inst✝ : NonUnitalNonAssocRing T
g : S →ₙ+* T
f✝ f : R →ₙ+* S
x✝ : S
⊢ x✝ ∈ f.range ↔ x✝ ∈ NonUnitalSubring.map f ⊤
state_after: no goals
tactic: simp
Theorem: ContextFreeGrammar.Derives.append_left
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
g : ContextFreeGrammar T
v w : List (Symbol T g.NT)
hvw : g.Derives v w
p : List (Symbol T g.NT)
⊢ g.Derives (p ++ v) (p ++ w)
state_after: no goals
tactic: induction hvw with
  | refl => rfl
  | tail _ last ih => exact ih.trans_produces <| last.append_left p
Theorem: Memℓp.neg
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
hf : Memℓp f p
⊢ Memℓp (-f) p
state_after: case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
hf : Memℓp f 0
⊢ Memℓp (-f) 0

case inr.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
hf : Memℓp f ⊤
⊢ Memℓp (-f) ⊤

case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
hf : Memℓp f p
hp : 0 < p.toReal
⊢ Memℓp (-f) p
tactic: rcases p.trichotomy with (rfl | rfl | hp)
Theorem: Multiset.bind_map_comm
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : Multiset β
f : α → β → γ
⊢ (bind 0 fun a => map (fun b => f a b) n) = n.bind fun b => map (fun a => f a b) 0
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : Multiset β
f : α → β → γ
⊢ ∀ (a : α) (s : Multiset α),
    ((s.bind fun a => map (fun b => f a b) n) = n.bind fun b => map (fun a => f a b) s) →
      ((a ::ₘ s).bind fun a => map (fun b => f a b) n) = n.bind fun b => map (fun a => f a b) (a ::ₘ s)
state_after: no goals
tactic: simp (config := { contextual := true })
Theorem: MeasureTheory.measure_toMeasurable
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
⊢ μ (toMeasurable μ s) = μ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
⊢ μ
      (if h : ∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[ae μ] s then h.choose
      else
        if h' : ∃ t ⊇ s, MeasurableSet t ∧ ∀ (u : Set α), MeasurableSet u → μ (t ∩ u) = μ (s ∩ u) then h'.choose
        else ⋯.choose) =
    μ s
tactic: rw [toMeasurable_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
⊢ μ
      (if h : ∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[ae μ] s then h.choose
      else
        if h' : ∃ t ⊇ s, MeasurableSet t ∧ ∀ (u : Set α), MeasurableSet u → μ (t ∩ u) = μ (s ∩ u) then h'.choose
        else ⋯.choose) =
    μ s
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
hs : ∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[ae μ] s
⊢ μ hs.choose = μ s

case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
hs : ¬∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[ae μ] s
h's : ∃ t ⊇ s, MeasurableSet t ∧ ∀ (u : Set α), MeasurableSet u → μ (t ∩ u) = μ (s ∩ u)
⊢ μ h's.choose = μ s

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
hs : ¬∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[ae μ] s
h's : ¬∃ t ⊇ s, MeasurableSet t ∧ ∀ (u : Set α), MeasurableSet u → μ (t ∩ u) = μ (s ∩ u)
⊢ μ ⋯.choose = μ s
tactic: split_ifs with hs h's
Theorem: PartialHomeomorph.ofSet_trans
File: Mathlib/Topology/PartialHomeomorph.lean

Proof steps:
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
e' : PartialHomeomorph Y Z
s : Set X
hs : IsOpen s
⊢ ((ofSet s hs).trans e).source = (e.restr s).source
state_after: no goals
tactic: simp [hs.interior_eq, inter_comm]
Theorem: Fin.card_Iio
File: Mathlib/Order/Interval/Finset/Fin.lean

Proof steps:
state_before: n : ℕ
a b : Fin n
⊢ (Iio b).card = ↑b
state_after: no goals
tactic: rw [← Nat.card_Iio b, ← map_valEmbedding_Iio, card_map]
Theorem: TensorProduct.exists_eq_tmul_of_forall
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type u_2
inst✝¹⁷ : Monoid R'
R'' : Type u_3
inst✝¹⁶ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : AddCommMonoid T
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module R P
inst✝⁶ : Module R Q
inst✝⁵ : Module R S
inst✝⁴ : Module R T
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
x : M ⊗[R] N
h : ∀ (m₁ m₂ : M) (n₁ n₂ : N), ∃ m n, m₁ ⊗ₜ[R] n₁ + m₂ ⊗ₜ[R] n₂ = m ⊗ₜ[R] n
⊢ ∃ m n, x = m ⊗ₜ[R] n
state_after: no goals
tactic: induction x with
  | zero =>
    use 0, 0
    rw [TensorProduct.zero_tmul]
  | tmul m n => use m, n
  | add x y h₁ h₂ =>
    obtain ⟨m₁, n₁, rfl⟩ := h₁
    obtain ⟨m₂, n₂, rfl⟩ := h₂
    apply h
Theorem: Inducing.hasProd_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : CommMonoid α
inst✝⁴ : TopologicalSpace α
f✝ g✝ : β → α
a✝ b : α
s : Finset β
inst✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Inducing ⇑g
f : β → α
a : α
⊢ HasProd (⇑g ∘ f) (g a) ↔ HasProd f a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : CommMonoid α
inst✝⁴ : TopologicalSpace α
f✝ g✝ : β → α
a✝ b : α
s : Finset β
inst✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Inducing ⇑g
f : β → α
a : α
⊢ Tendsto (fun s => g (∏ x ∈ s, f x)) atTop (𝓝 (g a)) ↔ Tendsto (fun s => ∏ x ∈ s, f x) atTop (𝓝 a)
tactic: simp_rw [HasProd, comp_apply, ← map_prod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : CommMonoid α
inst✝⁴ : TopologicalSpace α
f✝ g✝ : β → α
a✝ b : α
s : Finset β
inst✝³ : CommMonoid γ
inst✝² : TopologicalSpace γ
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Inducing ⇑g
f : β → α
a : α
⊢ Tendsto (fun s => g (∏ x ∈ s, f x)) atTop (𝓝 (g a)) ↔ Tendsto (fun s => ∏ x ∈ s, f x) atTop (𝓝 a)
state_after: no goals
tactic: exact hg.tendsto_nhds_iff.symm
Theorem: LSeriesHasSum.sub
File: Mathlib/NumberTheory/LSeries/Linearity.lean

Proof steps:
state_before: f g : ℕ → ℂ
s a b : ℂ
hf : LSeriesHasSum f s a
hg : LSeriesHasSum g s b
⊢ LSeriesHasSum (f - g) s (a - b)
state_after: no goals
tactic: simpa only [LSeriesHasSum, term_sub] using HasSum.sub hf hg
Theorem: Submodule.nontrivial_iff_ne_bot
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
⊢ Nontrivial ↥p ↔ p ≠ ⊥
state_after: no goals
tactic: rw [iff_not_comm, not_nontrivial_iff_subsingleton, subsingleton_iff_eq_bot]
Theorem: HasFPowerSeriesOnBall.comp_sub
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y z : E
hz : z ∈ EMetric.ball 0 r
⊢ HasSum (fun n => (p n) fun x => z) (f (x + y + z - y))
state_after: case h.e'_6.h.e'_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y z : E
hz : z ∈ EMetric.ball 0 r
⊢ x + y + z - y = x + z
tactic: convert hf.hasSum hz using 2
state_before: case h.e'_6.h.e'_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y z : E
hz : z ∈ EMetric.ball 0 r
⊢ x + y + z - y = x + z
state_after: no goals
tactic: abel
Theorem: Real.log_two_gt_d9
File: Mathlib/Data/Complex/ExponentialBounds.lean

Proof steps:
state_before: ⊢ 0.6931471803 < 287209 / 414355 - 1 / 10 ^ 10
state_after: no goals
tactic: norm_num1
Theorem: Int.natAbs_eq_iff_sq_eq
File: Mathlib/Data/Int/Lemmas.lean

Proof steps:
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ a.natAbs = b.natAbs ↔ a ^ 2 = b ^ 2
state_after: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ a.natAbs = b.natAbs ↔ a * a = b * b
tactic: rw [sq, sq]
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ a.natAbs = b.natAbs ↔ a * a = b * b
state_after: no goals
tactic: exact natAbs_eq_iff_mul_self_eq
Theorem: IsIntegralClosure.mk'_mul
File: Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsIntegralClosure A R B
x y : B
hx : IsIntegral R x
hy : IsIntegral R y
⊢ (algebraMap A B) (mk' A (x * y) ⋯) = (algebraMap A B) (mk' A x hx * mk' A y hy)
state_after: no goals
tactic: simp only [algebraMap_mk', RingHom.map_mul]
Theorem: MeasureTheory.Memℒp.evariance_lt_top
File: Mathlib/Probability/Variance.lean

Proof steps:
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ evariance X μ < ⊤
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
this : eLpNorm (X - fun x => ∫ (x : Ω), X x ∂μ) 2 μ ^ 2 < ⊤
⊢ evariance X μ < ⊤
tactic: have := ENNReal.pow_lt_top (hX.sub <| memℒp_const <| μ[X]).2 2
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
this : eLpNorm (X - fun x => ∫ (x : Ω), X x ∂μ) 2 μ ^ 2 < ⊤
⊢ evariance X μ < ⊤
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
this : ((∫⁻ (x : Ω), ↑‖(X - fun x => ∫ (x : Ω), X x ∂μ) x‖₊ ^ ENNReal.toReal 2 ∂μ) ^ (1 / ENNReal.toReal 2)) ^ 2 < ⊤
⊢ evariance X μ < ⊤
tactic: rw [eLpNorm_eq_lintegral_rpow_nnnorm two_ne_zero ENNReal.two_ne_top, ← ENNReal.rpow_two] at this
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
this : ((∫⁻ (x : Ω), ↑‖(X - fun x => ∫ (x : Ω), X x ∂μ) x‖₊ ^ ENNReal.toReal 2 ∂μ) ^ (1 / ENNReal.toReal 2)) ^ 2 < ⊤
⊢ evariance X μ < ⊤
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
this : ((∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ 2 ∂μ) ^ 2⁻¹) ^ 2 < ⊤
⊢ evariance X μ < ⊤
tactic: simp only [ENNReal.toReal_ofNat, Pi.sub_apply, ENNReal.one_toReal, one_div] at this
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
this : ((∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ 2 ∂μ) ^ 2⁻¹) ^ 2 < ⊤
⊢ evariance X μ < ⊤
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
this : ∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ 2 ∂μ < ⊤
⊢ evariance X μ < ⊤
tactic: rw [← ENNReal.rpow_mul, inv_mul_cancel (two_ne_zero : (2 : ℝ) ≠ 0), ENNReal.rpow_one] at this
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
this : ∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ 2 ∂μ < ⊤
⊢ evariance X μ < ⊤
state_after: no goals
tactic: exact this
Theorem: CategoryTheory.Limits.biproduct.matrix_map
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J K : Type
inst✝² : Finite J
f✝ : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Finite K
f : J → C
g h : K → C
m : (j : J) → (k : K) → f j ⟶ g k
n : (k : K) → g k ⟶ h k
⊢ matrix m ≫ map n = matrix fun j k => m j k ≫ n k
state_after: case w.w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J K : Type
inst✝² : Finite J
f✝ : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Finite K
f : J → C
g h : K → C
m : (j : J) → (k : K) → f j ⟶ g k
n : (k : K) → g k ⟶ h k
j✝¹ : K
j✝ : J
⊢ ι f j✝ ≫ (matrix m ≫ map n) ≫ π h j✝¹ = ι f j✝ ≫ (matrix fun j k => m j k ≫ n k) ≫ π h j✝¹
tactic: ext
state_before: case w.w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J K : Type
inst✝² : Finite J
f✝ : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Finite K
f : J → C
g h : K → C
m : (j : J) → (k : K) → f j ⟶ g k
n : (k : K) → g k ⟶ h k
j✝¹ : K
j✝ : J
⊢ ι f j✝ ≫ (matrix m ≫ map n) ≫ π h j✝¹ = ι f j✝ ≫ (matrix fun j k => m j k ≫ n k) ≫ π h j✝¹
state_after: no goals
tactic: simp
Theorem: Metric.eventually_isCompact_closedBall
File: Mathlib/Topology/MetricSpace/Pseudo/Lemmas.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, IsCompact (closedBall x r)
state_after: case intro.intro
ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
s : Set α
s_compact : IsCompact s
hs : s ∈ 𝓝 x
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, IsCompact (closedBall x r)
tactic: rcases exists_compact_mem_nhds x with ⟨s, s_compact, hs⟩
state_before: case intro.intro
ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
s : Set α
s_compact : IsCompact s
hs : s ∈ 𝓝 x
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, IsCompact (closedBall x r)
state_after: case h
ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
s : Set α
s_compact : IsCompact s
hs : s ∈ 𝓝 x
r : ℝ
hr : closedBall x r ⊆ s
⊢ IsCompact (closedBall x r)
tactic: filter_upwards [eventually_closedBall_subset hs] with r hr
state_before: case h
ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
s : Set α
s_compact : IsCompact s
hs : s ∈ 𝓝 x
r : ℝ
hr : closedBall x r ⊆ s
⊢ IsCompact (closedBall x r)
state_after: no goals
tactic: exact IsCompact.of_isClosed_subset s_compact isClosed_ball hr