1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: gauge_closure_zero
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: simp only [← singleton_zero, gauge_def', mem_closure_zero_iff_norm, norm_smul, mul_eq_zero,
  norm_eq_zero, inv_eq_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
⊢ gauge (closure 0) x = 0 x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = 0 x

tactic: rcases (norm_nonneg x).eq_or_gt with hx | hx
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = 0 x
state_after: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
hx : ‖x‖ = 0
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = 0 x

case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
hx : 0 < ‖x‖
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = 0 x

tactic: convert csInf_Ioi (a := (0 : ℝ))
state_before: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
hx : ‖x‖ = 0
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = 0 x
state_after: case h.e'_2.h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
hx : ‖x‖ = 0
⊢ {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = Ioi 0

tactic: exact Set.ext fun r ↦ and_iff_left (.inr hx)
state_before: case h.e'_2.h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
hx : ‖x‖ = 0
⊢ {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = Ioi 0
state_after: no goals

tactic: convert Real.sInf_empty
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
hx : 0 < ‖x‖
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = 0 x
state_after: case h.e'_2.h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
hx : 0 < ‖x‖
⊢ {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = ∅

tactic: exact eq_empty_of_forall_not_mem fun r ⟨hr₀, hr⟩ ↦ hx.ne' <| hr.resolve_left hr₀.out.ne'
state_before: case h.e'_2.h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ x : E
hx : 0 < ‖x‖
⊢ {r | r ∈ Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} = ∅
state_after: no goals
Theorem: Finset.prod_univ_sum
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: simp only [prod_attach_univ, prod_sum, Finset.sum_univ_pi]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
s s₁ s₂ : Finset ι
i : ι
a : α
f✝ g : ι → α
inst✝² : CommSemiring α
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
⊢ ∏ i : ι, ∑ j ∈ t i, f i j = ∑ x ∈ piFinset t, ∏ i : ι, f i (x i)
state_after: no goals
Theorem: Subgroup.IsComplement.equiv_snd_eq_self_of_mem_of_one_mem
File: Mathlib/GroupTheory/Complement.lean

tactic: have : hST.equiv.symm (⟨1, h1⟩, ⟨g, hg⟩) = g := by
  rw [equiv, Equiv.ofBijective]; simp
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
⊢ (hST.equiv g).2 = ⟨g, hg⟩
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
this : hST.equiv.symm (⟨1, h1⟩, ⟨g, hg⟩) = g
⊢ (hST.equiv g).2 = ⟨g, hg⟩

tactic: conv_lhs => rw [← this, Equiv.apply_symm_apply]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
this : hST.equiv.symm (⟨1, h1⟩, ⟨g, hg⟩) = g
⊢ (hST.equiv g).2 = ⟨g, hg⟩
state_after: no goals

tactic: rw [equiv, Equiv.ofBijective]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
⊢ hST.equiv.symm (⟨1, h1⟩, ⟨g, hg⟩) = g
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
⊢ { toFun := fun x => ↑x.1 * ↑x.2, invFun := Function.surjInv ⋯, left_inv := ⋯, right_inv := ⋯ }.symm.symm
      (⟨1, h1⟩, ⟨g, hg⟩) =
    g

tactic: simp
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
⊢ { toFun := fun x => ↑x.1 * ↑x.2, invFun := Function.surjInv ⋯, left_inv := ⋯, right_inv := ⋯ }.symm.symm
      (⟨1, h1⟩, ⟨g, hg⟩) =
    g
state_after: no goals
Theorem: isBigO_rpow_top_log_smul
File: Mathlib/Analysis/MellinTransform.lean

tactic: refine
  ((isLittleO_log_rpow_atTop (sub_pos.mpr hab)).isBigO.smul hf).congr'
    (eventually_of_forall fun t => by rfl)
    ((eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_))
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
hab : b < a
hf : f =O[atTop] fun x => x ^ (-a)
⊢ (fun t => log t • f t) =O[atTop] fun x => x ^ (-b)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
hab : b < a
hf : f =O[atTop] fun x => x ^ (-a)
t : ℝ
ht : 0 < t
⊢ (fun x => x ^ (a - b) • x ^ (-a)) t = (fun x => x ^ (-b)) t

tactic: simp only
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
hab : b < a
hf : f =O[atTop] fun x => x ^ (-a)
t : ℝ
ht : 0 < t
⊢ (fun x => x ^ (a - b) • x ^ (-a)) t = (fun x => x ^ (-b)) t
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
hab : b < a
hf : f =O[atTop] fun x => x ^ (-a)
t : ℝ
ht : 0 < t
⊢ t ^ (a - b) • t ^ (-a) = t ^ (-b)

tactic: rw [smul_eq_mul, ← rpow_add ht, ← sub_eq_add_neg, sub_eq_add_neg a, add_sub_cancel_left]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
hab : b < a
hf : f =O[atTop] fun x => x ^ (-a)
t : ℝ
ht : 0 < t
⊢ t ^ (a - b) • t ^ (-a) = t ^ (-b)
state_after: no goals

tactic: rfl
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
hab : b < a
hf : f =O[atTop] fun x => x ^ (-a)
t : ℝ
⊢ (fun x => log x • f x) t = (fun t => log t • f t) t
state_after: no goals
Theorem: Finset.prod_subtype_of_mem
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: rw [prod_subtype_eq_prod_filter, filter_true_of_mem]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
f : α → β
p : α → Prop
inst✝ : DecidablePred p
h : ∀ x ∈ s, p x
⊢ ∏ x ∈ Finset.subtype p s, f ↑x = ∏ x ∈ s, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
f : α → β
p : α → Prop
inst✝ : DecidablePred p
h : ∀ x ∈ s, p x
⊢ ∀ x ∈ s, p x

tactic: simpa using h
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
f : α → β
p : α → Prop
inst✝ : DecidablePred p
h : ∀ x ∈ s, p x
⊢ ∀ x ∈ s, p x
state_after: no goals
Theorem: Stream'.Seq.tail_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: cases' s with f al
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : Seq α
⊢ (cons a s).tail = s
state_after: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ (cons a ⟨f, al⟩).tail = ⟨f, al⟩

tactic: apply Subtype.eq
state_before: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ (cons a ⟨f, al⟩).tail = ⟨f, al⟩
state_after: case mk.a
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ ↑(cons a ⟨f, al⟩).tail = ↑⟨f, al⟩

tactic: dsimp [tail, cons]
state_before: case mk.a
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ ↑(cons a ⟨f, al⟩).tail = ↑⟨f, al⟩
state_after: no goals
Theorem: sdiff_sup
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sup_inf_left]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ y ⊓ (x ⊔ z) ⊔ y \ x ⊓ y \ z = (y ⊓ (x ⊔ z) ⊔ y \ x) ⊓ (y ⊓ (x ⊔ z) ⊔ y \ z)
state_after: no goals

tactic: rw [@inf_sup_left _ _ y]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (y ⊓ (x ⊔ z) ⊔ y \ x) ⊓ (y ⊓ (x ⊔ z) ⊔ y \ z) = (y ⊓ x ⊔ y ⊓ z ⊔ y \ x) ⊓ (y ⊓ x ⊔ y ⊓ z ⊔ y \ z)
state_after: no goals

tactic: ac_rfl
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (y ⊓ x ⊔ y ⊓ z ⊔ y \ x) ⊓ (y ⊓ x ⊔ y ⊓ z ⊔ y \ z) = (y ⊓ z ⊔ (y ⊓ x ⊔ y \ x)) ⊓ (y ⊓ x ⊔ (y ⊓ z ⊔ y \ z))
state_after: no goals

tactic: rw [sup_inf_sdiff, sup_inf_sdiff]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (y ⊓ z ⊔ (y ⊓ x ⊔ y \ x)) ⊓ (y ⊓ x ⊔ (y ⊓ z ⊔ y \ z)) = (y ⊓ z ⊔ y) ⊓ (y ⊓ x ⊔ y)
state_after: no goals

tactic: ac_rfl
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (y ⊓ z ⊔ y) ⊓ (y ⊓ x ⊔ y) = (y ⊔ y ⊓ z) ⊓ (y ⊔ y ⊓ x)
state_after: no goals

tactic: rw [sup_inf_self, sup_inf_self, inf_idem]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (y ⊔ y ⊓ z) ⊓ (y ⊔ y ⊓ x) = y
state_after: no goals

tactic: rw [inf_sup_left]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ y ⊓ (x ⊔ z) ⊓ (y \ x ⊓ y \ z) = (y ⊓ x ⊔ y ⊓ z) ⊓ (y \ x ⊓ y \ z)
state_after: no goals

tactic: rw [inf_sup_right]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (y ⊓ x ⊔ y ⊓ z) ⊓ (y \ x ⊓ y \ z) = y ⊓ x ⊓ (y \ x ⊓ y \ z) ⊔ y ⊓ z ⊓ (y \ x ⊓ y \ z)
state_after: no goals

tactic: ac_rfl
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ y ⊓ x ⊓ (y \ x ⊓ y \ z) ⊔ y ⊓ z ⊓ (y \ x ⊓ y \ z) = y ⊓ x ⊓ y \ x ⊓ y \ z ⊔ y \ x ⊓ (y \ z ⊓ (y ⊓ z))
state_after: no goals

tactic: rw [inf_inf_sdiff, bot_inf_eq, bot_sup_eq, inf_comm (y \ z),
    inf_inf_sdiff, inf_bot_eq]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ y ⊓ x ⊓ y \ x ⊓ y \ z ⊔ y \ x ⊓ (y \ z ⊓ (y ⊓ z)) = ⊥
state_after: no goals
Theorem: ciSup_unique
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: have : ∀ i, s i = s default := fun i => congr_arg s (Unique.eq_default i)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
inst✝ : Unique ι
s : ι → α
⊢ ⨆ i, s i = s default
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
inst✝ : Unique ι
s : ι → α
this : ∀ (i : ι), s i = s default
⊢ ⨆ i, s i = s default

tactic: simp only [this, ciSup_const]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
inst✝ : Unique ι
s : ι → α
this : ∀ (i : ι), s i = s default
⊢ ⨆ i, s i = s default
state_after: no goals
Theorem: Set.mem_ite_empty_left
File: Mathlib/Data/Set/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : Set α
x : α
⊢ (∃ (_ : ¬p), x ∈ t) ↔ ¬p ∧ x ∈ t
state_after: no goals
Theorem: mul_cancel_left_mem_nonZeroDivisors
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

tactic: simp_rw [mul_comm r, mul_cancel_right_mem_nonZeroDivisors hr]
state_before: M₀ : Type u_1
inst✝⁵ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
x y r : R'
hr : r ∈ R'⁰
⊢ r * x = r * y ↔ x = y
state_after: no goals
Theorem: AlternatingMap.measure_parallelepiped
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: conv_rhs => rw [ω.eq_smul_basis_det (finBasisOfFinrankEq ℝ G _i.out)]
state_before: E : Type u_1
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace ℝ E
inst✝¹³ : MeasurableSpace E
inst✝¹² : BorelSpace E
inst✝¹¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝¹⁰ : μ.IsAddHaarMeasure
F : Type u_2
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace ℝ F
inst✝⁷ : CompleteSpace F
s : Set E
ι : Type u_3
G : Type u_4
inst✝⁶ : Fintype ι
inst✝⁵ : DecidableEq ι
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
inst✝² : MeasurableSpace G
inst✝¹ : BorelSpace G
inst✝ : FiniteDimensional ℝ G
n : ℕ
_i : Fact (finrank ℝ G = n)
ω : G [⋀^Fin n]→ₗ[ℝ] ℝ
v : Fin n → G
⊢ ω.measure (parallelepiped v) = ENNReal.ofReal |ω v|
state_after: E : Type u_1
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace ℝ E
inst✝¹³ : MeasurableSpace E
inst✝¹² : BorelSpace E
inst✝¹¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝¹⁰ : μ.IsAddHaarMeasure
F : Type u_2
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace ℝ F
inst✝⁷ : CompleteSpace F
s : Set E
ι : Type u_3
G : Type u_4
inst✝⁶ : Fintype ι
inst✝⁵ : DecidableEq ι
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
inst✝² : MeasurableSpace G
inst✝¹ : BorelSpace G
inst✝ : FiniteDimensional ℝ G
n : ℕ
_i : Fact (finrank ℝ G = n)
ω : G [⋀^Fin n]→ₗ[ℝ] ℝ
v : Fin n → G
⊢ ω.measure (parallelepiped v) = ENNReal.ofReal |(ω ⇑(finBasisOfFinrankEq ℝ G ⋯) • (finBasisOfFinrankEq ℝ G ⋯).det) v|

tactic: simp only [addHaar_parallelepiped, AlternatingMap.measure, coe_nnreal_smul_apply,
  AlternatingMap.smul_apply, Algebra.id.smul_eq_mul, abs_mul, ENNReal.ofReal_mul (abs_nonneg _),
  Real.ennnorm_eq_ofReal_abs]
state_before: E : Type u_1
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace ℝ E
inst✝¹³ : MeasurableSpace E
inst✝¹² : BorelSpace E
inst✝¹¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝¹⁰ : μ.IsAddHaarMeasure
F : Type u_2
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace ℝ F
inst✝⁷ : CompleteSpace F
s : Set E
ι : Type u_3
G : Type u_4
inst✝⁶ : Fintype ι
inst✝⁵ : DecidableEq ι
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
inst✝² : MeasurableSpace G
inst✝¹ : BorelSpace G
inst✝ : FiniteDimensional ℝ G
n : ℕ
_i : Fact (finrank ℝ G = n)
ω : G [⋀^Fin n]→ₗ[ℝ] ℝ
v : Fin n → G
⊢ ω.measure (parallelepiped v) = ENNReal.ofReal |(ω ⇑(finBasisOfFinrankEq ℝ G ⋯) • (finBasisOfFinrankEq ℝ G ⋯).det) v|
state_after: no goals
Theorem: Filter.tendsto_sup
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Tendsto, map_sup, sup_le_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : α → β
x₁ x₂ : Filter α
y : Filter β
⊢ Tendsto f (x₁ ⊔ x₂) y ↔ Tendsto f x₁ y ∧ Tendsto f x₂ y
state_after: no goals
Theorem: Summable.countable_support_ennreal
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift f to α → ℝ≥0 using ENNReal.ne_top_of_tsum_ne_top h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0∞
h : ∑' (i : α), f i ≠ ⊤
⊢ (support f).Countable
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0
h : ∑' (i : α), (fun i => ↑(f i)) i ≠ ⊤
⊢ (support fun i => ↑(f i)).Countable

tactic: simpa [support] using (ENNReal.tsum_coe_ne_top_iff_summable.1 h).countable_support_nnreal
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0
h : ∑' (i : α), (fun i => ↑(f i)) i ≠ ⊤
⊢ (support fun i => ↑(f i)).Countable
state_after: no goals
Theorem: Filter.EventuallyEq.fderiv_eq
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [← fderivWithin_univ, ← fderivWithin_univ, h.fderivWithin_eq_nhds]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : f₁ =ᶠ[𝓝 x] f
⊢ fderiv 𝕜 f₁ x = fderiv 𝕜 f x
state_after: no goals
Theorem: MeasureTheory.integrableOn_const
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [Measure.restrict_apply_univ]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
C : E
⊢ C = 0 ∨ (μ.restrict s) univ < ⊤ ↔ C = 0 ∨ μ s < ⊤
state_after: no goals
Theorem: BoxIntegral.Prepartition.iUnion_ofWithBot
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: suffices ⋃ (J : Box ι) (_ : ↑J ∈ boxes), ↑J = ⋃ J ∈ boxes, (J : Set (ι → ℝ)) by
  simpa [ofWithBot, Prepartition.iUnion]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ J ∈ boxes, J ≤ ↑I
pairwise_disjoint : (↑boxes).Pairwise Disjoint
⊢ (ofWithBot boxes le_of_mem pairwise_disjoint).iUnion = ⋃ J ∈ boxes, ↑J
state_after: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ J ∈ boxes, J ≤ ↑I
pairwise_disjoint : (↑boxes).Pairwise Disjoint
⊢ ⋃ J, ⋃ (_ : ↑J ∈ boxes), ↑J = ⋃ J ∈ boxes, ↑J

tactic: simp only [← Box.biUnion_coe_eq_coe, @iUnion_comm _ _ (Box ι), @iUnion_comm _ _ (@Eq _ _ _),
  iUnion_iUnion_eq_right]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ J ∈ boxes, J ≤ ↑I
pairwise_disjoint : (↑boxes).Pairwise Disjoint
⊢ ⋃ J, ⋃ (_ : ↑J ∈ boxes), ↑J = ⋃ J ∈ boxes, ↑J
state_after: no goals

tactic: simpa [ofWithBot, Prepartition.iUnion]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ J ∈ boxes, J ≤ ↑I
pairwise_disjoint : (↑boxes).Pairwise Disjoint
this : ⋃ J, ⋃ (_ : ↑J ∈ boxes), ↑J = ⋃ J ∈ boxes, ↑J
⊢ (ofWithBot boxes le_of_mem pairwise_disjoint).iUnion = ⋃ J ∈ boxes, ↑J
state_after: no goals
Theorem: IsLocalMaxOn.fderivWithin_nonpos
File: Mathlib/Analysis/Calculus/LocalExtr/Basic.lean

tactic: rw [fderivWithin_zero_of_not_differentiableWithinAt hf]
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ (fderivWithin ℝ f s a) y ≤ 0
state_after: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ 0 y ≤ 0

tactic: rfl
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ 0 y ≤ 0
state_after: no goals
Theorem: List.map_permutationsAux
File: Mathlib/Data/List/Permutation.lean

tactic: refine permutationsAux.rec (by simp) ?_
state_before: α : Type u_1
β : Type u_2
f : α → β
⊢ ∀ (ts is : List α), map (map f) (ts.permutationsAux is) = (map f ts).permutationsAux (map f is)
state_after: α : Type u_1
β : Type u_2
f : α → β
⊢ ∀ (t : α) (ts is : List α),
    map (map f) (ts.permutationsAux (t :: is)) = (map f ts).permutationsAux (map f (t :: is)) →
      map (map f) (is.permutationsAux []) = (map f is).permutationsAux (map f []) →
        map (map f) ((t :: ts).permutationsAux is) = (map f (t :: ts)).permutationsAux (map f is)

tactic: introv IH1 IH2
state_before: α : Type u_1
β : Type u_2
f : α → β
⊢ ∀ (t : α) (ts is : List α),
    map (map f) (ts.permutationsAux (t :: is)) = (map f ts).permutationsAux (map f (t :: is)) →
      map (map f) (is.permutationsAux []) = (map f is).permutationsAux (map f []) →
        map (map f) ((t :: ts).permutationsAux is) = (map f (t :: ts)).permutationsAux (map f is)
state_after: α : Type u_1
β : Type u_2
f : α → β
t : α
ts is : List α
IH1 : map (map f) (ts.permutationsAux (t :: is)) = (map f ts).permutationsAux (map f (t :: is))
IH2 : map (map f) (is.permutationsAux []) = (map f is).permutationsAux (map f [])
⊢ map (map f) ((t :: ts).permutationsAux is) = (map f (t :: ts)).permutationsAux (map f is)

tactic: rw [map] at IH2
state_before: α : Type u_1
β : Type u_2
f : α → β
t : α
ts is : List α
IH1 : map (map f) (ts.permutationsAux (t :: is)) = (map f ts).permutationsAux (map f (t :: is))
IH2 : map (map f) (is.permutationsAux []) = (map f is).permutationsAux (map f [])
⊢ map (map f) ((t :: ts).permutationsAux is) = (map f (t :: ts)).permutationsAux (map f is)
state_after: α : Type u_1
β : Type u_2
f : α → β
t : α
ts is : List α
IH1 : map (map f) (ts.permutationsAux (t :: is)) = (map f ts).permutationsAux (map f (t :: is))
IH2 : map (map f) (is.permutationsAux []) = (map f is).permutationsAux []
⊢ map (map f) ((t :: ts).permutationsAux is) = (map f (t :: ts)).permutationsAux (map f is)

tactic: simp only [foldr_permutationsAux2, map_append, map, map_map_permutationsAux2, permutations,
  bind_map, IH1, append_assoc, permutationsAux_cons, bind_cons, ← IH2, map_bind]
state_before: α : Type u_1
β : Type u_2
f : α → β
t : α
ts is : List α
IH1 : map (map f) (ts.permutationsAux (t :: is)) = (map f ts).permutationsAux (map f (t :: is))
IH2 : map (map f) (is.permutationsAux []) = (map f is).permutationsAux []
⊢ map (map f) ((t :: ts).permutationsAux is) = (map f (t :: ts)).permutationsAux (map f is)
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
f : α → β
⊢ ∀ (is : List α), map (map f) ([].permutationsAux is) = (map f []).permutationsAux (map f is)
state_after: no goals
Theorem: ArithmeticFunction.abscissaOfAbsConv_zeta
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

tactic: rw [abscissaOfAbsConv_congr (g := 1) fun hn ↦ by simp [hn], abscissaOfAbsConv_one]
state_before: ⊢ (abscissaOfAbsConv fun n => ↑(ζ n)) = 1
state_after: no goals

tactic: simp [hn]
state_before: n✝ : ℕ
hn : n✝ ≠ 0
⊢ ↑(ζ n✝) = 1 n✝
state_after: no goals
Theorem: Ordinal.nadd_succ
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [← nadd_one (a ♯ b), nadd_assoc, nadd_one]
state_before: a b c : Ordinal.{u}
⊢ a ♯ succ b = succ (a ♯ b)
state_after: no goals
Theorem: Bornology.isBounded_empty
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [isBounded_def, compl_empty]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
x✝ : Bornology α
s t : Set α
x : α
⊢ IsBounded ∅
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
x✝ : Bornology α
s t : Set α
x : α
⊢ univ ∈ cobounded α

tactic: exact univ_mem
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
x✝ : Bornology α
s t : Set α
x : α
⊢ univ ∈ cobounded α
state_after: no goals