ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.Forall₂.imp
File: Mathlib/Data/List/Forall2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
H : ∀ (a : α) (b : β), R a b → S a b
l₁ : List α
l₂ : List β
h : Forall₂ R l₁ l₂
⊢ Forall₂ S l₁ l₂
state_after: no goals
tactic: induction h <;> constructor <;> solve_by_elim
Theorem: CategoryTheory.Functor.asEquivalence_functor
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.IsEquivalence
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ F.map ((𝟭 C).map f ≫ ((fun X => (F.preimageIso (F.objObjPreimageIso (F.obj X))).symm) Y✝).hom) =
    F.map (((fun X => (F.preimageIso (F.objObjPreimageIso (F.obj X))).symm) X✝).hom ≫ (F ⋙ F.inv).map f)
state_after: no goals
tactic: simp [inv]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.IsEquivalence
⊢ ∀ {X Y : D} (f : X ⟶ Y), (F.inv ⋙ F).map f ≫ (F.objObjPreimageIso Y).hom = (F.objObjPreimageIso X).hom ≫ (𝟭 D).map f
state_after: no goals
tactic: simp [inv]
Theorem: SimpleGraph.Walk.reverseAux_eq_reverse_append
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : G.Walk u v
q : G.Walk u w
⊢ p.reverseAux q = p.reverse.append q
state_after: no goals
tactic: simp [reverse]
Theorem: compl_symmDiff
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ (a ∆ b)ᶜ = a ⇔ b
state_after: no goals
tactic: simp_rw [symmDiff, compl_sup_distrib, compl_sdiff, bihimp, inf_comm]
Theorem: MvPolynomial.degrees_map_of_injective
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : CommSemiring S
p : MvPolynomial σ R
f : R →+* S
hf : Injective ⇑f
⊢ ((map f) p).degrees = p.degrees
state_after: no goals
tactic: simp only [degrees, MvPolynomial.support_map_of_injective _ hf]
Theorem: MeasureTheory.integrableAtFilter_top
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
⊢ IntegrableAtFilter f ⊤ μ ↔ Integrable f μ
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
h : IntegrableAtFilter f ⊤ μ
⊢ Integrable f μ
tactic: refine ⟨fun h ↦ ?_, fun h ↦ h.integrableAtFilter ⊤⟩
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
h : IntegrableAtFilter f ⊤ μ
⊢ Integrable f μ
state_after: case intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
s : Set α
hsf : s ∈ ⊤
hs : IntegrableOn f s μ
⊢ Integrable f μ
tactic: obtain ⟨s, hsf, hs⟩ := h
state_before: case intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
s : Set α
hsf : s ∈ ⊤
hs : IntegrableOn f s μ
⊢ Integrable f μ
state_after: no goals
tactic: exact (integrableOn_iff_integrable_of_support_subset fun _ _ ↦ hsf _).mp hs
Theorem: MeasureTheory.JordanDecomposition.real_smul_negPart_neg
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ
hr : r < 0
⊢ (r • j).negPart = (-r).toNNReal • j.posPart
state_after: no goals
tactic: rw [real_smul_def, ← smul_posPart, if_neg (not_le.2 hr), neg_negPart]
Theorem: Polynomial.degree_cyclotomic_pos
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
hpos : 0 < n
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ 0 < (cyclotomic n R).degree
state_after: no goals
tactic: rwa [degree_cyclotomic n R, Nat.cast_pos, Nat.totient_pos]
Theorem: gauge_eq_one_iff_mem_frontier
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
⊢ gauge s x = 1 ↔ x ∈ frontier s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
⊢ x ∈ closure s ∧ x ∉ interior s ↔ x ∈ frontier s
tactic: rw [eq_iff_le_not_lt, gauge_le_one_iff_mem_closure hc hs₀, gauge_lt_one_iff_mem_interior hc hs₀]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
⊢ x ∈ closure s ∧ x ∉ interior s ↔ x ∈ frontier s
state_after: no goals
tactic: rfl
Theorem: IsStronglyAtomic.of_wellFounded_lt
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
h : WellFounded fun x x_1 => x < x_1
a b : α
hab : a < b
⊢ ∃ x, a ⋖ x ∧ x ≤ b
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
h : WellFounded fun x x_1 => x < x_1
a b : α
hab : a < b
⊢ a ⋖ h.min (Set.Ioc a b) ⋯ ∧ h.min (Set.Ioc a b) ⋯ ≤ b
tactic: refine ⟨WellFounded.min h (Set.Ioc a b) ⟨b, hab,rfl.le⟩, ?_⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
h : WellFounded fun x x_1 => x < x_1
a b : α
hab : a < b
⊢ a ⋖ h.min (Set.Ioc a b) ⋯ ∧ h.min (Set.Ioc a b) ⋯ ≤ b
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
h : WellFounded fun x x_1 => x < x_1
a b : α
hab : a < b
hmem : h.min (Set.Ioc a b) ⋯ ∈ Set.Ioc a b
⊢ a ⋖ h.min (Set.Ioc a b) ⋯ ∧ h.min (Set.Ioc a b) ⋯ ≤ b
tactic: have hmem := (WellFounded.min_mem h (Set.Ioc a b) ⟨b, hab,rfl.le⟩)
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
h : WellFounded fun x x_1 => x < x_1
a b : α
hab : a < b
hmem : h.min (Set.Ioc a b) ⋯ ∈ Set.Ioc a b
⊢ a ⋖ h.min (Set.Ioc a b) ⋯ ∧ h.min (Set.Ioc a b) ⋯ ≤ b
state_after: no goals
tactic: exact ⟨⟨hmem.1,fun c hac hlt ↦ WellFounded.not_lt_min h
      (Set.Ioc a b) ⟨b, hab,rfl.le⟩ ⟨hac, hlt.le.trans hmem.2⟩ hlt ⟩, hmem.2⟩
Theorem: CategoryTheory.Functor.IsLocalization.of_equivalence_source
File: Mathlib/CategoryTheory/Localization/Equivalence.lean

Proof steps:
state_before: C₁ : Type u_1
C₂ : Type u_2
D : Type u_3
D₁ : Type u_4
D₂ : Type u_5
inst✝⁵ : Category.{u_6, u_1} C₁
inst✝⁴ : Category.{u_8, u_2} C₂
inst✝³ : Category.{u_7, u_3} D
inst✝² : Category.{?u.10794, u_4} D₁
inst✝¹ : Category.{?u.10798, u_5} D₂
L₁ : C₁ ⥤ D
W₁ : MorphismProperty C₁
L₂ : C₂ ⥤ D
W₂ : MorphismProperty C₂
E : C₁ ≌ C₂
hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor
hW₂ : W₂.IsInvertedBy L₂
inst✝ : L₁.IsLocalization W₁
iso : E.functor ⋙ L₂ ≅ L₁
⊢ L₂.IsLocalization W₂
state_after: C₁ : Type u_1
C₂ : Type u_2
D : Type u_3
D₁ : Type u_4
D₂ : Type u_5
inst✝⁵ : Category.{u_6, u_1} C₁
inst✝⁴ : Category.{u_8, u_2} C₂
inst✝³ : Category.{u_7, u_3} D
inst✝² : Category.{?u.10794, u_4} D₁
inst✝¹ : Category.{?u.10798, u_5} D₂
L₁ : C₁ ⥤ D
W₁ : MorphismProperty C₁
L₂ : C₂ ⥤ D
W₂ : MorphismProperty C₂
E : C₁ ≌ C₂
hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor
hW₂ : W₂.IsInvertedBy L₂
inst✝ : L₁.IsLocalization W₁
iso : E.functor ⋙ L₂ ≅ L₁
h : W₁.IsInvertedBy (E.functor ⋙ W₂.Q)
⊢ L₂.IsLocalization W₂
tactic: have h : W₁.IsInvertedBy (E.functor ⋙ W₂.Q) := fun _ _ f hf => by
    obtain ⟨_, _, f', hf', ⟨e⟩⟩ := hW₁ f hf
    exact ((MorphismProperty.isomorphisms _).arrow_mk_iso_iff
      (W₂.Q.mapArrow.mapIso e)).1 (Localization.inverts W₂.Q W₂ _ hf')
state_before: C₁ : Type u_1
C₂ : Type u_2
D : Type u_3
D₁ : Type u_4
D₂ : Type u_5
inst✝⁵ : Category.{u_6, u_1} C₁
inst✝⁴ : Category.{u_8, u_2} C₂
inst✝³ : Category.{u_7, u_3} D
inst✝² : Category.{?u.10794, u_4} D₁
inst✝¹ : Category.{?u.10798, u_5} D₂
L₁ : C₁ ⥤ D
W₁ : MorphismProperty C₁
L₂ : C₂ ⥤ D
W₂ : MorphismProperty C₂
E : C₁ ≌ C₂
hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor
hW₂ : W₂.IsInvertedBy L₂
inst✝ : L₁.IsLocalization W₁
iso : E.functor ⋙ L₂ ≅ L₁
h : W₁.IsInvertedBy (E.functor ⋙ W₂.Q)
⊢ L₂.IsLocalization W₂
state_after: no goals
tactic: exact
    { inverts := hW₂
      isEquivalence :=
        Localization.isEquivalence W₂.Q W₂ L₁ W₁ L₂ (Construction.lift L₂ hW₂)
          (E.functor ⋙ W₂.Q) (Localization.lift (E.functor ⋙ W₂.Q) h L₁) (by
            calc
              L₂ ⋙ lift (E.functor ⋙ W₂.Q) h L₁ ≅ _ := (leftUnitor _).symm
              _ ≅ _ := isoWhiskerRight E.counitIso.symm _
              _ ≅ E.inverse ⋙ E.functor ⋙ L₂ ⋙ lift (E.functor ⋙ W₂.Q) h L₁ :=
                    Functor.associator _ _ _
              _ ≅ E.inverse ⋙ L₁ ⋙ lift (E.functor ⋙ W₂.Q) h L₁ :=
                    isoWhiskerLeft E.inverse ((Functor.associator _ _ _).symm ≪≫
                      isoWhiskerRight iso _)
              _ ≅ E.inverse ⋙ E.functor ⋙ W₂.Q :=
                    isoWhiskerLeft _ (Localization.fac (E.functor ⋙ W₂.Q) h L₁)
              _ ≅ (E.inverse ⋙ E.functor) ⋙ W₂.Q := (Functor.associator _ _ _).symm
              _ ≅ 𝟭 C₂ ⋙ W₂.Q := isoWhiskerRight E.counitIso _
              _ ≅ W₂.Q := leftUnitor _)
          (Functor.associator _ _ _ ≪≫ isoWhiskerLeft _ (Lifting.iso W₂.Q W₂ _ _)  ≪≫ iso) }
Theorem: Nat.Prime.smoothNumbers_coprime
File: Mathlib/NumberTheory/SmoothNumbers.lean

Proof steps:
state_before: p n : ℕ
hp : Prime p
hn : n ∈ p.smoothNumbers
⊢ p.Coprime n
state_after: p n : ℕ
hp : Prime p
hn : n ∈ factoredNumbers (Finset.range p)
⊢ p.Coprime n
tactic: simp only [smoothNumbers_eq_factoredNumbers] at hn
state_before: p n : ℕ
hp : Prime p
hn : n ∈ factoredNumbers (Finset.range p)
⊢ p.Coprime n
state_after: no goals
tactic: exact hp.factoredNumbers_coprime Finset.not_mem_range_self hn
Theorem: Homeomorph.symm_comp_toContinuousMap
File: Mathlib/Topology/ContinuousFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
g : β ≃ₜ γ
⊢ f.symm.toContinuousMap.comp f.toContinuousMap = ContinuousMap.id α
state_after: no goals
tactic: rw [← coe_trans, self_trans_symm, coe_refl]
Theorem: Matroid.mem_closure_of_mem'
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M✝ : Matroid α
F X Y : Set α
e : α
M : Matroid α
heX : e ∈ X
h : autoParam (e ∈ M.E) _auto✝
⊢ e ∈ M.closure X
state_after: ι : Type u_1
α : Type u_2
M✝ : Matroid α
F X Y : Set α
e : α
M : Matroid α
heX : e ∈ X
h : autoParam (e ∈ M.E) _auto✝
⊢ e ∈ M.closure (X ∩ M.E)
tactic: rw [← closure_inter_ground]
state_before: ι : Type u_1
α : Type u_2
M✝ : Matroid α
F X Y : Set α
e : α
M : Matroid α
heX : e ∈ X
h : autoParam (e ∈ M.E) _auto✝
⊢ e ∈ M.closure (X ∩ M.E)
state_after: no goals
tactic: exact M.mem_closure_of_mem ⟨heX, h⟩
Theorem: MeasureTheory.ConvolutionExists.add_distrib
File: Mathlib/Analysis/Convolution.lean

Proof steps:
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 + f') ⋆[L, μ] 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 + f') ⋆[L, μ] g) x = (f ⋆[L, μ] g + f' ⋆[L, μ] g) x
tactic: ext 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 + f') ⋆[L, μ] g) x = (f ⋆[L, μ] g + f' ⋆[L, μ] g) x
state_after: no goals
tactic: exact (hfg x).add_distrib (hfg' x)
Theorem: CategoryTheory.Limits.biprod.associator_inv_natural
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
D : Type uD
inst✝² : Category.{uD', uD} D
inst✝¹ : HasZeroMorphisms D
P Q : C
inst✝ : HasBinaryBiproducts C
U V W X Y Z : C
f : U ⟶ X
g : V ⟶ Y
h : W ⟶ Z
⊢ map f (map g h) ≫ (associator X Y Z).inv = (associator U V W).inv ≫ map (map f g) h
state_after: no goals
tactic: aesop_cat
Theorem: piecewise_ae_eq_restrict
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
inst✝¹ : MeasurableSpace α
μ : Measure α
s t : Set α
f g : α → β
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ s.piecewise f g =ᶠ[ae (μ.restrict s)] f
state_after: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
inst✝¹ : MeasurableSpace α
μ : Measure α
s t : Set α
f g : α → β
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ s.piecewise f g =ᶠ[ae μ ⊓ 𝓟 s] f
tactic: rw [ae_restrict_eq hs]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
inst✝¹ : MeasurableSpace α
μ : Measure α
s t : Set α
f g : α → β
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ s.piecewise f g =ᶠ[ae μ ⊓ 𝓟 s] f
state_after: no goals
tactic: exact (piecewise_eqOn s f g).eventuallyEq.filter_mono inf_le_right
Theorem: integrableOn_Icc_iff_integrableOn_Ico'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
hb : μ {b} ≠ ⊤
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ico a b) μ
state_after: case pos
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
hb : μ {b} ≠ ⊤
hab : a ≤ b
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ico a b) μ

case neg
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
hb : μ {b} ≠ ⊤
hab : ¬a ≤ b
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ico a b) μ
tactic: by_cases hab : a ≤ b
Theorem: SetTheory.PGame.neg_le_zero_iff
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
⊢ -x ≤ 0 ↔ 0 ≤ x
state_after: no goals
tactic: rw [neg_le_iff, neg_zero]
Theorem: AddChar.FiniteField.primitiveChar_to_Complex_isPrimitive
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : DecidableEq F
⊢ (primitiveChar_to_Complex F).IsPrimitive
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : DecidableEq F
⊢ Function.Injective
    ⇑↑(IsCyclotomicExtension.algEquiv (primitiveChar F ℂ ⋯).n ℂ (CyclotomicField (primitiveChar F ℂ ⋯).n ℂ) ℂ)
tactic: refine IsPrimitive.compMulHom_of_isPrimitive (PrimitiveAddChar.prim _) ?_
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : DecidableEq F
⊢ Function.Injective
    ⇑↑(IsCyclotomicExtension.algEquiv (primitiveChar F ℂ ⋯).n ℂ (CyclotomicField (primitiveChar F ℂ ⋯).n ℂ) ℂ)
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : DecidableEq F
nn : ℕ+ := (primitiveChar F ℂ ⋯).n
⊢ Function.Injective
    ⇑↑(IsCyclotomicExtension.algEquiv (primitiveChar F ℂ ⋯).n ℂ (CyclotomicField (primitiveChar F ℂ ⋯).n ℂ) ℂ)
tactic: let nn := (primitiveChar F ℂ <| ringChar_ne F).n
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : DecidableEq F
nn : ℕ+ := (primitiveChar F ℂ ⋯).n
⊢ Function.Injective
    ⇑↑(IsCyclotomicExtension.algEquiv (primitiveChar F ℂ ⋯).n ℂ (CyclotomicField (primitiveChar F ℂ ⋯).n ℂ) ℂ)
state_after: no goals
tactic: exact (IsCyclotomicExtension.algEquiv nn ℂ (CyclotomicField nn ℂ) ℂ).injective
Theorem: HasDerivAtFilter.const_sub
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
c : F
hf : HasDerivAtFilter f f' x L
⊢ HasDerivAtFilter (fun x => c - f x) (-f') x L
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.neg.const_add c
Theorem: completeSpace_extension
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
m : β → α
hm : UniformInducing m
dense : DenseRange m
h : ∀ (f : Filter β), Cauchy f → ∃ x, map m f ≤ 𝓝 x
f : Filter α
hf : Cauchy f
p : Set (α × α) → Set α → Set α := fun s t => {y | ∃ x ∈ t, (x, y) ∈ s}
g : Filter α := (𝓤 α).lift fun s => f.lift' (p s)
mp₀ : Monotone p
mp₁ : ∀ {s : Set (α × α)}, Monotone (p s)
this✝⁵ : f ≤ g
this✝⁴ : g.NeBot
this✝³ : (comap m g).NeBot
this✝² : Cauchy g
this✝¹ : Cauchy (comap m g)
x : α
hx : map m (comap m g) ≤ 𝓝 x
this✝ : ClusterPt x (map m (comap m g))
this : ClusterPt x g
⊢ f ≤ g
state_after: no goals
tactic: assumption
Theorem: LinearIsometry.inner_map_map
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁸ : _root_.RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
ι : Type u_4
ι' : Type u_5
ι'' : Type u_6
E' : Type u_7
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type u_8
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
f : E →ₗᵢ[𝕜] E'
x y : E
⊢ ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜
state_after: no goals
tactic: simp [inner_eq_sum_norm_sq_div_four, ← f.norm_map]
Theorem: CategoryTheory.LaxFunctor.map₂_rightUnitor_hom
File: Mathlib/CategoryTheory/Bicategory/Functor/Lax.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F : LaxFunctor B C
a b : B
f : a ⟶ b
⊢ (ρ_ (F.map f)).hom = F.map f ◁ F.mapId b ≫ F.mapComp f (𝟙 b) ≫ F.map₂ (ρ_ f).hom
state_after: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F : LaxFunctor B C
a b : B
f : a ⟶ b
⊢ (F.map₂Iso (ρ_ f)).inv = (ρ_ (F.map f)).inv ≫ F.map f ◁ F.mapId b ≫ F.mapComp f (𝟙 b)
tactic: rw [← PrelaxFunctor.map₂Iso_hom, ← assoc, ← Iso.comp_inv_eq, ← Iso.eq_inv_comp]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F : LaxFunctor B C
a b : B
f : a ⟶ b
⊢ (F.map₂Iso (ρ_ f)).inv = (ρ_ (F.map f)).inv ≫ F.map f ◁ F.mapId b ≫ F.mapComp f (𝟙 b)
state_after: no goals
tactic: simp only [Functor.mapIso_inv, PrelaxFunctor.mapFunctor_map, map₂_rightUnitor]
Theorem: Option.elim_comp
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
h : α → β
f : γ → α
x : α
i : Option γ
⊢ (i.elim (h x) fun j => h (f j)) = h (i.elim x f)
state_after: no goals
tactic: cases i <;> rfl
Theorem: uniqueDiffWithinAt_Ioi
File: Mathlib/Analysis/Calculus/TangentCone.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a : ℝ
⊢ (interior (Ioi a)).Nonempty
state_after: no goals
tactic: simp
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a : ℝ
⊢ a ∈ closure (Ioi a)
state_after: no goals
tactic: simp
Theorem: PartialEquiv.self_trans_symm
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
⊢ e.trans e.symm ≈ ofSet e.source
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
A : (e.trans e.symm).source = e.source
⊢ e.trans e.symm ≈ ofSet e.source
tactic: have A : (e.trans e.symm).source = e.source := by mfld_set_tac
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
A : (e.trans e.symm).source = e.source
⊢ e.trans e.symm ≈ ofSet e.source
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
A : (e.trans e.symm).source = e.source
x : α
hx : x ∈ (e.trans e.symm).source
⊢ ↑(e.trans e.symm) x = ↑(ofSet e.source) x
tactic: refine ⟨by rw [A, ofSet_source], fun x hx => ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
A : (e.trans e.symm).source = e.source
x : α
hx : x ∈ (e.trans e.symm).source
⊢ ↑(e.trans e.symm) x = ↑(ofSet e.source) x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
A : (e.trans e.symm).source = e.source
x : α
hx : x ∈ e.source
⊢ ↑(e.trans e.symm) x = ↑(ofSet e.source) x
tactic: rw [A] at hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
A : (e.trans e.symm).source = e.source
x : α
hx : x ∈ e.source
⊢ ↑(e.trans e.symm) x = ↑(ofSet e.source) x
state_after: no goals
tactic: simp only [hx, mfld_simps]
Theorem: Bool.toNat_bne_one
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: b : Bool
⊢ (b.toNat != 1) = !b
state_after: no goals
tactic: simp [bne]
Theorem: MvPolynomial.mem_supported_vars
File: Mathlib/Algebra/MvPolynomial/Supported.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p✝ q : MvPolynomial σ R
s t : Set σ
p : MvPolynomial σ R
⊢ p ∈ supported R ↑p.vars
state_after: no goals
tactic: rw [mem_supported]