1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.ConvolutionExists.distrib_add
File: Mathlib/Analysis/Convolution.lean

tactic: ext x
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup E'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : NormedSpace 𝕜 E''
inst✝³ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝² : MeasurableSpace G
μ ν : Measure G
inst✝¹ : NormedSpace ℝ F
inst✝ : AddGroup G
hfg : ConvolutionExists f g L μ
hfg' : ConvolutionExists f g' L μ
⊢ f ⋆[L, μ] (g + g') = f ⋆[L, μ] g + f ⋆[L, μ] g'
state_after: case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup E'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x✝ x' : G
y y' : E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : NormedSpace 𝕜 E''
inst✝³ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝² : MeasurableSpace G
μ ν : Measure G
inst✝¹ : NormedSpace ℝ F
inst✝ : AddGroup G
hfg : ConvolutionExists f g L μ
hfg' : ConvolutionExists f g' L μ
x : G
⊢ (f ⋆[L, μ] (g + g')) x = (f ⋆[L, μ] g + f ⋆[L, μ] g') x

tactic: exact (hfg x).distrib_add (hfg' x)
state_before: case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup E'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x✝ x' : G
y y' : E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : NormedSpace 𝕜 E''
inst✝³ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝² : MeasurableSpace G
μ ν : Measure G
inst✝¹ : NormedSpace ℝ F
inst✝ : AddGroup G
hfg : ConvolutionExists f g L μ
hfg' : ConvolutionExists f g' L μ
x : G
⊢ (f ⋆[L, μ] (g + g')) x = (f ⋆[L, μ] g + f ⋆[L, μ] g') x
state_after: no goals
Theorem: Int.card_fintype_Ioo_of_lt
File: Mathlib/Data/Int/Interval.lean

tactic: rw [card_fintype_Ioo, sub_sub, toNat_sub_of_le h]
state_before: a b : ℤ
h : a < b
⊢ ↑(Fintype.card ↑(Set.Ioo a b)) = b - a - 1
state_after: no goals
Theorem: Relation.reflTransGen_iff_eq_or_transGen
File: Mathlib/Logic/Relation.lean

tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ ReflTransGen r a b ↔ b = a ∨ TransGen r a b
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : ReflTransGen r a b
⊢ b = a ∨ TransGen r a b

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : b = a ∨ TransGen r a b
⊢ ReflTransGen r a b

tactic: cases' h with c _ hac hcb
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : ReflTransGen r a b
⊢ b = a ∨ TransGen r a b
state_after: case refine_1.refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a c d : α
⊢ a = a ∨ TransGen r a a

case refine_1.tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c✝ d c : α
hac : ReflTransGen r a c
hcb : r c b
⊢ b = a ∨ TransGen r a b

tactic: exact Or.inl rfl
state_before: case refine_1.refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a c d : α
⊢ a = a ∨ TransGen r a a
state_after: no goals

tactic: exact Or.inr (TransGen.tail' hac hcb)
state_before: case refine_1.tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c✝ d c : α
hac : ReflTransGen r a c
hcb : r c b
⊢ b = a ∨ TransGen r a b
state_after: no goals

tactic: rcases h with (rfl | h)
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : b = a ∨ TransGen r a b
⊢ ReflTransGen r a b
state_after: case refine_2.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
b c d : α
⊢ ReflTransGen r b b

case refine_2.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : TransGen r a b
⊢ ReflTransGen r a b

tactic: rfl
state_before: case refine_2.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
b c d : α
⊢ ReflTransGen r b b
state_after: no goals

tactic: exact h.to_reflTransGen
state_before: case refine_2.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : TransGen r a b
⊢ ReflTransGen r a b
state_after: no goals
Theorem: Complex.div_re
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [div_eq_mul_inv, mul_assoc, sub_eq_add_neg]
state_before: z w : ℂ
⊢ (z / w).re = z.re * w.re / normSq w + z.im * w.im / normSq w
state_after: no goals
Theorem: memℓp_zero_iff
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: dsimp [Memℓp]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ Memℓp f 0 ↔ {i | f i ≠ 0}.Finite
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ (if 0 = 0 then {i | ¬f i = 0}.Finite else Summable fun i => ‖f i‖ ^ 0) ↔ {i | ¬f i = 0}.Finite

tactic: rw [if_pos rfl]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ (if 0 = 0 then {i | ¬f i = 0}.Finite else Summable fun i => ‖f i‖ ^ 0) ↔ {i | ¬f i = 0}.Finite
state_after: no goals
Theorem: CategoryTheory.InjectiveResolution.iso_inv_naturality
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

tactic: rw [← cancel_mono (J.iso).hom, Category.assoc, iso_hom_naturality f I J φ comm,
  Iso.inv_hom_id_assoc, Category.assoc, Iso.inv_hom_id, Category.comp_id]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasInjectiveResolutions C
X Y : C
f : X ⟶ Y
I : InjectiveResolution X
J : InjectiveResolution Y
φ : I.cocomplex ⟶ J.cocomplex
comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0
⊢ I.iso.inv ≫ (injectiveResolutions C).map f = (HomotopyCategory.quotient C (ComplexShape.up ℕ)).map φ ≫ J.iso.inv
state_after: no goals
Theorem: Cardinal.bsup_lt_ord_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [hc.cof_eq]
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{max u_2 u_3}
f : (a : Ordinal.{max u_2 u_3}) → a < o → Ordinal.{max u_2 u_3}
c : Cardinal.{max u_2 u_3}
hc : c.IsRegular
hι : o.card < c
⊢ o.card < c.ord.cof
state_after: no goals
Theorem: Setoid.eq_eqv_class_of_mem
File: Mathlib/Data/Setoid/Partition.lean

tactic: ext x
state_before: α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
⊢ s = {x | (mkClasses c H).Rel x y}
state_after: case h
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
⊢ x ∈ s ↔ x ∈ {x | (mkClasses c H).Rel x y}

tactic: constructor
state_before: case h
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
⊢ x ∈ s ↔ x ∈ {x | (mkClasses c H).Rel x y}
state_after: case h.mp
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
⊢ x ∈ s → x ∈ {x | (mkClasses c H).Rel x y}

case h.mpr
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
⊢ x ∈ {x | (mkClasses c H).Rel x y} → x ∈ s

tactic: intro hx _s' hs' hx'
state_before: case h.mp
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
⊢ x ∈ s → x ∈ {x | (mkClasses c H).Rel x y}
state_after: case h.mp
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
hx : x ∈ s
_s' : Set α
hs' : _s' ∈ c
hx' : x ∈ _s'
⊢ y ∈ _s'

tactic: rwa [eq_of_mem_eqv_class H hs' hx' hs hx]
state_before: case h.mp
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
hx : x ∈ s
_s' : Set α
hs' : _s' ∈ c
hx' : x ∈ _s'
⊢ y ∈ _s'
state_after: no goals

tactic: intro hx
state_before: case h.mpr
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
⊢ x ∈ {x | (mkClasses c H).Rel x y} → x ∈ s
state_after: case h.mpr
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
hx : x ∈ {x | (mkClasses c H).Rel x y}
⊢ x ∈ s

tactic: obtain ⟨b', ⟨hc, hb'⟩, _⟩ := H x
state_before: case h.mpr
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
hx : x ∈ {x | (mkClasses c H).Rel x y}
⊢ x ∈ s
state_after: case h.mpr.intro.intro.intro
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
hx : x ∈ {x | (mkClasses c H).Rel x y}
b' : Set α
right✝ : ∀ (y : Set α), (fun b => b ∈ c ∧ x ∈ b) y → y = b'
hc : b' ∈ c
hb' : x ∈ b'
⊢ x ∈ s

tactic: rwa [eq_of_mem_eqv_class H hs hy hc (hx b' hc hb')]
state_before: case h.mpr.intro.intro.intro
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b, b ∈ c ∧ a ∈ b
s : Set α
y : α
hs : s ∈ c
hy : y ∈ s
x : α
hx : x ∈ {x | (mkClasses c H).Rel x y}
b' : Set α
right✝ : ∀ (y : Set α), (fun b => b ∈ c ∧ x ∈ b) y → y = b'
hc : b' ∈ c
hb' : x ∈ b'
⊢ x ∈ s
state_after: no goals
Theorem: ENNReal.toReal_eq_zero_iff
File: Mathlib/Data/ENNReal/Basic.lean

tactic: simp [ENNReal.toReal, toNNReal_eq_zero_iff]
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ x.toReal = 0 ↔ x = 0 ∨ x = ⊤
state_after: no goals
Theorem: galRestrictHom_symm_algebraMap_apply
File: Mathlib/RingTheory/IntegralRestrict.lean

tactic: have := (IsFractionRing.injective A K).isDomain
state_before: A : Type u_1
K : Type u_2
L : Type u_3
B : Type u_4
inst✝¹³ : CommRing A
inst✝¹² : CommRing B
inst✝¹¹ : Algebra A B
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : Algebra A K
inst✝⁷ : IsFractionRing A K
inst✝⁶ : Algebra B L
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra A L
inst✝³ : IsScalarTower A B L
inst✝² : IsScalarTower A K L
inst✝¹ : IsIntegralClosure B A L
inst✝ : FiniteDimensional K L
σ : B →ₐ[A] B
x : B
⊢ ((galRestrictHom A K L B).symm σ) ((algebraMap B L) x) = (algebraMap B L) (σ x)
state_after: A : Type u_1
K : Type u_2
L : Type u_3
B : Type u_4
inst✝¹³ : CommRing A
inst✝¹² : CommRing B
inst✝¹¹ : Algebra A B
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : Algebra A K
inst✝⁷ : IsFractionRing A K
inst✝⁶ : Algebra B L
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra A L
inst✝³ : IsScalarTower A B L
inst✝² : IsScalarTower A K L
inst✝¹ : IsIntegralClosure B A L
inst✝ : FiniteDimensional K L
σ : B →ₐ[A] B
x : B
this : IsDomain A
⊢ ((galRestrictHom A K L B).symm σ) ((algebraMap B L) x) = (algebraMap B L) (σ x)

tactic: have := IsIntegralClosure.isLocalization A K L B
state_before: A : Type u_1
K : Type u_2
L : Type u_3
B : Type u_4
inst✝¹³ : CommRing A
inst✝¹² : CommRing B
inst✝¹¹ : Algebra A B
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : Algebra A K
inst✝⁷ : IsFractionRing A K
inst✝⁶ : Algebra B L
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra A L
inst✝³ : IsScalarTower A B L
inst✝² : IsScalarTower A K L
inst✝¹ : IsIntegralClosure B A L
inst✝ : FiniteDimensional K L
σ : B →ₐ[A] B
x : B
this : IsDomain A
⊢ ((galRestrictHom A K L B).symm σ) ((algebraMap B L) x) = (algebraMap B L) (σ x)
state_after: A : Type u_1
K : Type u_2
L : Type u_3
B : Type u_4
inst✝¹³ : CommRing A
inst✝¹² : CommRing B
inst✝¹¹ : Algebra A B
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : Algebra A K
inst✝⁷ : IsFractionRing A K
inst✝⁶ : Algebra B L
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra A L
inst✝³ : IsScalarTower A B L
inst✝² : IsScalarTower A K L
inst✝¹ : IsIntegralClosure B A L
inst✝ : FiniteDimensional K L
σ : B →ₐ[A] B
x : B
this✝ : IsDomain A
this : IsLocalization (Algebra.algebraMapSubmonoid B A⁰) L
⊢ ((galRestrictHom A K L B).symm σ) ((algebraMap B L) x) = (algebraMap B L) (σ x)

tactic: simp [galRestrictHom, galLift, Subalgebra.algebraMap_eq]
state_before: A : Type u_1
K : Type u_2
L : Type u_3
B : Type u_4
inst✝¹³ : CommRing A
inst✝¹² : CommRing B
inst✝¹¹ : Algebra A B
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : Algebra A K
inst✝⁷ : IsFractionRing A K
inst✝⁶ : Algebra B L
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra A L
inst✝³ : IsScalarTower A B L
inst✝² : IsScalarTower A K L
inst✝¹ : IsIntegralClosure B A L
inst✝ : FiniteDimensional K L
σ : B →ₐ[A] B
x : B
this✝ : IsDomain A
this : IsLocalization (Algebra.algebraMapSubmonoid B A⁰) L
⊢ ((galRestrictHom A K L B).symm σ) ((algebraMap B L) x) = (algebraMap B L) (σ x)
state_after: no goals
Theorem: TopCat.Presheaf.Pushforward.id_inv_app'
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: dsimp [id]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ℱ : Presheaf C X
U : Set ↑X
p : IsOpen U
⊢ (id ℱ).inv.app { unop := { carrier := U, is_open' := p } } = ℱ.map (𝟙 { unop := { carrier := U, is_open' := p } })
state_after: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ℱ : Presheaf C X
U : Set ↑X
p : IsOpen U
⊢ 𝟙 (ℱ.obj { unop := { carrier := U, is_open' := p } }) ≫ ℱ.map (𝟙 { unop := { carrier := U, is_open' := p } }) =
    ℱ.map (𝟙 { unop := { carrier := U, is_open' := p } })

tactic: simp [CategoryStruct.comp]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ℱ : Presheaf C X
U : Set ↑X
p : IsOpen U
⊢ 𝟙 (ℱ.obj { unop := { carrier := U, is_open' := p } }) ≫ ℱ.map (𝟙 { unop := { carrier := U, is_open' := p } }) =
    ℱ.map (𝟙 { unop := { carrier := U, is_open' := p } })
state_after: no goals
Theorem: Ordnode.eraseMax.valid
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [Valid.dual_iff, dual_eraseMax]
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
h : t.Valid
⊢ t.eraseMax.Valid
state_after: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
h : t.Valid
⊢ t.dual.eraseMin.Valid

tactic: exact eraseMin.valid h.dual
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
h : t.Valid
⊢ t.dual.eraseMin.Valid
state_after: no goals
Theorem: UniqueMDiffWithinAt.mono_nhds
File: Mathlib/Geometry/Manifold/MFDeriv/Basic.lean

tactic: simpa only [← map_extChartAt_nhdsWithin] using Filter.map_mono 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'
s t : Set M
x : M
hs : UniqueMDiffWithinAt I s x
ht : 𝓝[s] x ≤ 𝓝[t] x
⊢ 𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ range ↑I] ↑(extChartAt I x) x ≤
    𝓝[↑(extChartAt I x).symm ⁻¹' t ∩ range ↑I] ↑(extChartAt I x) x
state_after: no goals
Theorem: CategoryTheory.Sieve.overEquiv_symm_iff
File: Mathlib/CategoryTheory/Sites/Over.lean

tactic: rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
X : C
Y : Over X
S : Sieve Y.left
Z : Over X
f : Z ⟶ Y
⊢ ((overEquiv Y).symm S).arrows f ↔ S.arrows f.left
state_after: no goals
Theorem: List.range'_eq_range'TR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

tactic: funext s n step
state_before: ⊢ @range' = @range'TR
state_after: case h.h.h
s n : Nat
step : optParam Nat 1
⊢ range' s n step = range'TR s n step

tactic: exact (go s n 0).symm
state_before: case h.h.h
s n : Nat
step : optParam Nat 1
⊢ range' s n step = range'TR s n step
state_after: no goals

tactic: simp [range'TR.go]
state_before: s✝ n : Nat
step : optParam Nat 1
s m : Nat
⊢ range'TR.go step 0 (s + step * 0) (range' (s + step * 0) m step) = range' s (0 + m) step
state_after: no goals

tactic: simp [range'TR.go]
state_before: s✝ n✝ : Nat
step : optParam Nat 1
s n m : Nat
⊢ range'TR.go step (n + 1) (s + step * (n + 1)) (range' (s + step * (n + 1)) m step) = range' s (n + 1 + m) step
state_after: s✝ n✝ : Nat
step : optParam Nat 1
s n m : Nat
⊢ range'TR.go step n (s + step * (n + 1) - step) ((s + step * (n + 1) - step) :: range' (s + step * (n + 1)) m step) =
    range' s (n + 1 + m) step

tactic: rw [Nat.mul_succ, ← Nat.add_assoc, Nat.add_sub_cancel, Nat.add_right_comm n]
state_before: s✝ n✝ : Nat
step : optParam Nat 1
s n m : Nat
⊢ range'TR.go step n (s + step * (n + 1) - step) ((s + step * (n + 1) - step) :: range' (s + step * (n + 1)) m step) =
    range' s (n + 1 + m) step
state_after: s✝ n✝ : Nat
step : optParam Nat 1
s n m : Nat
⊢ range'TR.go step n (s + step * n) ((s + step * n) :: range' (s + step * n + step) m step) = range' s (n + m + 1) step

tactic: exact go s n (m + 1)
state_before: s✝ n✝ : Nat
step : optParam Nat 1
s n m : Nat
⊢ range'TR.go step n (s + step * n) ((s + step * n) :: range' (s + step * n + step) m step) = range' s (n + m + 1) step
state_after: no goals
Theorem: disjoint_nhdsSet_principal
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [disjoint_comm, disjoint_principal_nhdsSet, disjoint_comm]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
⊢ Disjoint (𝓝ˢ s) (𝓟 t) ↔ Disjoint s (closure t)
state_after: no goals
Theorem: DFinsupp.card_Ioc
File: Mathlib/Data/DFinsupp/Interval.lean

tactic: rw [card_Ioc_eq_card_Icc_sub_one, card_Icc]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → DecidableEq (α i)
inst✝² : (i : ι) → PartialOrder (α i)
inst✝¹ : (i : ι) → Zero (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
⊢ (Ioc f g).card = ∏ i ∈ f.support ∪ g.support, (Icc (f i) (g i)).card - 1
state_after: no goals
Theorem: Set.mem_fintype_prod
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

tactic: rw [mem_finset_prod]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝⁴ : FunLike F α β
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
inst✝¹ : MonoidHomClass F α β
inst✝ : Fintype ι
f : ι → Set α
a : α
⊢ a ∈ ∏ i : ι, f i ↔ ∃ g, ∃ (_ : ∀ (i : ι), g i ∈ f i), ∏ i : ι, g i = a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝⁴ : FunLike F α β
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
inst✝¹ : MonoidHomClass F α β
inst✝ : Fintype ι
f : ι → Set α
a : α
⊢ (∃ g, ∃ (_ : ∀ {i : ι}, i ∈ Finset.univ → g i ∈ f i), ∏ i : ι, g i = a) ↔
    ∃ g, ∃ (_ : ∀ (i : ι), g i ∈ f i), ∏ i : ι, g i = a

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝⁴ : FunLike F α β
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
inst✝¹ : MonoidHomClass F α β
inst✝ : Fintype ι
f : ι → Set α
a : α
⊢ (∃ g, ∃ (_ : ∀ {i : ι}, i ∈ Finset.univ → g i ∈ f i), ∏ i : ι, g i = a) ↔
    ∃ g, ∃ (_ : ∀ (i : ι), g i ∈ f i), ∏ i : ι, g i = a
state_after: no goals
Theorem: Set.mulIndicator_apply_ne_one
File: Mathlib/Algebra/Group/Indicator.lean

tactic: simp only [Ne, mulIndicator_apply_eq_one, Classical.not_imp, mem_inter_iff, mem_mulSupport]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a✝ a : α
⊢ s.mulIndicator f a ≠ 1 ↔ a ∈ s ∩ mulSupport f
state_after: no goals
Theorem: CategoryTheory.ite_comp
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: aesop
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f f' : X ⟶ Y
g : Y ⟶ Z
⊢ (if P then f else f') ≫ g = if P then f ≫ g else f' ≫ g
state_after: no goals
Theorem: pNilradical_eq_bot
File: Mathlib/FieldTheory/IsPerfectClosure.lean

tactic: rw [pNilradical, if_neg hp]
state_before: R : Type u_1
inst✝ : CommSemiring R
p : ℕ
hp : ¬1 < p
⊢ pNilradical R p = ⊥
state_after: no goals
Theorem: Finset.sup'_comm
File: Mathlib/Data/Finset/Lattice.lean

tactic: simpa using forall₂_swap
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f✝ : β → α
t : Finset γ
hs : s.Nonempty
ht : t.Nonempty
f : β → γ → α
a : α
⊢ (s.sup' hs fun b => t.sup' ht (f b)) ≤ a ↔ (t.sup' ht fun c => s.sup' hs fun b => f b c) ≤ a
state_after: no goals
Theorem: List.subperm_cons
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: refine ⟨fun ⟨l, p, s⟩ => ?_, fun ⟨l, p, s⟩ => ⟨a :: l, p.cons a, s.cons₂ _⟩⟩
state_before: α : Type u_1
a : α
l₁ l₂ : List α
⊢ a :: l₁ <+~ a :: l₂ ↔ l₁ <+~ l₂
state_after: α : Type u_1
a : α
l₁ l₂ : List α
x✝ : a :: l₁ <+~ a :: l₂
l : List α
p : l ~ a :: l₁
s : l <+ a :: l₂
⊢ l₁ <+~ l₂

tactic: match s with
| .cons _ s' => exact (p.subperm_left.2 <| (sublist_cons _ _).subperm).trans s'.subperm
| .cons₂ _ s' => exact ⟨_, p.cons_inv, s'⟩
state_before: α : Type u_1
a : α
l₁ l₂ : List α
x✝ : a :: l₁ <+~ a :: l₂
l : List α
p : l ~ a :: l₁
s : l <+ a :: l₂
⊢ l₁ <+~ l₂
state_after: no goals

tactic: exact (p.subperm_left.2 <| (sublist_cons _ _).subperm).trans s'.subperm
state_before: α : Type u_1
a : α
l₁ l₂ : List α
x✝ : a :: l₁ <+~ a :: l₂
l✝ : List α
s : l✝ <+ a :: l₂
l : List α
s' : l <+ l₂
p : l ~ a :: l₁
⊢ l₁ <+~ l₂
state_after: no goals

tactic: exact ⟨_, p.cons_inv, s'⟩
state_before: α : Type u_1
a : α
l₁ l₂ : List α
x✝ : a :: l₁ <+~ a :: l₂
l : List α
s : l <+ a :: l₂
l₁✝ : List α
s' : l₁✝ <+ l₂
p : a :: l₁✝ ~ a :: l₁
⊢ l₁ <+~ l₂
state_after: no goals
Theorem: comap_dist_left_atTop_eq_cocompact
File: Mathlib/Topology/MetricSpace/Bounded.lean

tactic: simp [cobounded_eq_cocompact]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
inst✝ : ProperSpace α
x : α
⊢ comap (dist x) atTop = cocompact α
state_after: no goals
Theorem: Ideal.torsionOf_zero
File: Mathlib/Algebra/Module/Torsion.lean

tactic: simp [torsionOf]
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ torsionOf R M 0 = ⊤
state_after: no goals
Theorem: finPiFinEquiv_single
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [finPiFinEquiv_apply, Fintype.sum_eq_single i, Pi.single_eq_same]
state_before: α : Type u_1
β : Type u_2
m : ℕ
n : Fin m → ℕ
inst✝ : ∀ (i : Fin m), NeZero (n i)
i : Fin m
j : Fin (n i)
⊢ ↑(finPiFinEquiv (Pi.single i j)) = ↑j * ∏ j : Fin ↑i, n (Fin.castLE ⋯ j)
state_after: α : Type u_1
β : Type u_2
m : ℕ
n : Fin m → ℕ
inst✝ : ∀ (i : Fin m), NeZero (n i)
i : Fin m
j : Fin (n i)
⊢ ∀ (x : Fin m), x ≠ i → ↑(Pi.single i j x) * ∏ j : Fin ↑x, n (Fin.castLE ⋯ j) = 0

tactic: rintro x hx
state_before: α : Type u_1
β : Type u_2
m : ℕ
n : Fin m → ℕ
inst✝ : ∀ (i : Fin m), NeZero (n i)
i : Fin m
j : Fin (n i)
⊢ ∀ (x : Fin m), x ≠ i → ↑(Pi.single i j x) * ∏ j : Fin ↑x, n (Fin.castLE ⋯ j) = 0
state_after: α : Type u_1
β : Type u_2
m : ℕ
n : Fin m → ℕ
inst✝ : ∀ (i : Fin m), NeZero (n i)
i : Fin m
j : Fin (n i)
x : Fin m
hx : x ≠ i
⊢ ↑(Pi.single i j x) * ∏ j : Fin ↑x, n (Fin.castLE ⋯ j) = 0

tactic: rw [Pi.single_eq_of_ne hx, Fin.val_zero', zero_mul]
state_before: α : Type u_1
β : Type u_2
m : ℕ
n : Fin m → ℕ
inst✝ : ∀ (i : Fin m), NeZero (n i)
i : Fin m
j : Fin (n i)
x : Fin m
hx : x ≠ i
⊢ ↑(Pi.single i j x) * ∏ j : Fin ↑x, n (Fin.castLE ⋯ j) = 0
state_after: no goals
Theorem: Rat.pow_eq_divInt
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [pow_def, mk_eq_divInt, Int.natCast_pow]
state_before: q✝ q : ℚ
n : ℕ
⊢ q ^ n = q.num ^ n /. ↑q.den ^ n
state_after: no goals