1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContinuousLinearMap.iteratedFDeriv_comp_left
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: simp only [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
g : F →L[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDeriv 𝕜 i (⇑g ∘ f) x = g.compContinuousMultilinearMap (iteratedFDeriv 𝕜 i f x)
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
g : F →L[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDerivWithin 𝕜 i (⇑g ∘ f) univ x = g.compContinuousMultilinearMap (iteratedFDerivWithin 𝕜 i f univ x)

tactic: exact g.iteratedFDerivWithin_comp_left hf.contDiffOn uniqueDiffOn_univ (mem_univ x) hi
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
g : F →L[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDerivWithin 𝕜 i (⇑g ∘ f) univ x = g.compContinuousMultilinearMap (iteratedFDerivWithin 𝕜 i f univ x)
state_after: no goals
Theorem: PowerSeries.order_one
File: Mathlib/RingTheory/PowerSeries/Order.lean

tactic: simpa using order_monomial_of_ne_zero 0 (1 : R) one_ne_zero
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ order 1 = 0
state_after: no goals
Theorem: ModularGroup.normSq_S_smul_lt_one
File: Mathlib/NumberTheory/Modular.lean

tactic: simpa [coe_S, num, denom] using (inv_lt_inv z.normSq_pos zero_lt_one).mpr h
state_before: g : SL(2, ℤ)
z : ℍ
h : 1 < normSq ↑z
⊢ normSq ↑(S • z) < 1
state_after: no goals
Theorem: Finsupp.sum_id_lt_of_lt
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: rw [← card_toMultiset, ← card_toMultiset]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m n : ι →₀ ℕ
h : m < n
⊢ (m.sum fun x => id) < n.sum fun x => id
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
m n : ι →₀ ℕ
h : m < n
⊢ Multiset.card (toMultiset m) < Multiset.card (toMultiset n)

tactic: apply Multiset.card_lt_card
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m n : ι →₀ ℕ
h : m < n
⊢ Multiset.card (toMultiset m) < Multiset.card (toMultiset n)
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
m n : ι →₀ ℕ
h : m < n
⊢ toMultiset m < toMultiset n

tactic: exact toMultiset_strictMono h
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
m n : ι →₀ ℕ
h : m < n
⊢ toMultiset m < toMultiset n
state_after: no goals
Theorem: Set.Countable.dense_compl
File: Mathlib/Topology/Algebra/Module/Cardinality.lean

tactic: rw [← interior_eq_empty_iff_dense_compl]
state_before: E : Type u
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : CompleteSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nontrivial E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s.Countable
⊢ Dense sᶜ
state_after: E : Type u
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : CompleteSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nontrivial E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s.Countable
⊢ interior s = ∅

tactic: by_contra H
state_before: E : Type u
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : CompleteSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nontrivial E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s.Countable
⊢ interior s = ∅
state_after: E : Type u
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : CompleteSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nontrivial E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s.Countable
H : ¬interior s = ∅
⊢ False

tactic: apply lt_irrefl (ℵ₀ : Cardinal.{u})
state_before: E : Type u
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : CompleteSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nontrivial E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s.Countable
H : ¬interior s = ∅
⊢ False
state_after: E : Type u
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : CompleteSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nontrivial E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s.Countable
H : ¬interior s = ∅
⊢ ℵ₀ < ℵ₀

tactic: calc
  (ℵ₀ : Cardinal.{u}) < 𝔠 := aleph0_lt_continuum
  _ ≤ #(interior s) :=
    continuum_le_cardinal_of_isOpen 𝕜 isOpen_interior (nmem_singleton_empty.1 H)
  _ ≤ #s := mk_le_mk_of_subset interior_subset
  _ ≤ ℵ₀ := le_aleph0 hs
state_before: E : Type u
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : CompleteSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nontrivial E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s.Countable
H : ¬interior s = ∅
⊢ ℵ₀ < ℵ₀
state_after: no goals
Theorem: mul_self_zpow
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [Int.add_comm, zpow_add, zpow_one]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℤ
⊢ a * a ^ n = a ^ (n + 1)
state_after: no goals
Theorem: padicValNat.eq_zero_iff
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp only [padicValNat, dite_eq_right_iff, PartENat.get_eq_iff_eq_coe, Nat.cast_zero,
  multiplicity_eq_zero, and_imp, pos_iff_ne_zero, Ne, ← or_iff_not_imp_left]
state_before: p n : ℕ
⊢ padicValNat p n = 0 ↔ p = 1 ∨ n = 0 ∨ ¬p ∣ n
state_after: no goals
Theorem: ENNReal.inv_pow
File: Mathlib/Data/ENNReal/Inv.lean

tactic: simp only [pow_zero, inv_one]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ : ℝ≥0∞
⊢ (x✝ ^ 0)⁻¹ = x✝⁻¹ ^ 0
state_after: no goals

tactic: simp [top_pow]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ (⊤ ^ (n + 1))⁻¹ = ⊤⁻¹ ^ (n + 1)
state_after: no goals

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
⊢ (↑a ^ (n + 1))⁻¹ = (↑a)⁻¹ ^ (n + 1)
state_after: case inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ (↑0 ^ (n + 1))⁻¹ = (↑0)⁻¹ ^ (n + 1)

case inr
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
⊢ (↑a ^ (n + 1))⁻¹ = (↑a)⁻¹ ^ (n + 1)

tactic: simp [top_pow]
state_before: case inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ (↑0 ^ (n + 1))⁻¹ = (↑0)⁻¹ ^ (n + 1)
state_after: no goals

tactic: have := pow_ne_zero (n + 1) ha
state_before: case inr
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
⊢ (↑a ^ (n + 1))⁻¹ = (↑a)⁻¹ ^ (n + 1)
state_after: case inr
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
this : a ^ (n + 1) ≠ 0
⊢ (↑a ^ (n + 1))⁻¹ = (↑a)⁻¹ ^ (n + 1)

tactic: norm_cast
state_before: case inr
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
this : a ^ (n + 1) ≠ 0
⊢ (↑a ^ (n + 1))⁻¹ = (↑a)⁻¹ ^ (n + 1)
state_after: case inr
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
this : a ^ (n + 1) ≠ 0
⊢ (a ^ (n + 1))⁻¹ = a⁻¹ ^ (n + 1)

tactic: rw [inv_pow]
state_before: case inr
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
this : a ^ (n + 1) ≠ 0
⊢ (a ^ (n + 1))⁻¹ = a⁻¹ ^ (n + 1)
state_after: no goals
Theorem: nhdsWithin_sUnion
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [sUnion_eq_biUnion, nhdsWithin_biUnion hS]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
S : Set (Set α)
hS : S.Finite
a : α
⊢ 𝓝[⋃₀ S] a = ⨆ s ∈ S, 𝓝[s] a
state_after: no goals
Theorem: CategoryTheory.Limits.Types.zigzag_of_eqvGen_quot_rel
File: Mathlib/CategoryTheory/Limits/IsConnected.lean

tactic: induction h with
| rel _ _ h => exact Zigzag.of_hom <| Exists.choose h
| refl _ => exact Zigzag.refl _
| symm _ _ _ ih => exact zigzag_symmetric ih
| trans _ _ _ _ _ ih₁ ih₂ => exact ih₁.trans ih₂
state_before: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
c d : (j : C) × F.obj j
h : EqvGen (Quot.Rel F) c d
⊢ Zigzag c.fst d.fst
state_after: no goals

tactic: exact Zigzag.of_hom <| Exists.choose h
state_before: case rel
C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
c d x✝ y✝ : (j : C) × F.obj j
h : Quot.Rel F x✝ y✝
⊢ Zigzag x✝.fst y✝.fst
state_after: no goals

tactic: exact Zigzag.refl _
state_before: case refl
C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
c d x✝ : (j : C) × F.obj j
⊢ Zigzag x✝.fst x✝.fst
state_after: no goals

tactic: exact zigzag_symmetric ih
state_before: case symm
C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
c d x✝ y✝ : (j : C) × F.obj j
a✝ : EqvGen (Quot.Rel F) x✝ y✝
ih : Zigzag x✝.fst y✝.fst
⊢ Zigzag y✝.fst x✝.fst
state_after: no goals

tactic: exact ih₁.trans ih₂
state_before: case trans
C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
c d x✝ y✝ z✝ : (j : C) × F.obj j
a✝¹ : EqvGen (Quot.Rel F) x✝ y✝
a✝ : EqvGen (Quot.Rel F) y✝ z✝
ih₁ : Zigzag x✝.fst y✝.fst
ih₂ : Zigzag y✝.fst z✝.fst
⊢ Zigzag x✝.fst z✝.fst
state_after: no goals
Theorem: IsLocalization.lift_spec_mul_add
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: erw [mul_comm, ← mul_assoc, mul_add_inv_left hg, mul_comm]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
hg : ∀ (y : ↥M), IsUnit (g ↑y)
z : S
w w' v : P
⊢ ((toLocalizationWithZeroMap M S).lift g.toMonoidWithZeroHom hg) z * w + w' = v ↔
    g ((toLocalizationMap M S).sec z).1 * w + g ↑((toLocalizationMap M S).sec z).2 * w' =
      g ↑((toLocalizationMap M S).sec z).2 * v
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
hg : ∀ (y : ↥M), IsUnit (g ↑y)
z : S
w w' v : P
⊢ ↑g.toMonoidWithZeroHom ((toLocalizationWithZeroMap M S).sec z).1 * w +
        g ↑((toLocalizationWithZeroMap M S).sec z).2 * w' =
      g ↑((toLocalizationWithZeroMap M S).sec z).2 * v ↔
    g ((toLocalizationMap M S).sec z).1 * w + g ↑((toLocalizationMap M S).sec z).2 * w' =
      g ↑((toLocalizationMap M S).sec z).2 * v

tactic: rfl
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
hg : ∀ (y : ↥M), IsUnit (g ↑y)
z : S
w w' v : P
⊢ ↑g.toMonoidWithZeroHom ((toLocalizationWithZeroMap M S).sec z).1 * w +
        g ↑((toLocalizationWithZeroMap M S).sec z).2 * w' =
      g ↑((toLocalizationWithZeroMap M S).sec z).2 * v ↔
    g ((toLocalizationMap M S).sec z).1 * w + g ↑((toLocalizationMap M S).sec z).2 * w' =
      g ↑((toLocalizationMap M S).sec z).2 * v
state_after: no goals
Theorem: Real.sin_half_eq_sqrt
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← abs_sin_half, abs_of_nonneg]
state_before: x : ℝ
hl : 0 ≤ x
hr : x ≤ 2 * π
⊢ sin (x / 2) = √((1 - cos x) / 2)
state_after: x : ℝ
hl : 0 ≤ x
hr : x ≤ 2 * π
⊢ 0 ≤ sin (x / 2)

tactic: apply sin_nonneg_of_nonneg_of_le_pi <;> linarith
state_before: x : ℝ
hl : 0 ≤ x
hr : x ≤ 2 * π
⊢ 0 ≤ sin (x / 2)
state_after: no goals
Theorem: MeasureTheory.IsSetSemiring.sUnion_insert_diffFinset
File: Mathlib/MeasureTheory/SetSemiring.lean

tactic: conv_rhs => rw [← union_diff_cancel hst, ← hC.sUnion_diffFinset hs ht]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
hst : t ⊆ s
⊢ ⋃₀ insert t ↑(hC.diffFinset hs ht) = s
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
hst : t ⊆ s
⊢ ⋃₀ insert t ↑(hC.diffFinset hs ht) = t ∪ ⋃₀ ↑(hC.diffFinset hs ht)

tactic: simp only [mem_coe, sUnion_insert]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
hst : t ⊆ s
⊢ ⋃₀ insert t ↑(hC.diffFinset hs ht) = t ∪ ⋃₀ ↑(hC.diffFinset hs ht)
state_after: no goals
Theorem: eq_iff_eq_of_lt_iff_lt_of_gt_iff_gt
File: Mathlib/Order/Basic.lean

tactic: simp_rw [eq_iff_le_not_lt, ← not_lt, ltc, gtc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
P : Sort u_5
x y x' y' : α
ltc : x < y ↔ x' < y'
gtc : y < x ↔ y' < x'
⊢ x = y ↔ x' = y'
state_after: no goals
Theorem: Fin.prod_Ioi_zero
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [Ioi_zero_eq_map, Finset.prod_map, val_succEmb]
state_before: α : Type u_1
β : Type u_2
M : Type u_3
inst✝ : CommMonoid M
n : ℕ
v : Fin n.succ → M
⊢ ∏ i ∈ Ioi 0, v i = ∏ j : Fin n, v j.succ
state_after: no goals
Theorem: Multiset.count_filter_of_pos
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [quot_mk_to_coe'', filter_coe, mem_coe, coe_count, decide_eq_true_eq]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
s✝ : Multiset α
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
_l : List α
⊢ count a (filter p (Quot.mk Setoid.r _l)) = count a (Quot.mk Setoid.r _l)
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
s✝ : Multiset α
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
_l : List α
⊢ List.count a (List.filter (fun b => decide (p b)) _l) = List.count a _l

tactic: apply count_filter
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
s✝ : Multiset α
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
_l : List α
⊢ List.count a (List.filter (fun b => decide (p b)) _l) = List.count a _l
state_after: case h
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
s✝ : Multiset α
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
_l : List α
⊢ decide (p a) = true

tactic: simpa using h
state_before: case h
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
s✝ : Multiset α
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
_l : List α
⊢ decide (p a) = true
state_after: no goals
Theorem: Set.dual_ordConnectedSection
File: Mathlib/Order/Interval/Set/OrdConnectedComponent.lean

tactic: simp only [ordConnectedSection]
state_before: α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x y z : α
s : Set α
⊢ (⇑ofDual ⁻¹' s).ordConnectedSection = ⇑ofDual ⁻¹' s.ordConnectedSection
state_after: α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x y z : α
s : Set α
⊢ range (⇑ofDual ⁻¹' s).ordConnectedProj = ⇑ofDual ⁻¹' range s.ordConnectedProj

tactic: simp (config := { unfoldPartialApp := true }) only [ordConnectedProj]
state_before: α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x y z : α
s : Set α
⊢ range (⇑ofDual ⁻¹' s).ordConnectedProj = ⇑ofDual ⁻¹' range s.ordConnectedProj
state_after: α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x y z : α
s : Set α
⊢ (range fun x => ⋯.some) = ⇑ofDual ⁻¹' range fun x => ⋯.some

tactic: ext x
state_before: α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x y z : α
s : Set α
⊢ (range fun x => ⋯.some) = ⇑ofDual ⁻¹' range fun x => ⋯.some
state_after: case h
α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x✝ y z : α
s : Set α
x : αᵒᵈ
⊢ (x ∈ range fun x => ⋯.some) ↔ x ∈ ⇑ofDual ⁻¹' range fun x => ⋯.some

tactic: simp only [mem_range, Subtype.exists, mem_preimage, OrderDual.exists, dual_ordConnectedComponent,
  ofDual_toDual]
state_before: case h
α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x✝ y z : α
s : Set α
x : αᵒᵈ
⊢ (x ∈ range fun x => ⋯.some) ↔ x ∈ ⇑ofDual ⁻¹' range fun x => ⋯.some
state_after: case h
α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x✝ y z : α
s : Set α
x : αᵒᵈ
⊢ (∃ a, ∃ (h : a ∈ s), ⋯.some = x) ↔ ∃ a, ∃ (h : a ∈ s), ⋯.some = ofDual x

tactic: tauto
state_before: case h
α : Type u_1
inst✝ : LinearOrder α
s✝ t : Set α
x✝ y z : α
s : Set α
x : αᵒᵈ
⊢ (∃ a, ∃ (h : a ∈ s), ⋯.some = x) ↔ ∃ a, ∃ (h : a ∈ s), ⋯.some = ofDual x
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.ext₁
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: simp [map'_eq_hom₁, w]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C 1
left : F.left = G.left
right : F.right = G.right
w : F.hom = eqToHom left ≫ G.hom ≫ eqToHom ⋯
⊢ F.map' 0 1 ⋯ ⋯ ≫ (eqToIso right).hom = (eqToIso left).hom ≫ G.map' 0 1 ⋯ ⋯
state_after: no goals

tactic: fin_cases i <;> assumption
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C 1
left : F.left = G.left
right : F.right = G.right
w : F.hom = eqToHom left ≫ G.hom ≫ eqToHom ⋯
i : Fin (1 + 1)
⊢ F.obj i = G.obj i
state_after: no goals

tactic: fin_cases i <;> rfl
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C 1
left : F.left = G.left
right : F.right = G.right
w : F.hom = eqToHom left ≫ G.hom ≫ eqToHom ⋯
i : Fin (1 + 1)
⊢ (isoMk₁ (eqToIso left) (eqToIso right) ⋯).hom.app i = eqToHom ⋯
state_after: no goals
Theorem: CompactSpace.elim_nhds_subcover
File: Mathlib/Topology/Compactness/Compact.lean

tactic: obtain ⟨t, -, s⟩ := IsCompact.elim_nhds_subcover isCompact_univ U fun x _ => hU x
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
U : X → Set X
hU : ∀ (x : X), U x ∈ 𝓝 x
⊢ ∃ t, ⋃ x ∈ t, U x = ⊤
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t✝ : Set X
inst✝ : CompactSpace X
U : X → Set X
hU : ∀ (x : X), U x ∈ 𝓝 x
t : Finset X
s : univ ⊆ ⋃ x ∈ t, U x
⊢ ∃ t, ⋃ x ∈ t, U x = ⊤

tactic: exact ⟨t, top_unique s⟩
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t✝ : Set X
inst✝ : CompactSpace X
U : X → Set X
hU : ∀ (x : X), U x ∈ 𝓝 x
t : Finset X
s : univ ⊆ ⋃ x ∈ t, U x
⊢ ∃ t, ⋃ x ∈ t, U x = ⊤
state_after: no goals
Theorem: VitaliFamily.frequently_filterAt_iff
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: simp only [(v.filterAt_basis_closedBall x).frequently_iff, ← and_assoc, subset_def, mem_setOf]
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
P : Set α → Prop
⊢ (∃ᶠ (a : Set α) in v.filterAt x, P a) ↔ ∀ ε > 0, ∃ a ∈ v.setsAt x, a ⊆ closedBall x ε ∧ P a
state_after: no goals
Theorem: iInter_Iio_of_not_bddBelow_range
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: refine eq_empty_of_subset_empty ?_
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) = ∅
state_after: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) ⊆ ∅

tactic: rw [← iInter_Iic_eq_empty_iff.mpr hf]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) ⊆ ∅
state_after: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) ⊆ ⋂ i, Iic (f i)

tactic: gcongr
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) ⊆ ⋂ i, Iic (f i)
state_after: case h
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
i✝ : ι
⊢ Iio (f i✝) ⊆ Iic (f i✝)

tactic: exact Iio_subset_Iic_self
state_before: case h
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
i✝ : ι
⊢ Iio (f i✝) ⊆ Iic (f i✝)
state_after: no goals
Theorem: ContinuousMap.continuous_isUnit_unit
File: Mathlib/Topology/ContinuousFunction/Units.lean

tactic: refine
  continuous_induced_rng.2
    (Continuous.prod_mk f.continuous
      (MulOpposite.continuous_op.comp (continuous_iff_continuousAt.mpr fun x => ?_)))
state_before: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
⊢ Continuous fun x => ⋯.unit
state_after: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
x : X
⊢ ContinuousAt (fun x => ↑((fun x => ⋯.unit) x)⁻¹) x

tactic: have := NormedRing.inverse_continuousAt (h x).unit
state_before: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
x : X
⊢ ContinuousAt (fun x => ↑((fun x => ⋯.unit) x)⁻¹) x
state_after: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
x : X
this : ContinuousAt Ring.inverse ↑⋯.unit
⊢ ContinuousAt (fun x => ↑((fun x => ⋯.unit) x)⁻¹) x

tactic: simp only
state_before: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
x : X
this : ContinuousAt Ring.inverse ↑⋯.unit
⊢ ContinuousAt (fun x => ↑((fun x => ⋯.unit) x)⁻¹) x
state_after: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
x : X
this : ContinuousAt Ring.inverse ↑⋯.unit
⊢ ContinuousAt (fun x => ↑⋯.unit⁻¹) x

tactic: simp only [← Ring.inverse_unit, IsUnit.unit_spec] at this ⊢
state_before: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
x : X
this : ContinuousAt Ring.inverse ↑⋯.unit
⊢ ContinuousAt (fun x => ↑⋯.unit⁻¹) x
state_after: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
x : X
this : ContinuousAt Ring.inverse (f x)
⊢ ContinuousAt (fun x => Ring.inverse (f x)) x

tactic: exact this.comp (f.continuousAt x)
state_before: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
x : X
this : ContinuousAt Ring.inverse (f x)
⊢ ContinuousAt (fun x => Ring.inverse (f x)) x
state_after: no goals