1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.VectorMeasure.restrict_le_restrict_union
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [Set.union_eq_iUnion]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommMonoid M
inst✝ : OrderClosedTopology M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi₂ : v.restrict i ≤ w.restrict i
hj₁ : MeasurableSet j
hj₂ : v.restrict j ≤ w.restrict j
⊢ v.restrict (i ∪ j) ≤ w.restrict (i ∪ j)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommMonoid M
inst✝ : OrderClosedTopology M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi₂ : v.restrict i ≤ w.restrict i
hj₁ : MeasurableSet j
hj₂ : v.restrict j ≤ w.restrict j
⊢ v.restrict (⋃ b, bif b then i else j) ≤ w.restrict (⋃ b, bif b then i else j)

tactic: refine restrict_le_restrict_countable_iUnion v w ?_ ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommMonoid M
inst✝ : OrderClosedTopology M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi₂ : v.restrict i ≤ w.restrict i
hj₁ : MeasurableSet j
hj₂ : v.restrict j ≤ w.restrict j
⊢ v.restrict (⋃ b, bif b then i else j) ≤ w.restrict (⋃ b, bif b then i else j)
state_after: case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommMonoid M
inst✝ : OrderClosedTopology M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi₂ : v.restrict i ≤ w.restrict i
hj₁ : MeasurableSet j
hj₂ : v.restrict j ≤ w.restrict j
⊢ ∀ (b : Bool), MeasurableSet (bif b then i else j)

case refine_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommMonoid M
inst✝ : OrderClosedTopology M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi₂ : v.restrict i ≤ w.restrict i
hj₁ : MeasurableSet j
hj₂ : v.restrict j ≤ w.restrict j
⊢ ∀ (b : Bool), v.restrict (bif b then i else j) ≤ w.restrict (bif b then i else j)

tactic: measurability
state_before: case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommMonoid M
inst✝ : OrderClosedTopology M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi₂ : v.restrict i ≤ w.restrict i
hj₁ : MeasurableSet j
hj₂ : v.restrict j ≤ w.restrict j
⊢ ∀ (b : Bool), MeasurableSet (bif b then i else j)
state_after: no goals

tactic: rintro (_ | _) <;> simpa
state_before: case refine_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommMonoid M
inst✝ : OrderClosedTopology M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi₂ : v.restrict i ≤ w.restrict i
hj₁ : MeasurableSet j
hj₂ : v.restrict j ≤ w.restrict j
⊢ ∀ (b : Bool), v.restrict (bif b then i else j) ≤ w.restrict (bif b then i else j)
state_after: no goals
Theorem: Pairwise.exists_mem_filter_basis_of_disjoint
File: Mathlib/Order/Filter/Bases.lean

tactic: rcases hd.exists_mem_filter_of_disjoint with ⟨t, htl, hd⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Sort u_4
ι' : Sort u_5
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_7
inst✝ : Finite I
l : I → Filter α
ι : I → Sort u_6
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
hd : Pairwise (Disjoint on l)
h : ∀ (i : I), (l i).HasBasis (p i) (s i)
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Sort u_4
ι' : Sort u_5
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_7
inst✝ : Finite I
l : I → Filter α
ι : I → Sort u_6
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
hd✝ : Pairwise (Disjoint on l)
h : ∀ (i : I), (l i).HasBasis (p i) (s i)
t : I → Set α
htl : ∀ (i : I), t i ∈ l i
hd : Pairwise (Disjoint on t)
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))

tactic: choose ind hp ht using fun i => (h i).mem_iff.1 (htl i)
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Sort u_4
ι' : Sort u_5
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_7
inst✝ : Finite I
l : I → Filter α
ι : I → Sort u_6
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
hd✝ : Pairwise (Disjoint on l)
h : ∀ (i : I), (l i).HasBasis (p i) (s i)
t : I → Set α
htl : ∀ (i : I), t i ∈ l i
hd : Pairwise (Disjoint on t)
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Sort u_4
ι' : Sort u_5
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_7
inst✝ : Finite I
l : I → Filter α
ι : I → Sort u_6
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
hd✝ : Pairwise (Disjoint on l)
h : ∀ (i : I), (l i).HasBasis (p i) (s i)
t : I → Set α
htl : ∀ (i : I), t i ∈ l i
hd : Pairwise (Disjoint on t)
ind : (i : I) → ι i
hp : ∀ (i : I), p i (ind i)
ht : ∀ (i : I), s i (ind i) ⊆ t i
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))

tactic: exact ⟨ind, hp, hd.mono fun i j hij => hij.mono (ht _) (ht _)⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Sort u_4
ι' : Sort u_5
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_7
inst✝ : Finite I
l : I → Filter α
ι : I → Sort u_6
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
hd✝ : Pairwise (Disjoint on l)
h : ∀ (i : I), (l i).HasBasis (p i) (s i)
t : I → Set α
htl : ∀ (i : I), t i ∈ l i
hd : Pairwise (Disjoint on t)
ind : (i : I) → ι i
hp : ∀ (i : I), p i (ind i)
ht : ∀ (i : I), s i (ind i) ⊆ t i
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))
state_after: no goals
Theorem: Filter.IsBasis.hasBasis
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [h.mem_filter_iff, exists_prop]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : IsBasis p s
t : Set α
⊢ t ∈ h.filter ↔ ∃ i, p i ∧ s i ⊆ t
state_after: no goals
Theorem: LucasLehmer.two_lt_q
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: refine (minFac_prime (one_lt_mersenne.2 ?_).ne').two_le.lt_of_ne' ?_
state_before: p' : ℕ
⊢ 2 < q (p' + 2)
state_after: case refine_1
p' : ℕ
⊢ 1 < p' + 2

case refine_2
p' : ℕ
⊢ (mersenne (p' + 2)).minFac ≠ 2

tactic: exact le_add_left _ _
state_before: case refine_1
p' : ℕ
⊢ 1 < p' + 2
state_after: no goals

tactic: rw [Ne, minFac_eq_two_iff, mersenne, Nat.pow_succ']
state_before: case refine_2
p' : ℕ
⊢ (mersenne (p' + 2)).minFac ≠ 2
state_after: case refine_2
p' : ℕ
⊢ ¬2 ∣ 2 * 2 ^ (p' + 1) - 1

tactic: exact Nat.two_not_dvd_two_mul_sub_one Nat.one_le_two_pow
state_before: case refine_2
p' : ℕ
⊢ ¬2 ∣ 2 * 2 ^ (p' + 1) - 1
state_after: no goals
Theorem: AnalyticAt.unique_eventuallyEq_pow_smul_nonzero
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

tactic: simp_rw [← zpow_natCast] at hm hn
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₀ : 𝕜
m n : ℕ
hm : ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ m • g z
hn : ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ n • g z
⊢ m = n
state_after: 𝕜 : 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₀ : 𝕜
m n : ℕ
hm : ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ ↑m • g z
hn : ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ ↑n • g z
⊢ m = n

tactic: exact Int.ofNat_inj.mp <| unique_eventuallyEq_zpow_smul_nonzero
  (let ⟨g, h₁, h₂, h₃⟩ := hm; ⟨g, h₁, h₂, h₃.filter_mono nhdsWithin_le_nhds⟩)
  (let ⟨g, h₁, h₂, h₃⟩ := hn; ⟨g, h₁, h₂, h₃.filter_mono nhdsWithin_le_nhds⟩)
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₀ : 𝕜
m n : ℕ
hm : ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ ↑m • g z
hn : ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ ↑n • g z
⊢ m = n
state_after: no goals
Theorem: NNReal.sqrt_pos
File: Mathlib/Data/Real/Sqrt.lean

tactic: simp [pos_iff_ne_zero]
state_before: x y : ℝ≥0
⊢ 0 < sqrt x ↔ 0 < x
state_after: no goals
Theorem: Fin.Ioi_succ
File: Mathlib/Data/Fintype/Fin.lean

tactic: ext i
state_before: α : Type u_1
β : Type u_2
n : ℕ
i : Fin n
⊢ Ioi i.succ = map (succEmb n) (Ioi i)
state_after: case a
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ i ∈ Ioi i✝.succ ↔ i ∈ map (succEmb n) (Ioi i✝)

tactic: simp only [mem_filter, mem_Ioi, mem_map, mem_univ, true_and_iff, Function.Embedding.coeFn_mk,
  exists_true_left]
state_before: case a
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ i ∈ Ioi i✝.succ ↔ i ∈ map (succEmb n) (Ioi i✝)
state_after: case a
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ i✝.succ < i ↔ ∃ a, i✝ < a ∧ (succEmb n) a = i

tactic: constructor
state_before: case a
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ i✝.succ < i ↔ ∃ a, i✝ < a ∧ (succEmb n) a = i
state_after: case a.mp
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ i✝.succ < i → ∃ a, i✝ < a ∧ (succEmb n) a = i

case a.mpr
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ (∃ a, i✝ < a ∧ (succEmb n) a = i) → i✝.succ < i

tactic: refine cases ?_ ?_ i
state_before: case a.mp
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ i✝.succ < i → ∃ a, i✝ < a ∧ (succEmb n) a = i
state_after: case a.mp.refine_1
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ i✝.succ < 0 → ∃ a, i✝ < a ∧ (succEmb n) a = 0

case a.mp.refine_2
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ ∀ (i : Fin n), i✝.succ < i.succ → ∃ a, i✝ < a ∧ (succEmb n) a = i.succ

tactic: rintro ⟨⟨⟩⟩
state_before: case a.mp.refine_1
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ i✝.succ < 0 → ∃ a, i✝ < a ∧ (succEmb n) a = 0
state_after: no goals

tactic: intro i hi
state_before: case a.mp.refine_2
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ ∀ (i : Fin n), i✝.succ < i.succ → ∃ a, i✝ < a ∧ (succEmb n) a = i.succ
state_after: case a.mp.refine_2
α : Type u_1
β : Type u_2
n : ℕ
i✝¹ : Fin n
i✝ : Fin n.succ
i : Fin n
hi : i✝¹.succ < i.succ
⊢ ∃ a, i✝¹ < a ∧ (succEmb n) a = i.succ

tactic: exact ⟨i, succ_lt_succ_iff.mp hi, rfl⟩
state_before: case a.mp.refine_2
α : Type u_1
β : Type u_2
n : ℕ
i✝¹ : Fin n
i✝ : Fin n.succ
i : Fin n
hi : i✝¹.succ < i.succ
⊢ ∃ a, i✝¹ < a ∧ (succEmb n) a = i.succ
state_after: no goals

tactic: rintro ⟨i, hi, rfl⟩
state_before: case a.mpr
α : Type u_1
β : Type u_2
n : ℕ
i✝ : Fin n
i : Fin n.succ
⊢ (∃ a, i✝ < a ∧ (succEmb n) a = i) → i✝.succ < i
state_after: case a.mpr.intro.intro
α : Type u_1
β : Type u_2
n : ℕ
i✝ i : Fin n
hi : i✝ < i
⊢ i✝.succ < (succEmb n) i

tactic: simpa
state_before: case a.mpr.intro.intro
α : Type u_1
β : Type u_2
n : ℕ
i✝ i : Fin n
hi : i✝ < i
⊢ i✝.succ < (succEmb n) i
state_after: no goals
Theorem: RingHom.map_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp only [Matrix.dotProduct, map_sum f, f.map_mul, Function.comp]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁴ : Fintype n
inst✝³ : NonAssocSemiring α
inst✝² : NonAssocSemiring β
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
f : R →+* S
v w : n → R
⊢ f (v ⬝ᵥ w) = ⇑f ∘ v ⬝ᵥ ⇑f ∘ w
state_after: no goals
Theorem: Set.iUnion_smul_eq_setOf_exists
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp_rw [← iUnion_setOf, ← iUnion_inv_smul, ← preimage_smul, preimage]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a : α
x : β
s : Set β
⊢ ⋃ g, g • s = {a | ∃ g, g • a ∈ s}
state_after: no goals
Theorem: Batteries.RBSet.toStream_toList
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: simp [toStream_eq]
state_before: α : Type u_1
cmp : α → α → Ordering
t : RBSet α cmp
⊢ (toStream t).toList = t.toList
state_after: no goals
Theorem: rank_zero_iff_forall_zero
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: simp_rw [rank_eq_zero_iff, smul_eq_zero, and_or_left, not_and_self_iff, false_or,
  exists_and_right, and_iff_right (exists_ne (0 : R))]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
⊢ Module.rank R M = 0 ↔ ∀ (x : M), x = 0
state_after: no goals
Theorem: FractionalIdeal.mul_inv_cancel_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rwa [← right_inverse_eq K I J hJ]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
R₁ : Type u_4
inst✝³ : CommRing R₁
inst✝² : IsDomain R₁
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I✝ J✝ I : FractionalIdeal R₁⁰ K
x✝ : ∃ J, I * J = 1
J : FractionalIdeal R₁⁰ K
hJ : I * J = 1
⊢ I * I⁻¹ = 1
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.Subpresheaf.homOfLe_ι
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: ext
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G✝ G'✝ G G' : Subpresheaf F
h : G ≤ G'
⊢ homOfLe h ≫ G'.ι = G.ι
state_after: case w.h.h
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G✝ G'✝ G G' : Subpresheaf F
h : G ≤ G'
x✝ : Cᵒᵖ
a✝ : G.toPresheaf.obj x✝
⊢ (homOfLe h ≫ G'.ι).app x✝ a✝ = G.ι.app x✝ a✝

tactic: rfl
state_before: case w.h.h
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G✝ G'✝ G G' : Subpresheaf F
h : G ≤ G'
x✝ : Cᵒᵖ
a✝ : G.toPresheaf.obj x✝
⊢ (homOfLe h ≫ G'.ι).app x✝ a✝ = G.ι.app x✝ a✝
state_after: no goals
Theorem: zpow_two
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [zpow_ofNat, pow_two]
state_before: G : Type u_1
inst✝ : DivInvMonoid G
a✝ b a : G
⊢ a ^ 2 = a * a
state_after: no goals
Theorem: Complex.abs_exp_mul_exp_add_exp_neg_le_of_abs_im_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp only [abs_exp, Real.exp_le_exp, re_ofReal_mul, add_re, exp_re, neg_im, Real.cos_neg, ←
  add_mul, mul_assoc, mul_comm (Real.cos b), neg_re, ← Real.cos_abs z.im]
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
⊢ abs (cexp (↑a * (cexp z + cexp (-z)))) ≤ rexp (a * Real.cos b * rexp |z.re|)
state_after: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
⊢ a * ((rexp z.re + rexp (-z.re)) * Real.cos |z.im|) ≤ a * (rexp |z.re| * Real.cos b)

tactic: have : Real.exp |z.re| ≤ Real.exp z.re + Real.exp (-z.re) :=
  apply_abs_le_add_of_nonneg (fun x => (Real.exp_pos x).le) z.re
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
⊢ a * ((rexp z.re + rexp (-z.re)) * Real.cos |z.im|) ≤ a * (rexp |z.re| * Real.cos b)
state_after: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ a * ((rexp z.re + rexp (-z.re)) * Real.cos |z.im|) ≤ a * (rexp |z.re| * Real.cos b)

tactic: refine mul_le_mul_of_nonpos_left (mul_le_mul this ?_ ?_ ((Real.exp_pos _).le.trans this)) ha
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ a * ((rexp z.re + rexp (-z.re)) * Real.cos |z.im|) ≤ a * (rexp |z.re| * Real.cos b)
state_after: case refine_1
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ Real.cos b ≤ Real.cos |z.im|

case refine_2
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ 0 ≤ Real.cos b

tactic: exact
  Real.cos_le_cos_of_nonneg_of_le_pi (_root_.abs_nonneg _)
    (hb.trans <| half_le_self <| Real.pi_pos.le) hz
state_before: case refine_1
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ Real.cos b ≤ Real.cos |z.im|
state_after: no goals

tactic: refine Real.cos_nonneg_of_mem_Icc ⟨?_, hb⟩
state_before: case refine_2
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ 0 ≤ Real.cos b
state_after: case refine_2
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ -(π / 2) ≤ b

tactic: exact (neg_nonpos.2 <| Real.pi_div_two_pos.le).trans ((_root_.abs_nonneg _).trans hz)
state_before: case refine_2
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ -(π / 2) ≤ b
state_after: no goals
Theorem: IsUnit.pow
File: Mathlib/Algebra/Group/Units.lean

tactic: rintro ⟨u, rfl⟩
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a b : M
n : ℕ
⊢ IsUnit a → IsUnit (a ^ n)
state_after: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
b : M
n : ℕ
u : Mˣ
⊢ IsUnit (↑u ^ n)

tactic: exact ⟨u ^ n, rfl⟩
state_before: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
b : M
n : ℕ
u : Mˣ
⊢ IsUnit (↑u ^ n)
state_after: no goals
Theorem: ENNReal.toReal_iInf
File: Mathlib/Data/ENNReal/Real.lean

tactic: simp only [ENNReal.toReal, toNNReal_iInf hf, NNReal.coe_iInf]
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
hf : ∀ (i : ι), f i ≠ ⊤
⊢ (iInf f).toReal = ⨅ i, (f i).toReal
state_after: no goals
Theorem: Real.strictAnti_rpow_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp_rw [Real.rpow_def_of_pos hb₀]
state_before: x y z : ℝ
n : ℕ
b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ StrictAnti fun x => b ^ x
state_after: x y z : ℝ
n : ℕ
b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ StrictAnti fun x => rexp (log b * x)

tactic: exact exp_strictMono.comp_strictAnti <| StrictMono.const_mul_of_neg strictMono_id
    <| Real.log_neg hb₀ hb₁
state_before: x y z : ℝ
n : ℕ
b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ StrictAnti fun x => rexp (log b * x)
state_after: no goals
Theorem: Fintype.prod_eq_one_iff_of_le_one
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

tactic: simp [Function.funext_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : Fintype ι
inst✝ : OrderedCommMonoid M
f : ι → M
hf : f ≤ 1
⊢ (∀ i ∈ Finset.univ, f i = 1) ↔ f = 1
state_after: no goals
Theorem: Nat.ceilRoot_pow_self
File: Mathlib/Data/Nat/Factorization/Root.lean

tactic: simp [ceilRoot_def, pos_iff_ne_zero.2, hn]
state_before: a✝ b n : ℕ
hn : n ≠ 0
a : ℕ
⊢ n.ceilRoot (a ^ n) = a
state_after: a✝ b n : ℕ
hn : n ≠ 0
a : ℕ
⊢ (if a = 0 then 0 else a.factorization.prod fun x x_1 => x ^ x_1) = a

tactic: split_ifs <;> simp [*]
state_before: a✝ b n : ℕ
hn : n ≠ 0
a : ℕ
⊢ (if a = 0 then 0 else a.factorization.prod fun x x_1 => x ^ x_1) = a
state_after: no goals
Theorem: WittVector.add_coeff_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: simp [add_coeff, peval]
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x y : 𝕎 R
⊢ (x + y).coeff 0 = x.coeff 0 + y.coeff 0
state_after: no goals
Theorem: List.prev_ne_cons_cons
File: Mathlib/Data/List/Cycle.lean

tactic: simpa [hy] using h
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y z : α
h : x ∈ y :: z :: l
hy : x ≠ y
hz : x ≠ z
⊢ x ∈ z :: l
state_after: no goals

tactic: cases l
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y z : α
h : x ∈ y :: z :: l
hy : x ≠ y
hz : x ≠ z
⊢ (y :: z :: l).prev x h = (z :: l).prev x ⋯
state_after: case nil
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x ≠ z
h : x ∈ [y, z]
⊢ [y, z].prev x h = [z].prev x ⋯

case cons
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x ≠ z
head✝ : α
tail✝ : List α
h : x ∈ y :: z :: head✝ :: tail✝
⊢ (y :: z :: head✝ :: tail✝).prev x h = (z :: head✝ :: tail✝).prev x ⋯

tactic: simp [hy, hz] at h
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x ≠ z
h : x ∈ [y, z]
⊢ [y, z].prev x h = [z].prev x ⋯
state_after: no goals

tactic: rw [prev, dif_neg hy, if_neg hz]
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x ≠ z
head✝ : α
tail✝ : List α
h : x ∈ y :: z :: head✝ :: tail✝
⊢ (y :: z :: head✝ :: tail✝).prev x h = (z :: head✝ :: tail✝).prev x ⋯
state_after: no goals
Theorem: topologicalGroup_iInf
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: exact topologicalGroup_sInf (Set.forall_mem_range.mpr h')
state_before: G : Type w
H : Type x
α : Type u
β : Type v
ι : Sort u_1
inst✝ : Group G
ts' : ι → TopologicalSpace G
h' : ∀ (i : ι), TopologicalGroup G
⊢ TopologicalGroup G
state_after: no goals
Theorem: divp_mul_divp
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [divp_mul_eq_mul_divp, divp_assoc', divp_divp_eq_divp_mul]
state_before: α : Type u
inst✝ : CommMonoid α
x y : α
ux uy : αˣ
⊢ x /ₚ ux * (y /ₚ uy) = x * y /ₚ (ux * uy)
state_after: no goals
Theorem: DiscreteQuotient.proj_bot_inj
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: simp
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
S : DiscreteQuotient X
inst✝ : DiscreteTopology X
x y : X
⊢ ⊥.proj x = ⊥.proj y ↔ x = y
state_after: no goals
Theorem: Finsupp.subset_support_tsub
File: Mathlib/Data/Finsupp/Order.lean

tactic: simp (config := { contextual := true }) [subset_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : CanonicallyOrderedAddCommMonoid α
f✝ g✝ : ι →₀ α
inst✝² : Sub α
inst✝¹ : OrderedSub α
f g : ι →₀ α
i : ι
a b : α
inst✝ : DecidableEq ι
f1 f2 : ι →₀ α
⊢ f1.support \ f2.support ⊆ (f1 - f2).support
state_after: no goals
Theorem: ContractingWith.dist_inequality
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: rwa [le_div_iff hf.one_sub_K_pos, mul_comm, _root_.sub_mul, one_mul, sub_le_iff_le_add]
state_before: α : Type u_1
inst✝ : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
this : dist x y ≤ dist x (f x) + dist y (f y) + ↑K * dist x y
⊢ dist x y ≤ (dist x (f x) + dist y (f y)) / (1 - ↑K)
state_after: no goals