ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.arccos_le_pi_div_four
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ arccos x ≤ π / 4 ↔ √2 / 2 ≤ x
state_after: x✝ y x : ℝ
⊢ π / 2 - arcsin x ≤ π / 4 ↔ π / 4 ≤ arcsin x
tactic: rw [arccos, ← pi_div_four_le_arcsin]
Theorem: Set.biUnion_preimage_singleton
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : Set β
⊢ ⋃ y ∈ s, f ⁻¹' {y} = f ⁻¹' s
state_after: no goals
tactic: rw [← preimage_iUnion₂, biUnion_of_singleton]
Theorem: CategoryTheory.PresheafOfGroups.OneCocycle.equivalence_isCohomologous
File: Mathlib/CategoryTheory/Sites/NonabelianCohomology/H1.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
⊢ ∀ {x y : OneCocycle G U}, x.IsCohomologous y → y.IsCohomologous x
state_after: case intro
C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
γ₁ γ₂ : OneCocycle G U
α : ZeroCochain G U
h : OneCohomologyRelation γ₁.toOneCochain γ₂.toOneCochain α
⊢ γ₂.IsCohomologous γ₁
tactic: rintro γ₁ γ₂ ⟨α, h⟩
state_before: case intro
C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
γ₁ γ₂ : OneCocycle G U
α : ZeroCochain G U
h : OneCohomologyRelation γ₁.toOneCochain γ₂.toOneCochain α
⊢ γ₂.IsCohomologous γ₁
state_after: no goals
tactic: exact ⟨_, h.symm⟩
state_before: C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
⊢ ∀ {x y z : OneCocycle G U}, x.IsCohomologous y → y.IsCohomologous z → x.IsCohomologous z
state_after: case intro.intro
C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
γ₁ γ₂✝ γ₂ : OneCocycle G U
α : ZeroCochain G U
h : OneCohomologyRelation γ₁.toOneCochain γ₂✝.toOneCochain α
β : ZeroCochain G U
h' : OneCohomologyRelation γ₂✝.toOneCochain γ₂.toOneCochain β
⊢ γ₁.IsCohomologous γ₂
tactic: rintro γ₁ γ₂ γ₂ ⟨α, h⟩ ⟨β, h'⟩
state_before: case intro.intro
C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
γ₁ γ₂✝ γ₂ : OneCocycle G U
α : ZeroCochain G U
h : OneCohomologyRelation γ₁.toOneCochain γ₂✝.toOneCochain α
β : ZeroCochain G U
h' : OneCohomologyRelation γ₂✝.toOneCochain γ₂.toOneCochain β
⊢ γ₁.IsCohomologous γ₂
state_after: no goals
tactic: exact ⟨_, h.trans h'⟩
Theorem: Complex.subfield_eq_of_closed
File: Mathlib/Topology/Instances/Complex.lean

Proof steps:
state_before: K : Subfield ℂ
hc : IsClosed ↑K
⊢ K = ofReal.fieldRange ∨ K = ⊤
state_after: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ ↑K
tactic: suffices range (ofReal' : ℝ → ℂ) ⊆ K by
    rw [range_subset_iff, ← coe_algebraMap] at this
    have :=
      (Subalgebra.isSimpleOrder_of_finrank finrank_real_complex).eq_bot_or_eq_top
        (Subfield.toIntermediateField K this).toSubalgebra
    simp_rw [← SetLike.coe_set_eq, IntermediateField.coe_toSubalgebra] at this ⊢
    exact this
state_before: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ ↑K
state_after: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ closure (range (ofReal' ∘ Rat.cast))
tactic: suffices range (ofReal' : ℝ → ℂ) ⊆ closure (Set.range ((ofReal' : ℝ → ℂ) ∘ ((↑) : ℚ → ℝ))) by
    refine subset_trans this ?_
    rw [← IsClosed.closure_eq hc]
    apply closure_mono
    rintro _ ⟨_, rfl⟩
    simp only [Function.comp_apply, ofReal_ratCast, SetLike.mem_coe, SubfieldClass.ratCast_mem]
state_before: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ closure (range (ofReal' ∘ Rat.cast))
state_after: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ closure (ofReal' '' range Rat.cast)
tactic: nth_rw 1 [range_comp]
state_before: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ closure (ofReal' '' range Rat.cast)
state_after: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ ofReal' '' closure (range Rat.cast)
tactic: refine subset_trans ?_ (image_closure_subset_closure_image continuous_ofReal)
state_before: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ ofReal' '' closure (range Rat.cast)
state_after: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ ofReal' '' univ
tactic: rw [DenseRange.closure_range Rat.denseEmbedding_coe_real.dense]
state_before: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ ofReal' '' univ
state_after: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ range ofReal'
tactic: simp only [image_univ]
state_before: K : Subfield ℂ
hc : IsClosed ↑K
⊢ range ofReal' ⊆ range ofReal'
state_after: no goals
tactic: rfl
Theorem: List.dlookup_kinsert_ne
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : a ≠ a'
⊢ dlookup a (kinsert a' b' l) = dlookup a l
state_after: no goals
tactic: simp [h]
Theorem: uniformity_eq_comap_nhds_zero
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ 𝓤 α = comap (fun x => x.2 / x.1) (𝓝 1)
state_after: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ 𝓤 α = comap (Prod.mk 1 ∘ fun x => x.2 / x.1) (𝓤 α)
tactic: rw [nhds_eq_comap_uniformity, Filter.comap_comap]
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ 𝓤 α = comap (Prod.mk 1 ∘ fun x => x.2 / x.1) (𝓤 α)
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ map (Prod.mk 1 ∘ fun x => x.2 / x.1) (𝓤 α) ≤ 𝓤 α

case refine_2
α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ comap (Prod.mk 1 ∘ fun x => x.2 / x.1) (𝓤 α) ≤ 𝓤 α
tactic: refine le_antisymm (Filter.map_le_iff_le_comap.1 ?_) ?_
Theorem: Filter.nhds_iInf
File: Mathlib/Topology/Filter.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
f : ι → Filter α
⊢ 𝓝 (⨅ i, f i) = ⨅ i, 𝓝 (f i)
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
f : ι → Filter α
⊢ (⨅ i, f i).lift' (Iic ∘ 𝓟) = ⨅ i, (f i).lift' (Iic ∘ 𝓟)
tactic: simp only [nhds_eq]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
f : ι → Filter α
⊢ (⨅ i, f i).lift' (Iic ∘ 𝓟) = ⨅ i, (f i).lift' (Iic ∘ 𝓟)
state_after: no goals
tactic: apply lift'_iInf_of_map_univ <;> simp
Theorem: aemeasurable_coe_nnreal_real_iff
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝ : MeasurableSpace α
f : α → ℝ≥0
μ : Measure α
h : AEMeasurable (fun x => ↑(f x)) μ
⊢ AEMeasurable f μ
state_after: no goals
tactic: simpa only [Real.toNNReal_coe] using h.real_toNNReal
Theorem: CategoryTheory.StructuredArrow.hom_eq_iff
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' Y'' : C
T T' : C ⥤ D
X Y : StructuredArrow S T
f g : X ⟶ Y
h : f = g
⊢ f.right = g.right
state_after: no goals
tactic: rw [h]
Theorem: List.sigma_nil
File: Mathlib/Data/List/ProdSigma.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
σ : α → Type u_3
head✝ : α
l : List α
⊢ ((head✝ :: l).sigma fun a => []) = []
state_after: no goals
tactic: simp [sigma_cons, sigma_nil l]
Theorem: IsometryEquiv.image_closedBall
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
h✝ h : α ≃ᵢ β
x : α
r : ℝ
⊢ ⇑h '' Metric.closedBall x r = Metric.closedBall (h x) r
state_after: no goals
tactic: rw [← h.preimage_symm, h.symm.preimage_closedBall, symm_symm]
Theorem: Stream'.WSeq.tail_nil
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
⊢ nil.tail = nil
state_after: no goals
tactic: simp [tail]
Theorem: CstarRing.norm_mem_spectrum_of_nonneg
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Order.lean

Proof steps:
state_before: A : Type u_1
inst✝⁸ : NormedRing A
inst✝⁷ : StarRing A
inst✝⁶ : CstarRing A
inst✝⁵ : CompleteSpace A
inst✝⁴ : NormedAlgebra ℂ A
inst✝³ : StarModule ℂ A
inst✝² : PartialOrder A
inst✝¹ : StarOrderedRing A
inst✝ : Nontrivial A
a : A
ha : autoParam (0 ≤ a) _auto✝
⊢ ‖a‖ ∈ spectrum ℝ a
state_after: no goals
tactic: simpa using spectrum.algebraMap_mem ℝ <| CstarRing.nnnorm_mem_spectrum_of_nonneg ha
Theorem: Real.one_half_lt_eulerMascheroniSeq_six
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

Proof steps:
state_before: ⊢ 1 / 2 < eulerMascheroniSeq 6
state_after: this : eulerMascheroniSeq 6 = 49 / 20 - log 7
⊢ 1 / 2 < eulerMascheroniSeq 6
tactic: have : eulerMascheroniSeq 6 = 49 / 20 - log 7 := by
    rw [eulerMascheroniSeq]
    norm_num
state_before: this : eulerMascheroniSeq 6 = 49 / 20 - log 7
⊢ 1 / 2 < eulerMascheroniSeq 6
state_after: this : eulerMascheroniSeq 6 = 49 / 20 - log 7
⊢ 7 < rexp (49 / 20 - 1 / 2)
tactic: rw [this, lt_sub_iff_add_lt, ← lt_sub_iff_add_lt', log_lt_iff_lt_exp (by positivity)]
state_before: this : eulerMascheroniSeq 6 = 49 / 20 - log 7
⊢ 7 < rexp (49 / 20 - 1 / 2)
state_after: this : eulerMascheroniSeq 6 = 49 / 20 - log 7
⊢ 7 < ∑ i ∈ Finset.range 7, (49 / 20 - 1 / 2) ^ i / ↑i.factorial
tactic: refine lt_of_lt_of_le ?_ (Real.sum_le_exp_of_nonneg (by norm_num) 7)
state_before: this : eulerMascheroniSeq 6 = 49 / 20 - log 7
⊢ 7 < ∑ i ∈ Finset.range 7, (49 / 20 - 1 / 2) ^ i / ↑i.factorial
state_after: this : eulerMascheroniSeq 6 = 49 / 20 - log 7
⊢ 7 <
    ∑ i ∈ Finset.range 0, (49 / 20 - 1 / 2) ^ i / ↑i.factorial + (49 / 20 - 1 / 2) ^ 0 / ↑(Nat.factorial 0) +
                (49 / 20 - 1 / 2) ^ 1 / ↑((0 + 1) * Nat.factorial 0) +
              (49 / 20 - 1 / 2) ^ 2 / ↑((1 + 1) * ((0 + 1) * Nat.factorial 0)) +
            (49 / 20 - 1 / 2) ^ 3 / ↑((2 + 1) * ((1 + 1) * ((0 + 1) * Nat.factorial 0))) +
          (49 / 20 - 1 / 2) ^ 4 / ↑((3 + 1) * ((2 + 1) * ((1 + 1) * ((0 + 1) * Nat.factorial 0)))) +
        (49 / 20 - 1 / 2) ^ 5 / ↑((4 + 1) * ((3 + 1) * ((2 + 1) * ((1 + 1) * ((0 + 1) * Nat.factorial 0))))) +
      (49 / 20 - 1 / 2) ^ 6 / ↑((5 + 1) * ((4 + 1) * ((3 + 1) * ((2 + 1) * ((1 + 1) * ((0 + 1) * Nat.factorial 0))))))
tactic: simp_rw [Finset.sum_range_succ, Nat.factorial_succ]
state_before: this : eulerMascheroniSeq 6 = 49 / 20 - log 7
⊢ 7 <
    ∑ i ∈ Finset.range 0, (49 / 20 - 1 / 2) ^ i / ↑i.factorial + (49 / 20 - 1 / 2) ^ 0 / ↑(Nat.factorial 0) +
                (49 / 20 - 1 / 2) ^ 1 / ↑((0 + 1) * Nat.factorial 0) +
              (49 / 20 - 1 / 2) ^ 2 / ↑((1 + 1) * ((0 + 1) * Nat.factorial 0)) +
            (49 / 20 - 1 / 2) ^ 3 / ↑((2 + 1) * ((1 + 1) * ((0 + 1) * Nat.factorial 0))) +
          (49 / 20 - 1 / 2) ^ 4 / ↑((3 + 1) * ((2 + 1) * ((1 + 1) * ((0 + 1) * Nat.factorial 0)))) +
        (49 / 20 - 1 / 2) ^ 5 / ↑((4 + 1) * ((3 + 1) * ((2 + 1) * ((1 + 1) * ((0 + 1) * Nat.factorial 0))))) +
      (49 / 20 - 1 / 2) ^ 6 / ↑((5 + 1) * ((4 + 1) * ((3 + 1) * ((2 + 1) * ((1 + 1) * ((0 + 1) * Nat.factorial 0))))))
state_after: no goals
tactic: norm_num
Theorem: CategoryTheory.Limits.cokernelIsoOfEq_refl
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
h : f = f
⊢ cokernelIsoOfEq h = Iso.refl (cokernel f)
state_after: case w.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
h : f = f
⊢ coequalizer.π f 0 ≫ (cokernelIsoOfEq h).hom = coequalizer.π f 0 ≫ (Iso.refl (cokernel f)).hom
tactic: ext
state_before: case w.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
h : f = f
⊢ coequalizer.π f 0 ≫ (cokernelIsoOfEq h).hom = coequalizer.π f 0 ≫ (Iso.refl (cokernel f)).hom
state_after: no goals
tactic: simp [cokernelIsoOfEq]
Theorem: CochainComplex.HomComplex.Cocycle.equivHom_apply
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
⊢ ∀ (x y : F ⟶ G),
    { toFun := ofHom, invFun := homOf, left_inv := ⋯, right_inv := ⋯ }.toFun (x + y) =
      { toFun := ofHom, invFun := homOf, left_inv := ⋯, right_inv := ⋯ }.toFun x +
        { toFun := ofHom, invFun := homOf, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.unitIso_inv
File: Mathlib/CategoryTheory/Localization/Construction.lean

Proof steps:
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
⊢ 𝟭 (W.Localization ⥤ D) = functor W D ⋙ inverse W D
state_after: case refine_1
C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G✝ : C ⥤ D
hG : W.IsInvertedBy G✝
G : W.Localization ⥤ D
⊢ (𝟭 (W.Localization ⥤ D)).obj G = (functor W D ⋙ inverse W D).obj G

case refine_2
C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
G₁ G₂ : W.Localization ⥤ D
τ : G₁ ⟶ G₂
⊢ (𝟭 (W.Localization ⥤ D)).map τ = eqToHom ⋯ ≫ (functor W D ⋙ inverse W D).map τ ≫ eqToHom ⋯
tactic: refine Functor.ext (fun G => ?_) fun G₁ G₂ τ => ?_
Theorem: Equiv.Perm.decomposeFin_symm_apply_zero
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
p : Fin (n + 1)
e : Perm (Fin n)
⊢ (decomposeFin.symm (p, e)) 0 = p
state_after: no goals
tactic: simp [Equiv.Perm.decomposeFin]
Theorem: multiplicity.min_le_multiplicity_add
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≤ multiplicity p b
⊢ min (multiplicity p a) (multiplicity p b) ≤ multiplicity p (a + b)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≤ multiplicity p b
⊢ ∀ (n : ℕ), p ^ n ∣ a → p ^ n ∣ a + b
tactic: rw [min_eq_left h, multiplicity_le_multiplicity_iff]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≤ multiplicity p b
⊢ ∀ (n : ℕ), p ^ n ∣ a → p ^ n ∣ a + b
state_after: no goals
tactic: exact fun n hn => dvd_add hn (multiplicity_le_multiplicity_iff.1 h n hn)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b ≤ multiplicity p a
⊢ min (multiplicity p a) (multiplicity p b) ≤ multiplicity p (a + b)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b ≤ multiplicity p a
⊢ ∀ (n : ℕ), p ^ n ∣ b → p ^ n ∣ a + b
tactic: rw [min_eq_right h, multiplicity_le_multiplicity_iff]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b ≤ multiplicity p a
⊢ ∀ (n : ℕ), p ^ n ∣ b → p ^ n ∣ a + b
state_after: no goals
tactic: exact fun n hn => dvd_add (multiplicity_le_multiplicity_iff.1 h n hn) hn
Theorem: Filter.tendsto_div_const_atTop_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => f x / r) l atTop ↔ Tendsto f l atBot
state_after: no goals
tactic: simp [div_eq_mul_inv, tendsto_mul_const_atTop_of_neg, hr]
Theorem: CategoryTheory.ShortComplex.RightHomologyData.p_comp_opcyclesIso_inv
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
inst✝ : S.HasRightHomology
⊢ h.p ≫ h.opcyclesIso.inv = S.pOpcycles
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
inst✝ : S.HasRightHomology
⊢ h.p ≫ opcyclesMap' (𝟙 S) h S.rightHomologyData = S.rightHomologyData.p
tactic: dsimp [pOpcycles, RightHomologyData.opcyclesIso]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
inst✝ : S.HasRightHomology
⊢ h.p ≫ opcyclesMap' (𝟙 S) h S.rightHomologyData = S.rightHomologyData.p
state_after: no goals
tactic: simp only [p_opcyclesMap', id_τ₂, id_comp]
Theorem: Module.Baer.ExtensionOfMaxAdjoin.extendIdealTo_eq
File: Mathlib/Algebra/Module/Injective.lean

Proof steps:
state_before: R : Type u
inst✝⁷ : Ring R
Q : Type v
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M : Type u_1
N : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ⇑i)
h : Baer R Q
y : N
r : R
hr : r • y ∈ (extensionOfMax i f).domain
⊢ (extendIdealTo i f h y) r = ↑(extensionOfMax i f).toLinearPMap ⟨r • y, hr⟩
state_after: no goals
tactic: simp only [ExtensionOfMaxAdjoin.extendIdealTo_is_extension i f h _ _ hr,
    ExtensionOfMaxAdjoin.idealTo, LinearMap.coe_mk, Subtype.coe_mk, AddHom.coe_mk]
Theorem: Finset.Ico_filter_le_of_left_le
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
inst✝ : DecidablePred fun x => c ≤ x
hac : a ≤ c
⊢ filter (fun x => c ≤ x) (Ico a b) = Ico c b
state_after: case a
ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x✝ a b c : α
inst✝ : DecidablePred fun x => c ≤ x
hac : a ≤ c
x : α
⊢ x ∈ filter (fun x => c ≤ x) (Ico a b) ↔ x ∈ Ico c b
tactic: ext x
state_before: case a
ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x✝ a b c : α
inst✝ : DecidablePred fun x => c ≤ x
hac : a ≤ c
x : α
⊢ x ∈ filter (fun x => c ≤ x) (Ico a b) ↔ x ∈ Ico c b
state_after: case a
ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x✝ a b c : α
inst✝ : DecidablePred fun x => c ≤ x
hac : a ≤ c
x : α
⊢ a ≤ x ∧ c ≤ x ∧ x < b ↔ c ≤ x ∧ x < b
tactic: rw [mem_filter, mem_Ico, mem_Ico, and_comm, and_left_comm]
state_before: case a
ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x✝ a b c : α
inst✝ : DecidablePred fun x => c ≤ x
hac : a ≤ c
x : α
⊢ a ≤ x ∧ c ≤ x ∧ x < b ↔ c ≤ x ∧ x < b
state_after: no goals
tactic: exact and_iff_right_of_imp fun h => hac.trans h.1
Theorem: DihedralGroup.card_conjClasses_odd
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

Proof steps:
state_before: n : ℕ
hn : Odd n
⊢ Nat.card (ConjClasses (DihedralGroup n)) = (n + 3) / 2
state_after: no goals
tactic: rw [← Nat.mul_div_mul_left _ 2 hn.pos, ← card_commute_odd hn, mul_comm,
    card_comm_eq_card_conjClasses_mul_card, nat_card, Nat.mul_div_left _ (mul_pos two_pos hn.pos)]
Theorem: Equiv.symm_symm
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
⊢ e.symm.symm = e
state_after: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.symm.symm =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
tactic: cases e
state_before: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.symm.symm =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
state_after: no goals
tactic: rfl
Theorem: Composition.sizeUpTo_ofLength_le
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c : Composition n
i : ℕ
h : c.length ≤ i
⊢ c.sizeUpTo i = n
state_after: n : ℕ
c : Composition n
i : ℕ
h : c.length ≤ i
⊢ (take i c.blocks).sum = n
tactic: dsimp [sizeUpTo]
state_before: n : ℕ
c : Composition n
i : ℕ
h : c.length ≤ i
⊢ (take i c.blocks).sum = n
state_after: case h.e'_2.h.e'_4
n : ℕ
c : Composition n
i : ℕ
h : c.length ≤ i
⊢ take i c.blocks = c.blocks
tactic: convert c.blocks_sum
state_before: case h.e'_2.h.e'_4
n : ℕ
c : Composition n
i : ℕ
h : c.length ≤ i
⊢ take i c.blocks = c.blocks
state_after: no goals
tactic: exact take_all_of_le h
Theorem: comp_mul_right
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Semigroup α
x y : α
⊢ ((fun x_1 => x_1 * x) ∘ fun x => x * y) = fun x_1 => x_1 * (y * x)
state_after: case h
α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Semigroup α
x y z : α
⊢ ((fun x_1 => x_1 * x) ∘ fun x => x * y) z = z * (y * x)
tactic: ext z
state_before: case h
α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Semigroup α
x y z : α
⊢ ((fun x_1 => x_1 * x) ∘ fun x => x * y) z = z * (y * x)
state_after: no goals
tactic: simp [mul_assoc]
Theorem: MeasureTheory.exists_measurable_superset
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ : Measure α
s : Set α
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ μ t = μ s
state_after: no goals
tactic: simpa only [← measure_eq_trim] using μ.toOuterMeasure.exists_measurable_superset_eq_trim s
Theorem: Codisjoint.ne
File: Mathlib/Order/Disjoint.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : OrderTop α
a b c d : α
ha : a ≠ ⊤
hab : Codisjoint a b
h : a = b
⊢ Codisjoint a a
state_after: no goals
tactic: rwa [← h] at hab
Theorem: IntervalIntegrable.trans_iterate_Ico
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
hint : ∀ k ∈ Ico m n, IntervalIntegrable f μ (a k) (a (k + 1))
⊢ IntervalIntegrable f μ (a m) (a n)
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
⊢ (∀ k ∈ Ico m n, IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a n)
tactic: revert hint
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
⊢ (∀ k ∈ Ico m n, IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a n)
state_after: case refine_1
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
⊢ (∀ k ∈ Ico m m, IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a m)

case refine_2
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
⊢ ∀ (n : ℕ),
    m ≤ n →
      ((∀ k ∈ Ico m n, IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a n)) →
        (∀ k ∈ Ico m (n + 1), IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a (n + 1))
tactic: refine Nat.le_induction ?_ ?_ n hmn