1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ENNReal.essSup_piecewise
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: simp only [essSup, limsup_piecewise, blimsup_eq_limsup, ae_restrict_eq, hs, hs.compl]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
g : α → ℝ≥0∞
hs : MeasurableSet s
⊢ essSup (s.piecewise f g) μ = max (essSup f (μ.restrict s)) (essSup g (μ.restrict sᶜ))
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
g : α → ℝ≥0∞
hs : MeasurableSet s
⊢ limsup f (ae μ ⊓ 𝓟 {x | x ∈ s}) ⊔ limsup g (ae μ ⊓ 𝓟 {x | x ∉ s}) =
    max (limsup f (ae μ ⊓ 𝓟 s)) (limsup g (ae μ ⊓ 𝓟 sᶜ))

tactic: rfl
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
g : α → ℝ≥0∞
hs : MeasurableSet s
⊢ limsup f (ae μ ⊓ 𝓟 {x | x ∈ s}) ⊔ limsup g (ae μ ⊓ 𝓟 {x | x ∉ s}) =
    max (limsup f (ae μ ⊓ 𝓟 s)) (limsup g (ae μ ⊓ 𝓟 sᶜ))
state_after: no goals
Theorem: TopCat.Presheaf.germ_eq
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: obtain ⟨W, iU, iV, e⟩ :=
  (Types.FilteredColimit.isColimit_eq_iff.{v, v} _
        (isColimitOfPreserves _ (colimit.isColimit ((OpenNhds.inclusion x).op ⋙ F)))).mp h
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
U V : Opens ↑X
x : ↑X
mU : x ∈ U
mV : x ∈ V
s : (forget C).obj (F.obj { unop := U })
t : (forget C).obj (F.obj { unop := V })
h : (F.germ ⟨x, mU⟩) s = (F.germ ⟨x, mV⟩) t
⊢ ∃ W, ∃ (_ : x ∈ W), ∃ iU iV, (F.map iU.op) s = (F.map iV.op) t
state_after: case intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
U V : Opens ↑X
x : ↑X
mU : x ∈ U
mV : x ∈ V
s : (forget C).obj (F.obj { unop := U })
t : (forget C).obj (F.obj { unop := V })
h : (F.germ ⟨x, mU⟩) s = (F.germ ⟨x, mV⟩) t
W : (OpenNhds x)ᵒᵖ
iU : { unop := { obj := U, property := ⋯ } } ⟶ W
iV : { unop := { obj := V, property := ⋯ } } ⟶ W
e : (((OpenNhds.inclusion x).op ⋙ F) ⋙ forget C).map iU s = (((OpenNhds.inclusion x).op ⋙ F) ⋙ forget C).map iV t
⊢ ∃ W, ∃ (_ : x ∈ W), ∃ iU iV, (F.map iU.op) s = (F.map iV.op) t

tactic: exact ⟨(unop W).1, (unop W).2, iU.unop, iV.unop, e⟩
state_before: case intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
U V : Opens ↑X
x : ↑X
mU : x ∈ U
mV : x ∈ V
s : (forget C).obj (F.obj { unop := U })
t : (forget C).obj (F.obj { unop := V })
h : (F.germ ⟨x, mU⟩) s = (F.germ ⟨x, mV⟩) t
W : (OpenNhds x)ᵒᵖ
iU : { unop := { obj := U, property := ⋯ } } ⟶ W
iV : { unop := { obj := V, property := ⋯ } } ⟶ W
e : (((OpenNhds.inclusion x).op ⋙ F) ⋙ forget C).map iU s = (((OpenNhds.inclusion x).op ⋙ F) ⋙ forget C).map iV t
⊢ ∃ W, ∃ (_ : x ∈ W), ∃ iU iV, (F.map iU.op) s = (F.map iV.op) t
state_after: no goals
Theorem: Finset.Pi.cons_injective
File: Mathlib/Data/Finset/Pi.lean

tactic: simpa only [Multiset.mem_cons, mem_insert] using h
state_before: α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝ : DecidableEq α
s✝ : Finset α
t : (a : α) → Finset (β a)
a : α
b : δ a
s : Finset α
hs : a ∉ s
e₁ e₂ : (a : α) → a ∈ s → δ a
eq : cons s a b e₁ = cons s a b e₂
e : α
h : e ∈ a ::ₘ s.val
⊢ e ∈ insert a s
state_after: no goals

tactic: rw [eq]
state_before: α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝ : DecidableEq α
s✝ : Finset α
t : (a : α) → Finset (β a)
a : α
b : δ a
s : Finset α
hs : a ∉ s
e₁ e₂ : (a : α) → a ∈ s → δ a
eq : cons s a b e₁ = cons s a b e₂
e : α
h : e ∈ a ::ₘ s.val
⊢ cons s a b e₁ e ⋯ = cons s a b e₂ e ⋯
state_after: no goals
Theorem: CoxeterSystem.wordProd_surjective
File: Mathlib/GroupTheory/Coxeter/Basic.lean

tactic: intro w
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ Surjective cs.wordProd
state_after: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ a, cs.wordProd a = w

tactic: apply cs.simple_induction_left w
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ a, cs.wordProd a = w
state_after: case one
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ a, cs.wordProd a = 1

case mul_simple_left
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∀ (w : W) (i : B), (∃ a, cs.wordProd a = w) → ∃ a, cs.wordProd a = cs.simple i * w

tactic: use []
state_before: case one
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ a, cs.wordProd a = 1
state_after: case h
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.wordProd [] = 1

tactic: rw [wordProd_nil]
state_before: case h
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.wordProd [] = 1
state_after: no goals

tactic: rintro _ i ⟨ω, rfl⟩
state_before: case mul_simple_left
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∀ (w : W) (i : B), (∃ a, cs.wordProd a = w) → ∃ a, cs.wordProd a = cs.simple i * w
state_after: case mul_simple_left.intro
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
ω : List B
⊢ ∃ a, cs.wordProd a = cs.simple i * cs.wordProd ω

tactic: use i :: ω
state_before: case mul_simple_left.intro
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
ω : List B
⊢ ∃ a, cs.wordProd a = cs.simple i * cs.wordProd ω
state_after: case h
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
ω : List B
⊢ cs.wordProd (i :: ω) = cs.simple i * cs.wordProd ω

tactic: rw [wordProd_cons]
state_before: case h
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
ω : List B
⊢ cs.wordProd (i :: ω) = cs.simple i * cs.wordProd ω
state_after: no goals
Theorem: inv_div_inv
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a⁻¹ / b⁻¹ = b / a
state_after: no goals
Theorem: norm_iteratedFDerivWithin_zero
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: rw [iteratedFDerivWithin_zero_eq_comp, comp_apply, LinearIsometryEquiv.norm_map]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ‖iteratedFDerivWithin 𝕜 0 f s x‖ = ‖f x‖
state_after: no goals
Theorem: Complex.sameRay_iff_arg_div_eq_zero
File: Mathlib/Analysis/Complex/Arg.lean

tactic: rw [← Real.Angle.toReal_zero, ← arg_coe_angle_eq_iff_eq_toReal, sameRay_iff]
state_before: x y : ℂ
⊢ SameRay ℝ x y ↔ (x / y).arg = 0
state_after: x y : ℂ
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0

tactic: by_cases hx : x = 0
state_before: x y : ℂ
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
state_after: case pos
x y : ℂ
hx : x = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0

case neg
x y : ℂ
hx : ¬x = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0

tactic: by_cases hy : y = 0
state_before: case neg
x y : ℂ
hx : ¬x = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
state_after: case pos
x y : ℂ
hx : ¬x = 0
hy : y = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0

case neg
x y : ℂ
hx : ¬x = 0
hy : ¬y = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0

tactic: simp [hx, hy, arg_div_coe_angle, sub_eq_zero]
state_before: case neg
x y : ℂ
hx : ¬x = 0
hy : ¬y = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
state_after: no goals

tactic: simp [hx]
state_before: case pos
x y : ℂ
hx : x = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
state_after: no goals

tactic: simp [hy]
state_before: case pos
x y : ℂ
hx : ¬x = 0
hy : y = 0
⊢ x = 0 ∨ y = 0 ∨ x.arg = y.arg ↔ ↑(x / y).arg = 0
state_after: no goals
Theorem: Subgroup.mul_self_mem_of_index_two
File: Mathlib/GroupTheory/Index.lean

tactic: rw [mul_mem_iff_of_index_two h]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : H.index = 2
a : G
⊢ a * a ∈ H
state_after: no goals
Theorem: UniformOnFun.iInf_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: simp_rw [UniformOnFun.uniformSpace, UniformFun.iInf_eq, UniformSpace.comap_iInf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u : ι → UniformSpace γ
⊢ uniformSpace α γ 𝔖 = ⨅ i, uniformSpace α γ 𝔖
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u : ι → UniformSpace γ
⊢ ⨅ s ∈ 𝔖, ⨅ i, UniformSpace.comap (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(toFun 𝔖)) (UniformFun.uniformSpace (↑s) γ) =
    ⨅ i, ⨅ s ∈ 𝔖, UniformSpace.comap (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(toFun 𝔖)) (UniformFun.uniformSpace (↑s) γ)

tactic: rw [iInf_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u : ι → UniformSpace γ
⊢ ⨅ s ∈ 𝔖, ⨅ i, UniformSpace.comap (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(toFun 𝔖)) (UniformFun.uniformSpace (↑s) γ) =
    ⨅ i, ⨅ s ∈ 𝔖, UniformSpace.comap (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(toFun 𝔖)) (UniformFun.uniformSpace (↑s) γ)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u : ι → UniformSpace γ
⊢ ⨅ s ∈ 𝔖, ⨅ i, UniformSpace.comap (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(toFun 𝔖)) (UniformFun.uniformSpace (↑s) γ) =
    ⨅ j,
      ⨅ i,
        ⨅ (_ : j ∈ 𝔖), UniformSpace.comap (⇑UniformFun.ofFun ∘ j.restrict ∘ ⇑(toFun 𝔖)) (UniformFun.uniformSpace (↑j) γ)

tactic: exact iInf_congr fun s => iInf_comm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u : ι → UniformSpace γ
⊢ ⨅ s ∈ 𝔖, ⨅ i, UniformSpace.comap (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(toFun 𝔖)) (UniformFun.uniformSpace (↑s) γ) =
    ⨅ j,
      ⨅ i,
        ⨅ (_ : j ∈ 𝔖), UniformSpace.comap (⇑UniformFun.ofFun ∘ j.restrict ∘ ⇑(toFun 𝔖)) (UniformFun.uniformSpace (↑j) γ)
state_after: no goals
Theorem: ONote.NF.zero_of_zero
File: Mathlib/SetTheory/Ordinal/Notation.lean

tactic: simpa [e0, NFBelow_zero] using h.snd'
state_before: e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
e0 : e = 0
⊢ a = 0
state_after: no goals
Theorem: Polynomial.eval₂_sub
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [sub_eq_add_neg, eval₂_add, eval₂_neg, sub_eq_add_neg]
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Ring R
p q r : R[X]
S : Type u_1
inst✝ : Ring S
f : R →+* S
x : S
⊢ eval₂ f x (p - q) = eval₂ f x p - eval₂ f x q
state_after: no goals
Theorem: MvPolynomial.eval_map
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: simp (config := { contextual := true })
state_before: case h_X
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ f : R →+* S₁
g : σ → S₁
p : MvPolynomial σ R
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    (eval g) ((map f) p) = eval₂ f g p → (eval g) ((map f) (p * X n)) = eval₂ f g (p * X n)
state_after: no goals
Theorem: LinearEquiv.lift_rank_eq
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

tactic: apply le_antisymm
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
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✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M ≃ₗ[R] M'
⊢ lift.{v', v} (Module.rank R M) = lift.{v, v'} (Module.rank R M')
state_after: case a
R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
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✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M ≃ₗ[R] M'
⊢ lift.{v', v} (Module.rank R M) ≤ lift.{v, v'} (Module.rank R M')

case a
R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
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✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M ≃ₗ[R] M'
⊢ lift.{v, v'} (Module.rank R M') ≤ lift.{v', v} (Module.rank R M)

tactic: exact f.toLinearMap.lift_rank_le_of_injective f.injective
state_before: case a
R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
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✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M ≃ₗ[R] M'
⊢ lift.{v', v} (Module.rank R M) ≤ lift.{v, v'} (Module.rank R M')
state_after: no goals

tactic: exact f.symm.toLinearMap.lift_rank_le_of_injective f.symm.injective
state_before: case a
R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
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✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M ≃ₗ[R] M'
⊢ lift.{v, v'} (Module.rank R M') ≤ lift.{v', v} (Module.rank R M)
state_after: no goals
Theorem: CategoryTheory.Limits.colimit.ι_map
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: simp
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
j : J
⊢ ι F j ≫ colim.map α = α.app j ≫ ι G j
state_after: no goals
Theorem: Set.prod_image_image_eq
File: Mathlib/Data/Set/Prod.lean

tactic: simp [-exists_and_right, exists_and_right.symm, and_left_comm, and_assoc, and_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
m₁ : α → γ
m₂ : β → δ
⊢ ∀ (x : γ × δ), x ∈ (m₁ '' s) ×ˢ (m₂ '' t) ↔ x ∈ (fun p => (m₁ p.1, m₂ p.2)) '' s ×ˢ t
state_after: no goals
Theorem: Submodule.restrictScalars_span
File: Mathlib/Algebra/Algebra/Tower.lean

tactic: refine ((span_le_restrictScalars R A X).antisymm fun m hm => ?_).symm
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
⊢ restrictScalars R (span A X) = span R X
state_after: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m : M
hm : m ∈ restrictScalars R (span A X)
⊢ m ∈ span R X

tactic: refine span_induction hm subset_span (zero_mem _) (fun _ _ => add_mem) fun a m hm => ?_
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m : M
hm : m ∈ restrictScalars R (span A X)
⊢ m ∈ span R X
state_after: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m✝ : M
hm✝ : m✝ ∈ restrictScalars R (span A X)
a : A
m : M
hm : m ∈ span R X
⊢ a • m ∈ span R X

tactic: obtain ⟨r, rfl⟩ := hsur a
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m✝ : M
hm✝ : m✝ ∈ restrictScalars R (span A X)
a : A
m : M
hm : m ∈ span R X
⊢ a • m ∈ span R X
state_after: case intro
R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m✝ : M
hm✝ : m✝ ∈ restrictScalars R (span A X)
m : M
hm : m ∈ span R X
r : R
⊢ (algebraMap R A) r • m ∈ span R X

tactic: simpa [algebraMap_smul] using smul_mem _ r hm
state_before: case intro
R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m✝ : M
hm✝ : m✝ ∈ restrictScalars R (span A X)
m : M
hm : m ∈ span R X
r : R
⊢ (algebraMap R A) r • m ∈ span R X
state_after: no goals
Theorem: CategoryTheory.Abelian.mono_inl_of_isColimit
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: haveI : Mono (NatTrans.app (colimit.cocone (span f g)).ι WalkingCospan.left) :=
  Abelian.mono_pushout_of_mono_g f g
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono g
s : PushoutCocone f g
hs : IsColimit s
⊢ Mono s.inl
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono g
s : PushoutCocone f g
hs : IsColimit s
this : Mono ((colimit.cocone (span f g)).ι.app WalkingCospan.left)
⊢ Mono s.inl

tactic: apply
  mono_of_mono_fac (IsColimit.comp_coconePointUniqueUpToIso_hom hs (colimit.isColimit _) _)
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono g
s : PushoutCocone f g
hs : IsColimit s
this : Mono ((colimit.cocone (span f g)).ι.app WalkingCospan.left)
⊢ Mono s.inl
state_after: no goals
Theorem: EMetric.hausdorffEdist_image
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp only [hausdorffEdist_def, iSup_image, infEdist_image h]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
h : Isometry Φ
⊢ hausdorffEdist (Φ '' s) (Φ '' t) = hausdorffEdist s t
state_after: no goals
Theorem: Nat.bodd_eq_bits_head
File: Mathlib/Data/Nat/Bits.lean

tactic: induction' n using Nat.binaryRec' with b n h _
state_before: m n✝ n : ℕ
⊢ n.bodd = n.bits.headI
state_after: case z
m n : ℕ
⊢ bodd 0 = (bits 0).headI

case f
m n✝ : ℕ
b : Bool
n : ℕ
h : n = 0 → b = true
a✝ : n.bodd = n.bits.headI
⊢ (bit b n).bodd = (bit b n).bits.headI

tactic: simp [bodd_bit, bits_append_bit _ _ h]
state_before: case f
m n✝ : ℕ
b : Bool
n : ℕ
h : n = 0 → b = true
a✝ : n.bodd = n.bits.headI
⊢ (bit b n).bodd = (bit b n).bits.headI
state_after: no goals

tactic: simp
state_before: case z
m n : ℕ
⊢ bodd 0 = (bits 0).headI
state_after: no goals
Theorem: PreErgodic.prob_eq_zero_or_one
File: Mathlib/Dynamics/Ergodic/Ergodic.lean

tactic: simpa [hs] using hf.measure_self_or_compl_eq_zero hs hs'
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
inst✝ : IsProbabilityMeasure μ
hf : PreErgodic f μ
hs : MeasurableSet s
hs' : f ⁻¹' s = s
⊢ μ s = 0 ∨ μ s = 1
state_after: no goals
Theorem: Stream'.mem_of_mem_odd
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h, get_odd]
state_before: α : Type u
β : Type v
δ : Type w
a : α
s : Stream' α
x✝ : a ∈ s.odd
n : ℕ
h : (fun b => a = b) (s.odd.get n)
⊢ (fun b => a = b) (s.get (2 * n + 1))
state_after: no goals
Theorem: PiLp.norm_eq_of_L2
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: rw [norm_eq_of_nat 2 (by norm_cast) _]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖ = √(∑ i : ι, ‖x i‖ ^ 2)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / ↑2) = √(∑ i : ι, ‖x i‖ ^ 2)

tactic: rw [Real.sqrt_eq_rpow]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / ↑2) = √(∑ i : ι, ‖x i‖ ^ 2)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / ↑2) = (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / 2)

tactic: norm_cast
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / ↑2) = (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / 2)
state_after: no goals

tactic: norm_cast
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ 2 = ↑2
state_after: no goals
Theorem: ENNReal.nhds_top
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp [lt_top_iff_ne_top, Ioi]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ ⨅ l, ⨅ (_ : l < ⊤), 𝓟 (Ioi l) = ⨅ a, ⨅ (_ : a ≠ ⊤), 𝓟 (Ioi a)
state_after: no goals
Theorem: IsCompact.closedBall_mul
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [mul_comm, hs.mul_closedBall hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ closedBall x δ * s = x • cthickening δ s
state_after: no goals