1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.unbounded_lt_iff_unbounded_le
File: Mathlib/Order/Bounded.lean

tactic: simp_rw [← not_bounded_iff, bounded_le_iff_bounded_lt]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : Preorder α
inst✝ : NoMaxOrder α
⊢ Unbounded (fun x x_1 => x < x_1) s ↔ Unbounded (fun x x_1 => x ≤ x_1) s
state_after: no goals
Theorem: mfderivWithin_inter
File: Mathlib/Geometry/Manifold/MFDeriv/Basic.lean

tactic: rw [mfderivWithin, mfderivWithin, extChartAt_preimage_inter_eq, mdifferentiableWithinAt_inter ht,
  fderivWithin_inter (extChartAt_preimage_mem_nhds I ht)]
state_before: 𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedSpace 𝕜 E
H : Type u_3
inst✝¹² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹¹ : TopologicalSpace M
inst✝¹⁰ : ChartedSpace H M
E' : Type u_5
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝⁷ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : ChartedSpace H' M'
E'' : Type u_8
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : NormedSpace 𝕜 E''
H'' : Type u_9
inst✝² : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
M'' : Type u_10
inst✝¹ : TopologicalSpace M''
inst✝ : ChartedSpace H'' M''
f f₀ f₁ : M → M'
x : M
s t : Set M
g : M' → M''
u : Set M'
Is : SmoothManifoldWithCorners I M
I's : SmoothManifoldWithCorners I' M'
I''s : SmoothManifoldWithCorners I'' M''
f' f₀' f₁' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)
g' : TangentSpace I' (f x) →L[𝕜] TangentSpace I'' (g (f x))
ht : t ∈ 𝓝 x
⊢ mfderivWithin I I' f (s ∩ t) x = mfderivWithin I I' f s x
state_after: no goals
Theorem: ContinuousLinearMap.hasStrictDerivAt_of_bilinear
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simpa using
  (B.hasStrictFDerivAt_of_bilinear hu.hasStrictFDerivAt hv.hasStrictFDerivAt).hasStrictDerivAt
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
B : E →L[𝕜] F →L[𝕜] G
u : 𝕜 → E
v : 𝕜 → F
u' : E
v' : F
hu : HasStrictDerivAt u u' x
hv : HasStrictDerivAt v v' x
⊢ HasStrictDerivAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) x
state_after: no goals
Theorem: Sum.LiftRel.mono
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

tactic: cases h
state_before: α✝¹ : Type u_1
α✝ : Type u_2
r₁ r₂ : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s₁ s₂ : β✝¹ → β✝ → Prop
x : α✝¹ ⊕ β✝¹
y : α✝ ⊕ β✝
hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b
hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b
h : LiftRel r₁ s₁ x y
⊢ LiftRel r₂ s₂ x y
state_after: case inl
α✝¹ : Type u_1
α✝ : Type u_2
r₁ r₂ : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s₁ s₂ : β✝¹ → β✝ → Prop
hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b
hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b
a✝¹ : α✝¹
c✝ : α✝
a✝ : r₁ a✝¹ c✝
⊢ LiftRel r₂ s₂ (inl a✝¹) (inl c✝)

case inr
α✝¹ : Type u_1
α✝ : Type u_2
r₁ r₂ : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s₁ s₂ : β✝¹ → β✝ → Prop
hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b
hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b
b✝ : β✝¹
d✝ : β✝
a✝ : s₁ b✝ d✝
⊢ LiftRel r₂ s₂ (inr b✝) (inr d✝)

tactic: exact LiftRel.inl (hr _ _ ‹_›)
state_before: case inl
α✝¹ : Type u_1
α✝ : Type u_2
r₁ r₂ : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s₁ s₂ : β✝¹ → β✝ → Prop
hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b
hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b
a✝¹ : α✝¹
c✝ : α✝
a✝ : r₁ a✝¹ c✝
⊢ LiftRel r₂ s₂ (inl a✝¹) (inl c✝)
state_after: no goals

tactic: exact LiftRel.inr (hs _ _ ‹_›)
state_before: case inr
α✝¹ : Type u_1
α✝ : Type u_2
r₁ r₂ : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s₁ s₂ : β✝¹ → β✝ → Prop
hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b
hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b
b✝ : β✝¹
d✝ : β✝
a✝ : s₁ b✝ d✝
⊢ LiftRel r₂ s₂ (inr b✝) (inr d✝)
state_after: no goals
Theorem: MulAction.isFixedBlock_top
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

tactic: simp only [Set.top_eq_univ, Set.smul_set_univ]
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
x✝ : G
⊢ x✝ • ⊤ = ⊤
state_after: no goals
Theorem: IsGLB.biUnion_Ici_eq_Ici
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: refine (iUnion₂_subset fun x hx => ?_).antisymm fun x hx => ?_
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
⊢ ⋃ x ∈ s, Ici x = Ici a
state_after: case refine_1
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
x : α
hx : x ∈ s
⊢ Ici x ⊆ Ici a

case refine_2
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
x : α
hx : x ∈ Ici a
⊢ x ∈ ⋃ i ∈ s, Ici i

tactic: exact Ici_subset_Ici.mpr (mem_lowerBounds.mp a_glb.1 x hx)
state_before: case refine_1
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
x : α
hx : x ∈ s
⊢ Ici x ⊆ Ici a
state_after: no goals

tactic: exact mem_iUnion₂.mpr ⟨a, a_mem, hx⟩
state_before: case refine_2
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
x : α
hx : x ∈ Ici a
⊢ x ∈ ⋃ i ∈ s, Ici i
state_after: no goals
Theorem: CliffordAlgebra.ofProd_ι_mk
File: Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean

tactic: rw [ofProd, lift_ι_apply]
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
N : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup N
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R N
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Qₙ : QuadraticForm R N
m₁ : M₁
m₂ : M₂
⊢ (ofProd Q₁ Q₂) ((ι (Q₁.prod Q₂)) (m₁, m₂)) = (ι Q₁) m₁ ᵍ⊗ₜ[R] 1 + 1 ᵍ⊗ₜ[R] (ι Q₂) m₂
state_after: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
N : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup N
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R N
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Qₙ : QuadraticForm R N
m₁ : M₁
m₂ : M₂
⊢ (((GradedTensorProduct.includeLeft (evenOdd Q₁) (evenOdd Q₂)).toLinearMap ∘ₗ
            (evenOdd Q₁ 1).subtype ∘ₗ LinearMap.codRestrict (evenOdd Q₁ 1) (ι Q₁) ⋯).coprod
        ((GradedTensorProduct.includeRight (evenOdd Q₁) (evenOdd Q₂)).toLinearMap ∘ₗ
          (evenOdd Q₂ 1).subtype ∘ₗ LinearMap.codRestrict (evenOdd Q₂ 1) (ι Q₂) ⋯))
      (m₁, m₂) =
    (ι Q₁) m₁ ᵍ⊗ₜ[R] 1 + 1 ᵍ⊗ₜ[R] (ι Q₂) m₂

tactic: rfl
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
N : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup N
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R N
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Qₙ : QuadraticForm R N
m₁ : M₁
m₂ : M₂
⊢ (((GradedTensorProduct.includeLeft (evenOdd Q₁) (evenOdd Q₂)).toLinearMap ∘ₗ
            (evenOdd Q₁ 1).subtype ∘ₗ LinearMap.codRestrict (evenOdd Q₁ 1) (ι Q₁) ⋯).coprod
        ((GradedTensorProduct.includeRight (evenOdd Q₁) (evenOdd Q₂)).toLinearMap ∘ₗ
          (evenOdd Q₂ 1).subtype ∘ₗ LinearMap.codRestrict (evenOdd Q₂ 1) (ι Q₂) ⋯))
      (m₁, m₂) =
    (ι Q₁) m₁ ᵍ⊗ₜ[R] 1 + 1 ᵍ⊗ₜ[R] (ι Q₂) m₂
state_after: no goals
Theorem: CategoryTheory.isSeparator_sigma_of_isSeparator
File: Mathlib/CategoryTheory/Generator.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
b : β
hb : IsSeparator (f b)
⊢ {f b} ⊆ Set.range f
state_after: no goals
Theorem: List.get_splitWrtComposition
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: simp [getElem_splitWrtComposition]
state_before: n : ℕ
α : Type u_1
l : List α
c : Composition n
i : Fin (l.splitWrtComposition c).length
⊢ (l.splitWrtComposition c).get i = drop (c.sizeUpTo ↑i) (take (c.sizeUpTo (↑i + 1)) l)
state_after: no goals
Theorem: Multiset.revzip_powersetAux'
File: Mathlib/Data/Multiset/Powerset.lean

tactic: rw [revzip, powersetAux', ← map_reverse, zip_map, ← revzip, List.mem_map] at h
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : x ∈ (powersetAux' l).revzip
⊢ x.1 + x.2 = ↑l
state_after: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a ∈ l.sublists'.revzip, Prod.map ofList ofList a = x
⊢ x.1 + x.2 = ↑l

tactic: simp only [Prod.map_apply, Prod.exists] at h
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a ∈ l.sublists'.revzip, Prod.map ofList ofList a = x
⊢ x.1 + x.2 = ↑l
state_after: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a b, (a, b) ∈ l.sublists'.revzip ∧ (↑a, ↑b) = x
⊢ x.1 + x.2 = ↑l

tactic: rcases h with ⟨l₁, l₂, h, rfl, rfl⟩
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a b, (a, b) ∈ l.sublists'.revzip ∧ (↑a, ↑b) = x
⊢ x.1 + x.2 = ↑l
state_after: case intro.intro.intro.refl
α : Type u_1
l l₁ l₂ : List α
h : (l₁, l₂) ∈ l.sublists'.revzip
⊢ (↑l₁, ↑l₂).1 + (↑l₁, ↑l₂).2 = ↑l

tactic: exact Quot.sound (revzip_sublists' _ _ _ h)
state_before: case intro.intro.intro.refl
α : Type u_1
l l₁ l₂ : List α
h : (l₁, l₂) ∈ l.sublists'.revzip
⊢ (↑l₁, ↑l₂).1 + (↑l₁, ↑l₂).2 = ↑l
state_after: no goals
Theorem: IsMulFreimanHom.mul
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

tactic: rw [Pi.mul_def, prod_map_mul, prod_map_mul, h₁.map_prod_eq_map_prod hsA htA hs ht h,
  h₂.map_prod_eq_map_prod hsA htA hs ht h]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
h₁ : IsMulFreimanHom n A B₁ f₁
h₂ : IsMulFreimanHom n A B₂ f₂
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
h : s.prod = t.prod
⊢ (map (f₁ * f₂) s).prod = (map (f₁ * f₂) t).prod
state_after: no goals
Theorem: List.stronglyMeasurable_prod
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simpa only [← Pi.list_prod_apply] using l.stronglyMeasurable_prod' hl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l : List (α → M)
hl : ∀ f ∈ l, StronglyMeasurable f
⊢ StronglyMeasurable fun x => (List.map (fun f => f x) l).prod
state_after: no goals
Theorem: ZNum.of_to_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← ofInt'_eq, of_to_int']
state_before: α : Type u_1
n : ZNum
⊢ ↑↑n = n
state_after: no goals
Theorem: Monoid.lcm_orderOf_dvd_exponent
File: Mathlib/GroupTheory/Exponent.lean

tactic: apply Finset.lcm_dvd
state_before: G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ Finset.univ.lcm orderOf ∣ exponent G
state_after: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ ∀ b ∈ Finset.univ, orderOf b ∣ exponent G

tactic: intro g _
state_before: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ ∀ b ∈ Finset.univ, orderOf b ∣ exponent G
state_after: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
g : G
a✝ : g ∈ Finset.univ
⊢ orderOf g ∣ exponent G

tactic: exact order_dvd_exponent g
state_before: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
g : G
a✝ : g ∈ Finset.univ
⊢ orderOf g ∣ exponent G
state_after: no goals
Theorem: same_sub_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: simpa only [← @div_self _ _ b h] using (div_sub_div_same b a b).symm
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : DivisionRing K
a✝ b✝ c d a b : K
h : b ≠ 0
⊢ (b - a) / b = 1 - a / b
state_after: no goals
Theorem: tendsto_atBot_ciInf
File: Mathlib/Topology/Order/MonotoneConvergence.lean

tactic: convert tendsto_atTop_ciSup h_mono.dual hbdd.dual using 1
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : ConditionallyCompleteLattice α
inst✝ : InfConvergenceClass α
f : ι → α
a : α
h_mono : Monotone f
hbdd : BddBelow (range f)
⊢ Tendsto f atBot (𝓝 (⨅ i, f i))
state_after: no goals
Theorem: Coheyting.boundary_sup_le
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [boundary, inf_sup_right]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ ∂ (a ⊔ b) ≤ ∂ a ⊔ ∂ b
state_after: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ a ⊓ ￢(a ⊔ b) ⊔ b ⊓ ￢(a ⊔ b) ≤ ∂ a ⊔ ∂ b

tactic: exact
  sup_le_sup (inf_le_inf_left _ <| hnot_anti le_sup_left)
    (inf_le_inf_left _ <| hnot_anti le_sup_right)
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ a ⊓ ￢(a ⊔ b) ⊔ b ⊓ ￢(a ⊔ b) ≤ ∂ a ⊔ ∂ b
state_after: no goals
Theorem: isCauSeq_neg
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: simp only [IsCauSeq, Pi.neg_apply, ← neg_sub', abv_neg]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
⊢ IsCauSeq abv (-f) ↔ IsCauSeq abv f
state_after: no goals
Theorem: isAtomistic_dual_iff_isCoatomistic
File: Mathlib/Order/Atoms.lean

tactic: apply h.eq_sSup_atoms
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : CompleteLattice α
h : IsAtomistic αᵒᵈ
b : α
⊢ ∃ s, b = sInf s ∧ ∀ a ∈ s, IsCoatom a
state_after: no goals

tactic: apply h.eq_sInf_coatoms
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : CompleteLattice α
h : IsCoatomistic α
b : αᵒᵈ
⊢ ∃ s, b = sSup s ∧ ∀ a ∈ s, IsAtom a
state_after: no goals
Theorem: ae_eq_trim_of_measurable
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: rwa [Filter.EventuallyEq, ae_iff, trim_measurableSet_eq hm _]
state_before: α✝¹ : Type u_1
G : Type u_2
α✝ : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α✝
f✝ g✝ : α✝ → G
μ✝ : Measure α✝
α : Type u_4
E : Type u_5
m m0 : MeasurableSpace α
μ : Measure α
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
hm : m ≤ m0
f g : α → E
hf : Measurable f
hg : Measurable g
hfg : f =ᶠ[ae μ] g
⊢ f =ᶠ[ae (μ.trim hm)] g
state_after: α✝¹ : Type u_1
G : Type u_2
α✝ : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α✝
f✝ g✝ : α✝ → G
μ✝ : Measure α✝
α : Type u_4
E : Type u_5
m m0 : MeasurableSpace α
μ : Measure α
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
hm : m ≤ m0
f g : α → E
hf : Measurable f
hg : Measurable g
hfg : f =ᶠ[ae μ] g
⊢ MeasurableSet {a | ¬f a = g a}

tactic: exact @MeasurableSet.compl α _ m (@measurableSet_eq_fun α m E _ _ _ _ _ _ hf hg)
state_before: α✝¹ : Type u_1
G : Type u_2
α✝ : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α✝
f✝ g✝ : α✝ → G
μ✝ : Measure α✝
α : Type u_4
E : Type u_5
m m0 : MeasurableSpace α
μ : Measure α
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
hm : m ≤ m0
f g : α → E
hf : Measurable f
hg : Measurable g
hfg : f =ᶠ[ae μ] g
⊢ MeasurableSet {a | ¬f a = g a}
state_after: no goals
Theorem: List.Sorted.head!_le
File: Mathlib/Data/List/Sort.lean

tactic: rw [← List.cons_head!_tail (List.ne_nil_of_mem ha)] at h ha
state_before: α : Type u
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝¹ : Inhabited α
inst✝ : Preorder α
a : α
l : List α
h : Sorted (fun x x_1 => x < x_1) l
ha : a ∈ l
⊢ l.head! ≤ a
state_after: α : Type u
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝¹ : Inhabited α
inst✝ : Preorder α
a : α
l : List α
h : Sorted (fun x x_1 => x < x_1) (l.head! :: l.tail)
ha : a ∈ l.head! :: l.tail
⊢ l.head! ≤ a

tactic: cases ha
state_before: α : Type u
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝¹ : Inhabited α
inst✝ : Preorder α
a : α
l : List α
h : Sorted (fun x x_1 => x < x_1) (l.head! :: l.tail)
ha : a ∈ l.head! :: l.tail
⊢ l.head! ≤ a
state_after: case head
α : Type u
r : α → α → Prop
a : α
l✝ : List α
inst✝¹ : Inhabited α
inst✝ : Preorder α
l : List α
h : Sorted (fun x x_1 => x < x_1) (l.head! :: l.tail)
⊢ l.head! ≤ l.head!

case tail
α : Type u
r : α → α → Prop
a✝¹ : α
l✝ : List α
inst✝¹ : Inhabited α
inst✝ : Preorder α
a : α
l : List α
h : Sorted (fun x x_1 => x < x_1) (l.head! :: l.tail)
a✝ : Mem a l.tail
⊢ l.head! ≤ a

tactic: exact le_rfl
state_before: case head
α : Type u
r : α → α → Prop
a : α
l✝ : List α
inst✝¹ : Inhabited α
inst✝ : Preorder α
l : List α
h : Sorted (fun x x_1 => x < x_1) (l.head! :: l.tail)
⊢ l.head! ≤ l.head!
state_after: no goals

tactic: exact le_of_lt (rel_of_sorted_cons h a (by assumption))
state_before: case tail
α : Type u
r : α → α → Prop
a✝¹ : α
l✝ : List α
inst✝¹ : Inhabited α
inst✝ : Preorder α
a : α
l : List α
h : Sorted (fun x x_1 => x < x_1) (l.head! :: l.tail)
a✝ : Mem a l.tail
⊢ l.head! ≤ a
state_after: no goals

tactic: assumption
state_before: α : Type u
r : α → α → Prop
a✝¹ : α
l✝ : List α
inst✝¹ : Inhabited α
inst✝ : Preorder α
a : α
l : List α
h : Sorted (fun x x_1 => x < x_1) (l.head! :: l.tail)
a✝ : Mem a l.tail
⊢ a ∈ l.tail
state_after: no goals
Theorem: NumberField.mixedEmbedding.convexBodyLT'_neg_mem
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

tactic: simp [Set.mem_prod, Prod.fst_neg, Set.mem_pi, Set.mem_univ, Pi.neg_apply,
  mem_ball_zero_iff, norm_neg, Real.norm_eq_abs, forall_true_left, Subtype.forall,
  Prod.snd_neg, Complex.norm_eq_abs] at hx ⊢
state_before: K : Type u_1
inst✝ : Field K
f : InfinitePlace K → ℝ≥0
w₀ : { w // w.IsComplex }
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx : x ∈ convexBodyLT' K f w₀
⊢ -x ∈ convexBodyLT' K f w₀
state_after: K : Type u_1
inst✝ : Field K
f : InfinitePlace K → ℝ≥0
w₀ : { w // w.IsComplex }
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx :
  (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex),
      x.2 ⟨a, b⟩ ∈ if ⟨a, b⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a) ^ 2} else ball 0 ↑(f a)
⊢ (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex),
      -x.2 ⟨a, b⟩ ∈ if ⟨a, b⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a) ^ 2} else ball 0 ↑(f a)

tactic: convert hx using 3
state_before: K : Type u_1
inst✝ : Field K
f : InfinitePlace K → ℝ≥0
w₀ : { w // w.IsComplex }
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx :
  (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex),
      x.2 ⟨a, b⟩ ∈ if ⟨a, b⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a) ^ 2} else ball 0 ↑(f a)
⊢ (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex),
      -x.2 ⟨a, b⟩ ∈ if ⟨a, b⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a) ^ 2} else ball 0 ↑(f a)
state_after: case h.e'_2.h.h.a
K : Type u_1
inst✝ : Field K
f : InfinitePlace K → ℝ≥0
w₀ : { w // w.IsComplex }
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx :
  (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex),
      x.2 ⟨a, b⟩ ∈ if ⟨a, b⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a) ^ 2} else ball 0 ↑(f a)
a✝¹ : InfinitePlace K
a✝ : a✝¹.IsComplex
⊢ (-x.2 ⟨a✝¹, a✝⟩ ∈ if ⟨a✝¹, a✝⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a✝¹) ^ 2} else ball 0 ↑(f a✝¹)) ↔
    x.2 ⟨a✝¹, a✝⟩ ∈ if ⟨a✝¹, a✝⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a✝¹) ^ 2} else ball 0 ↑(f a✝¹)

tactic: split_ifs <;> simp
state_before: case h.e'_2.h.h.a
K : Type u_1
inst✝ : Field K
f : InfinitePlace K → ℝ≥0
w₀ : { w // w.IsComplex }
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx :
  (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex),
      x.2 ⟨a, b⟩ ∈ if ⟨a, b⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a) ^ 2} else ball 0 ↑(f a)
a✝¹ : InfinitePlace K
a✝ : a✝¹.IsComplex
⊢ (-x.2 ⟨a✝¹, a✝⟩ ∈ if ⟨a✝¹, a✝⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a✝¹) ^ 2} else ball 0 ↑(f a✝¹)) ↔
    x.2 ⟨a✝¹, a✝⟩ ∈ if ⟨a✝¹, a✝⟩ = w₀ then {x | |x.re| < 1 ∧ |x.im| < ↑(f a✝¹) ^ 2} else ball 0 ↑(f a✝¹)
state_after: no goals
Theorem: Set.iUnion_pi_of_monotone
File: Mathlib/Data/Set/Finite.lean

tactic: simp only [pi_def, biInter_eq_iInter, preimage_iUnion]
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : I.Finite
hs : ∀ i ∈ I, Monotone (s i)
⊢ (⋃ j, I.pi fun i => s i j) = I.pi fun i => ⋃ j, s i j
state_after: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : I.Finite
hs : ∀ i ∈ I, Monotone (s i)
⊢ ⋃ j, ⋂ x, eval ↑x ⁻¹' s (↑x) j = ⋂ x, ⋃ i, eval ↑x ⁻¹' s (↑x) i

tactic: haveI := hI.fintype.finite
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : I.Finite
hs : ∀ i ∈ I, Monotone (s i)
⊢ ⋃ j, ⋂ x, eval ↑x ⁻¹' s (↑x) j = ⋂ x, ⋃ i, eval ↑x ⁻¹' s (↑x) i
state_after: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : I.Finite
hs : ∀ i ∈ I, Monotone (s i)
this : Finite ↑I
⊢ ⋃ j, ⋂ x, eval ↑x ⁻¹' s (↑x) j = ⋂ x, ⋃ i, eval ↑x ⁻¹' s (↑x) i

tactic: refine iUnion_iInter_of_monotone (ι' := ι') (fun (i : I) j₁ j₂ h => ?_)
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : I.Finite
hs : ∀ i ∈ I, Monotone (s i)
this : Finite ↑I
⊢ ⋃ j, ⋂ x, eval ↑x ⁻¹' s (↑x) j = ⋂ x, ⋃ i, eval ↑x ⁻¹' s (↑x) i
state_after: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : I.Finite
hs : ∀ i ∈ I, Monotone (s i)
this : Finite ↑I
i : ↑I
j₁ j₂ : ι'
h : j₁ ≤ j₂
⊢ eval ↑i ⁻¹' s (↑i) j₁ ≤ eval ↑i ⁻¹' s (↑i) j₂

tactic: exact preimage_mono <| hs i i.2 h
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : I.Finite
hs : ∀ i ∈ I, Monotone (s i)
this : Finite ↑I
i : ↑I
j₁ j₂ : ι'
h : j₁ ≤ j₂
⊢ eval ↑i ⁻¹' s (↑i) j₁ ≤ eval ↑i ⁻¹' s (↑i) j₂
state_after: no goals
Theorem: iteratedDerivWithin_add
File: Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean

tactic: simp_rw [iteratedDerivWithin, iteratedFDerivWithin_add_apply hf hg h hx,
  ContinuousMultilinearMap.add_apply]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
n : ℕ
x : 𝕜
s : Set 𝕜
hx : x ∈ s
h : UniqueDiffOn 𝕜 s
f g : 𝕜 → F
hf : ContDiffOn 𝕜 (↑n) f s
hg : ContDiffOn 𝕜 (↑n) g s
⊢ iteratedDerivWithin n (f + g) s x = iteratedDerivWithin n f s x + iteratedDerivWithin n g s x
state_after: no goals