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

tactic: rw [← gauge_lt_one_iff_mem_interior] <;> try assumption
state_before: E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module ℝ E
inst✝³ : TopologicalSpace E
inst✝² : T1Space E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s t : Set E
h₀ : t ∈ 𝓝 0
hc : Convex ℝ t
x : E
hx : x ∈ interior s
⊢ gaugeRescale s t x ∈ interior t
state_after: E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module ℝ E
inst✝³ : TopologicalSpace E
inst✝² : T1Space E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s t : Set E
h₀ : t ∈ 𝓝 0
hc : Convex ℝ t
x : E
hx : x ∈ interior s
⊢ gauge t (gaugeRescale s t x) < 1

tactic: exact (gauge_gaugeRescale_le _ _ _).trans_lt (interior_subset_gauge_lt_one _ hx)
state_before: E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module ℝ E
inst✝³ : TopologicalSpace E
inst✝² : T1Space E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s t : Set E
h₀ : t ∈ 𝓝 0
hc : Convex ℝ t
x : E
hx : x ∈ interior s
⊢ gauge t (gaugeRescale s t x) < 1
state_after: no goals

tactic: assumption
state_before: case hs₀
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module ℝ E
inst✝³ : TopologicalSpace E
inst✝² : T1Space E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s t : Set E
h₀ : t ∈ 𝓝 0
hc : Convex ℝ t
x : E
hx : x ∈ interior s
⊢ t ∈ 𝓝 0
state_after: no goals
Theorem: Stream'.WSeq.dropn_tail
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [Nat.add_comm]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ s.tail.drop n = s.drop (n + 1)
state_after: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ s.tail.drop n = s.drop (1 + n)

tactic: symm
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ s.tail.drop n = s.drop (1 + n)
state_after: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ s.drop (1 + n) = s.tail.drop n

tactic: apply dropn_add
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ s.drop (1 + n) = s.tail.drop n
state_after: no goals
Theorem: Set.subset_center_units
File: Mathlib/Algebra/Group/Center.lean

tactic: rw [_root_.Semigroup.mem_center_iff]
state_before: M : Type u_1
inst✝ : Monoid M
x✝ : Mˣ
ha : x✝ ∈ Units.val ⁻¹' center M
⊢ x✝ ∈ center Mˣ
state_after: M : Type u_1
inst✝ : Monoid M
x✝ : Mˣ
ha : x✝ ∈ Units.val ⁻¹' center M
⊢ ∀ (g : Mˣ), g * x✝ = x✝ * g

tactic: intro _
state_before: M : Type u_1
inst✝ : Monoid M
x✝ : Mˣ
ha : x✝ ∈ Units.val ⁻¹' center M
⊢ ∀ (g : Mˣ), g * x✝ = x✝ * g
state_after: M : Type u_1
inst✝ : Monoid M
x✝ : Mˣ
ha : x✝ ∈ Units.val ⁻¹' center M
g✝ : Mˣ
⊢ g✝ * x✝ = x✝ * g✝

tactic: rw [← Units.eq_iff, Units.val_mul, Units.val_mul, ha.comm]
state_before: M : Type u_1
inst✝ : Monoid M
x✝ : Mˣ
ha : x✝ ∈ Units.val ⁻¹' center M
g✝ : Mˣ
⊢ g✝ * x✝ = x✝ * g✝
state_after: no goals
Theorem: Real.sign_neg
File: Mathlib/Data/Real/Sign.lean

tactic: obtain hn | rfl | hp := lt_trichotomy r (0 : ℝ)
state_before: r : ℝ
⊢ (-r).sign = -r.sign
state_after: case inl
r : ℝ
hn : r < 0
⊢ (-r).sign = -r.sign

case inr.inl

⊢ (-0).sign = -sign 0

case inr.inr
r : ℝ
hp : 0 < r
⊢ (-r).sign = -r.sign

tactic: rw [sign_of_neg hn, sign_of_pos (neg_pos.mpr hn), neg_neg]
state_before: case inl
r : ℝ
hn : r < 0
⊢ (-r).sign = -r.sign
state_after: no goals

tactic: rw [sign_zero, neg_zero, sign_zero]
state_before: case inr.inl

⊢ (-0).sign = -sign 0
state_after: no goals

tactic: rw [sign_of_pos hp, sign_of_neg (neg_lt_zero.mpr hp)]
state_before: case inr.inr
r : ℝ
hp : 0 < r
⊢ (-r).sign = -r.sign
state_after: no goals
Theorem: HasDerivAtFilter.isBigO_sub_rev
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp [norm_smul, ← div_eq_inv_mul, mul_div_cancel_right₀ _ (mt norm_eq_zero.1 hf')]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hf : HasDerivAtFilter f f' x✝ L
hf' : f' ≠ 0
x : 𝕜
⊢ ‖x‖ ≤ ↑‖f'‖₊⁻¹ * ‖(smulRight 1 f') x‖
state_after: no goals
Theorem: Finset.prod_fiberwise_eq_prod_filter'
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: calc
  _ = ∏ j ∈ t, ∏ i ∈ s.filter fun i ↦ g i = j, f (g i) :=
      prod_congr rfl fun j _ ↦ prod_congr rfl fun i hi ↦ by rw [(mem_filter.1 hi).2]
  _ = _ := prod_fiberwise_eq_prod_filter _ _ _ _
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 β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝¹ : CommMonoid α
s✝ : Finset ι
t✝ : Finset κ
f✝ : ι → α
g✝ : κ → α
inst✝ : DecidableEq κ
s : Finset ι
t : Finset κ
g : ι → κ
f : κ → α
⊢ ∏ j ∈ t, ∏ _i ∈ filter (fun i => g i = j) s, f j = ∏ i ∈ filter (fun i => g i ∈ t) s, f (g i)
state_after: no goals

tactic: rw [(mem_filter.1 hi).2]
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 β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝¹ : CommMonoid α
s✝ : Finset ι
t✝ : Finset κ
f✝ : ι → α
g✝ : κ → α
inst✝ : DecidableEq κ
s : Finset ι
t : Finset κ
g : ι → κ
f : κ → α
j : κ
x✝ : j ∈ t
i : ι
hi : i ∈ filter (fun i => g i = j) s
⊢ f j = f (g i)
state_after: no goals
Theorem: PadicInt.norm_int_le_pow_iff_dvd
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: simpa [norm_intCast_eq_padic_norm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
n : ℕ
this : ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑p ^ n ∣ k
⊢ ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑p ^ n ∣ k
state_after: no goals
Theorem: dirichletLSeries_eulerProduct
File: Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean

tactic: rw [← tsum_dirichletSummand χ hs]
state_before: s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
⊢ Tendsto (fun n => ∏ p ∈ n.primesBelow, (1 - χ ↑p * ↑p ^ (-s))⁻¹) atTop (𝓝 (L (fun n => χ ↑n) s))
state_after: s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
⊢ Tendsto (fun n => ∏ p ∈ n.primesBelow, (1 - χ ↑p * ↑p ^ (-s))⁻¹) atTop (𝓝 (∑' (n : ℕ), (dirichletSummandHom χ ⋯) n))

tactic: apply eulerProduct_completely_multiplicative <| summable_dirichletSummand χ hs
state_before: s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
⊢ Tendsto (fun n => ∏ p ∈ n.primesBelow, (1 - χ ↑p * ↑p ^ (-s))⁻¹) atTop (𝓝 (∑' (n : ℕ), (dirichletSummandHom χ ⋯) n))
state_after: no goals
Theorem: PFunctor.W.mk_dest
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

tactic: cases p
state_before: P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
p : P.W
⊢ mk p.dest = p
state_after: case mk
P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
a✝ : P.A
f✝ : P.B a✝ → WType P.B
⊢ mk (dest (WType.mk a✝ f✝)) = WType.mk a✝ f✝

tactic: rfl
state_before: case mk
P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
a✝ : P.A
f✝ : P.B a✝ → WType P.B
⊢ mk (dest (WType.mk a✝ f✝)) = WType.mk a✝ f✝
state_after: no goals
Theorem: IsRightRegular.pow_iff
File: Mathlib/Algebra/Regular/Pow.lean

tactic: refine ⟨?_, IsRightRegular.pow n⟩
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a ^ n) ↔ IsRightRegular a
state_after: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a ^ n) → IsRightRegular a

tactic: rw [← Nat.succ_pred_eq_of_pos n0, pow_succ']
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a ^ n) → IsRightRegular a
state_after: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a * a ^ n.pred) → IsRightRegular a

tactic: exact IsRightRegular.of_mul
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a * a ^ n.pred) → IsRightRegular a
state_after: no goals
Theorem: integral_cos_pow
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: field_simp
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, cos x ^ (n + 2) =
    (cos b ^ (n + 1) * sin b - cos a ^ (n + 1) * sin a) / (↑n + 2) + (↑n + 1) / (↑n + 2) * ∫ (x : ℝ) in a..b, cos x ^ n
state_after: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, cos x ^ (n + 2)) * (↑n + 2) =
    cos b ^ (n + 1) * sin b - cos a ^ (n + 1) * sin a + (↑n + 1) * ∫ (x : ℝ) in a..b, cos x ^ n

tactic: convert eq_sub_iff_add_eq.mp (integral_cos_pow_aux n) using 1
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, cos x ^ (n + 2)) * (↑n + 2) =
    cos b ^ (n + 1) * sin b - cos a ^ (n + 1) * sin a + (↑n + 1) * ∫ (x : ℝ) in a..b, cos x ^ n
state_after: case h.e'_2
a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, cos x ^ (n + 2)) * (↑n + 2) =
    (∫ (x : ℝ) in a..b, cos x ^ (n + 2)) + (↑n + 1) * ∫ (x : ℝ) in a..b, cos x ^ (n + 2)

tactic: ring
state_before: case h.e'_2
a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, cos x ^ (n + 2)) * (↑n + 2) =
    (∫ (x : ℝ) in a..b, cos x ^ (n + 2)) + (↑n + 1) * ∫ (x : ℝ) in a..b, cos x ^ (n + 2)
state_after: no goals
Theorem: Multiset.trop_sum
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: simpa using List.trop_sum
state_before: R : Type u_1
S : Type u_2
inst✝ : AddCommMonoid R
s : Multiset R
⊢ ∀ (a : List R), trop (sum ⟦a⟧) = (map trop ⟦a⟧).prod
state_after: no goals
Theorem: mul_upperClosure
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: simp_rw [← smul_eq_mul, ← Set.iUnion_smul_set, upperClosure_iUnion, upperClosure_smul,
  UpperSet.coe_iInf₂]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ s * ↑(upperClosure t) = ↑(upperClosure (s * t))
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ⋃ a ∈ s, a • ↑(upperClosure t) = ⋃ i ∈ s, ↑(i • upperClosure t)

tactic: rfl
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ⋃ a ∈ s, a • ↑(upperClosure t) = ⋃ i ∈ s, ↑(i • upperClosure t)
state_after: no goals
Theorem: Polynomial.lifts_and_natDegree_eq_and_monic
File: Mathlib/Algebra/Polynomial/Lifts.lean

tactic: cases' subsingleton_or_nontrivial S with hR hR
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : p.Monic
⊢ ∃ q, map f q = p ∧ q.natDegree = p.natDegree ∧ q.Monic
state_after: case inl
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : p.Monic
hR : Subsingleton S
⊢ ∃ q, map f q = p ∧ q.natDegree = p.natDegree ∧ q.Monic

case inr
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : p.Monic
hR : Nontrivial S
⊢ ∃ q, map f q = p ∧ q.natDegree = p.natDegree ∧ q.Monic

tactic: obtain ⟨p', h₁, h₂, h₃⟩ := lifts_and_degree_eq_and_monic hlifts hp
state_before: case inr
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : p.Monic
hR : Nontrivial S
⊢ ∃ q, map f q = p ∧ q.natDegree = p.natDegree ∧ q.Monic
state_after: case inr.intro.intro.intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : p.Monic
hR : Nontrivial S
p' : R[X]
h₁ : map f p' = p
h₂ : p'.degree = p.degree
h₃ : p'.Monic
⊢ ∃ q, map f q = p ∧ q.natDegree = p.natDegree ∧ q.Monic

tactic: exact ⟨p', h₁, natDegree_eq_of_degree_eq h₂, h₃⟩
state_before: case inr.intro.intro.intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : p.Monic
hR : Nontrivial S
p' : R[X]
h₁ : map f p' = p
h₂ : p'.degree = p.degree
h₃ : p'.Monic
⊢ ∃ q, map f q = p ∧ q.natDegree = p.natDegree ∧ q.Monic
state_after: no goals

tactic: obtain rfl : p = 1 := Subsingleton.elim _ _
state_before: case inl
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
hlifts : p ∈ lifts f
hp : p.Monic
hR : Subsingleton S
⊢ ∃ q, map f q = p ∧ q.natDegree = p.natDegree ∧ q.Monic
state_after: case inl
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
hR : Subsingleton S
hlifts : 1 ∈ lifts f
hp : Monic 1
⊢ ∃ q, map f q = 1 ∧ q.natDegree = natDegree 1 ∧ q.Monic

tactic: exact ⟨1, Subsingleton.elim _ _, by simp, by simp⟩
state_before: case inl
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
hR : Subsingleton S
hlifts : 1 ∈ lifts f
hp : Monic 1
⊢ ∃ q, map f q = 1 ∧ q.natDegree = natDegree 1 ∧ q.Monic
state_after: no goals

tactic: simp
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
hR : Subsingleton S
hlifts : 1 ∈ lifts f
hp : Monic 1
⊢ natDegree 1 = natDegree 1
state_after: no goals

tactic: simp
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
hR : Subsingleton S
hlifts : 1 ∈ lifts f
hp : Monic 1
⊢ Monic 1
state_after: no goals
Theorem: Fintype.coe_piFinset
File: Mathlib/Data/Fintype/Pi.lean

tactic: rw [Set.mem_univ_pi]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
x : (a : α) → δ a
⊢ x ∈ ↑(piFinset t) ↔ x ∈ Set.univ.pi fun a => ↑(t a)
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
x : (a : α) → δ a
⊢ x ∈ ↑(piFinset t) ↔ ∀ (i : α), x i ∈ ↑(t i)

tactic: exact Fintype.mem_piFinset
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
x : (a : α) → δ a
⊢ x ∈ ↑(piFinset t) ↔ ∀ (i : α), x i ∈ ↑(t i)
state_after: no goals
Theorem: MeasureTheory.absolutelyContinuous_tilted
File: Mathlib/MeasureTheory/Measure/Tilted.lean

tactic: simp only [h, tilted_zero_measure]
state_before: case inl
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h : μ = 0
⊢ μ ≪ μ.tilted f
state_after: case inl
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h : μ = 0
⊢ 0 ≪ 0

tactic: exact fun _ _ ↦ by simp
state_before: case inl
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h : μ = 0
⊢ 0 ≪ 0
state_after: no goals

tactic: simp
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h : μ = 0
x✝¹ : Set α
x✝ : 0 x✝¹ = 0
⊢ 0 x✝¹ = 0
state_after: no goals

tactic: refine withDensity_absolutelyContinuous' ?_ ?_
state_before: case inr
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ μ ≪ μ.tilted f
state_after: case inr.refine_1
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ AEMeasurable (fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)) μ

case inr.refine_2
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ ∀ᵐ (x : α) ∂μ, ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) ≠ 0

tactic: exact (hf.1.aemeasurable.div_const _).ennreal_ofReal
state_before: case inr.refine_1
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ AEMeasurable (fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)) μ
state_after: no goals

tactic: filter_upwards
state_before: case inr.refine_2
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ ∀ᵐ (x : α) ∂μ, ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) ≠ 0
state_after: case inr.refine_2.h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ ∀ (a : α), ENNReal.ofReal (rexp (f a) / ∫ (x : α), rexp (f x) ∂μ) ≠ 0

tactic: simp only [ne_eq, ENNReal.ofReal_eq_zero, not_le]
state_before: case inr.refine_2.h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ ∀ (a : α), ENNReal.ofReal (rexp (f a) / ∫ (x : α), rexp (f x) ∂μ) ≠ 0
state_after: case inr.refine_2.h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ ∀ (a : α), 0 < rexp (f a) / ∫ (x : α), rexp (f x) ∂μ

tactic: exact fun _ ↦ div_pos (exp_pos _) (integral_exp_pos hf)
state_before: case inr.refine_2.h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable (fun x => rexp (f x)) μ
h0 : NeZero μ
⊢ ∀ (a : α), 0 < rexp (f a) / ∫ (x : α), rexp (f x) ∂μ
state_after: no goals
Theorem: DifferentiableAt.derivWithin
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold derivWithin deriv
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : DifferentiableAt 𝕜 f x
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ _root_.derivWithin f s x = deriv f x
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : DifferentiableAt 𝕜 f x
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ (fderivWithin 𝕜 f s x) 1 = (fderiv 𝕜 f x) 1

tactic: rw [h.fderivWithin hxs]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : DifferentiableAt 𝕜 f x
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ (fderivWithin 𝕜 f s x) 1 = (fderiv 𝕜 f x) 1
state_after: no goals
Theorem: Ordnode.insert_eq_insertWith
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: unfold Ordnode.insert insertWith
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ Ordnode.insert x (node size✝ l y r) = insertWith (fun x_1 => x) x (node size✝ l y r)
state_after: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ (match cmpLE x y with
    | Ordering.lt => (Ordnode.insert x l).balanceL y r
    | Ordering.eq => node size✝ l x r
    | Ordering.gt => l.balanceR y (Ordnode.insert x r)) =
    match cmpLE x y with
    | Ordering.lt => (insertWith (fun x_1 => x) x l).balanceL y r
    | Ordering.eq => node size✝ l x r
    | Ordering.gt => l.balanceR y (insertWith (fun x_1 => x) x r)

tactic: cases cmpLE x y <;> simp [insert_eq_insertWith]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ (match cmpLE x y with
    | Ordering.lt => (Ordnode.insert x l).balanceL y r
    | Ordering.eq => node size✝ l x r
    | Ordering.gt => l.balanceR y (Ordnode.insert x r)) =
    match cmpLE x y with
    | Ordering.lt => (insertWith (fun x_1 => x) x l).balanceL y r
    | Ordering.eq => node size✝ l x r
    | Ordering.gt => l.balanceR y (insertWith (fun x_1 => x) x r)
state_after: no goals
Theorem: Equiv.equivCongr_trans
File: Mathlib/Logic/Equiv/Defs.lean

tactic: ext
state_before: α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ε : Sort u_2
ζ : Sort u_3
ab : α ≃ β
de : δ ≃ ε
bc : β ≃ γ
ef : ε ≃ ζ
⊢ (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef)
state_after: case H.H
α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ε : Sort u_2
ζ : Sort u_3
ab : α ≃ β
de : δ ≃ ε
bc : β ≃ γ
ef : ε ≃ ζ
x✝¹ : α ≃ δ
x✝ : γ
⊢ (((ab.equivCongr de).trans (bc.equivCongr ef)) x✝¹) x✝ = (((ab.trans bc).equivCongr (de.trans ef)) x✝¹) x✝

tactic: rfl
state_before: case H.H
α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ε : Sort u_2
ζ : Sort u_3
ab : α ≃ β
de : δ ≃ ε
bc : β ≃ γ
ef : ε ≃ ζ
x✝¹ : α ≃ δ
x✝ : γ
⊢ (((ab.equivCongr de).trans (bc.equivCongr ef)) x✝¹) x✝ = (((ab.trans bc).equivCongr (de.trans ef)) x✝¹) x✝
state_after: no goals
Theorem: Finset.centerMass_smul
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simp only [Finset.centerMass, Finset.smul_sum, (mul_smul _ _ _).symm, mul_comm c, mul_assoc]
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
⊢ (t.centerMass w fun i => c • z i) = c • t.centerMass w z
state_after: no goals
Theorem: Set.forall_subtype_range_iff
File: Mathlib/Data/Set/Image.lean

tactic: subst hi
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
p : ↑(range f) → Prop
H : ∀ (i : ι), p ⟨f i, ⋯⟩
x✝ : ↑(range f)
y : α
i : ι
hi : f i = y
⊢ p ⟨y, ⋯⟩
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
p : ↑(range f) → Prop
H : ∀ (i : ι), p ⟨f i, ⋯⟩
x✝ : ↑(range f)
i : ι
⊢ p ⟨f i, ⋯⟩

tactic: apply H
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
p : ↑(range f) → Prop
H : ∀ (i : ι), p ⟨f i, ⋯⟩
x✝ : ↑(range f)
i : ι
⊢ p ⟨f i, ⋯⟩
state_after: no goals
Theorem: List.rotate_eq_drop_append_take_mod
File: Mathlib/Data/List/Rotate.lean

tactic: rcases l.length.zero_le.eq_or_lt with hl | hl
state_before: α : Type u
l : List α
n : ℕ
⊢ l.rotate n = drop (n % l.length) l ++ take (n % l.length) l
state_after: case inl
α : Type u
l : List α
n : ℕ
hl : 0 = l.length
⊢ l.rotate n = drop (n % l.length) l ++ take (n % l.length) l

case inr
α : Type u
l : List α
n : ℕ
hl : 0 < l.length
⊢ l.rotate n = drop (n % l.length) l ++ take (n % l.length) l

tactic: rw [← rotate_eq_drop_append_take (n.mod_lt hl).le, rotate_mod]
state_before: case inr
α : Type u
l : List α
n : ℕ
hl : 0 < l.length
⊢ l.rotate n = drop (n % l.length) l ++ take (n % l.length) l
state_after: no goals

tactic: simp [eq_nil_of_length_eq_zero hl.symm]
state_before: case inl
α : Type u
l : List α
n : ℕ
hl : 0 = l.length
⊢ l.rotate n = drop (n % l.length) l ++ take (n % l.length) l
state_after: no goals
Theorem: SzemerediRegularity.pow_mul_m_le_card_part
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

tactic: norm_cast
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
⊢ 4 ^ P.parts.card * ↑m ≤ ↑u.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
⊢ 4 ^ P.parts.card * m ≤ u.card

tactic: rw [stepBound, ← Nat.div_div_eq_div_mul]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
⊢ 4 ^ P.parts.card * m ≤ u.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
⊢ 4 ^ P.parts.card * (Fintype.card α / P.parts.card / 4 ^ P.parts.card) ≤ u.card

tactic: exact (Nat.mul_div_le _ _).trans (hP.average_le_card_part hu)
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
⊢ 4 ^ P.parts.card * (Fintype.card α / P.parts.card / 4 ^ P.parts.card) ≤ u.card
state_after: no goals
Theorem: Action.associator_inv_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

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

tactic: simp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X Y Z : Action V G
⊢ ((𝟙 X.V ⊗ 𝟙 (Y.V ⊗ Z.V)) ≫ (α_ X.V Y.V Z.V).inv) ≫ (𝟙 (X.V ⊗ Y.V) ⊗ 𝟙 Z.V) = (α_ X.V Y.V Z.V).inv
state_after: no goals
Theorem: Real.toNNReal_abs
File: Mathlib/Data/NNReal/Basic.lean

tactic: simp
state_before: x : ℝ
⊢ ↑|x|.toNNReal = ↑(nnabs x)
state_after: no goals