ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.CosimplicialObject.Augmented.whiskering_map_app_right
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
⊢ (const D).map (η.app (point.obj A)) ≫ ((whiskeringObj C D Y✝).obj A).hom =
    ((whiskeringObj C D X✝).obj A).hom ≫ (𝟭 (CosimplicialObject D)).map (whiskerLeft (drop.obj A) η)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ ((const D).map (η.app (point.obj A)) ≫ ((whiskeringObj C D Y✝).obj A).hom).app n =
    (((whiskeringObj C D X✝).obj A).hom ≫ (𝟭 (CosimplicialObject D)).map (whiskerLeft (drop.obj A) η)).app n
tactic: ext n
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ ((const D).map (η.app (point.obj A)) ≫ ((whiskeringObj C D Y✝).obj A).hom).app n =
    (((whiskeringObj C D X✝).obj A).hom ≫ (𝟭 (CosimplicialObject D)).map (whiskerLeft (drop.obj A) η)).app n
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ η.app A.left ≫ 𝟙 (Y✝.obj A.left) ≫ Y✝.map (A.hom.app n) =
    (𝟙 (X✝.obj A.left) ≫ X✝.map (A.hom.app n)) ≫ η.app (A.right.obj n)
tactic: dsimp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ η.app A.left ≫ 𝟙 (Y✝.obj A.left) ≫ Y✝.map (A.hom.app n) =
    (𝟙 (X✝.obj A.left) ≫ X✝.map (A.hom.app n)) ≫ η.app (A.right.obj n)
state_after: no goals
tactic: rw [Category.id_comp, Category.id_comp, η.naturality]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
x✝¹ x✝ : Augmented C
f : x✝¹ ⟶ x✝
⊢ (whiskeringObj C D X✝).map f ≫
      (fun A => { left := η.app (point.obj A), right := whiskerLeft (drop.obj A) η, w := ⋯ }) x✝ =
    (fun A => { left := η.app (point.obj A), right := whiskerLeft (drop.obj A) η, w := ⋯ }) x✝¹ ≫
      (whiskeringObj C D Y✝).map f
state_after: no goals
tactic: ext <;> dsimp <;> simp
Theorem: AddSubmonoid.LocalizationMap.lift_comp
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
⊢ (f.lift hg).comp f.toMap = g
state_after: case h
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x✝ : M
⊢ ((f.lift hg).comp f.toMap) x✝ = g x✝
tactic: ext
state_before: case h
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x✝ : M
⊢ ((f.lift hg).comp f.toMap) x✝ = g x✝
state_after: no goals
tactic: exact f.lift_eq hg _
Theorem: MeasureTheory.Measure.singularPart_eq_zero_of_ac
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
h : μ ≪ ν
⊢ μ.singularPart ν = 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
h : μ ≪ ν
⊢ μ.singularPart ν ⟂ₘ μ.singularPart ν
tactic: rw [← MutuallySingular.self_iff]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
h : μ ≪ ν
⊢ μ.singularPart ν ⟂ₘ μ.singularPart ν
state_after: no goals
tactic: exact MutuallySingular.mono_ac (mutuallySingular_singularPart _ _)
    AbsolutelyContinuous.rfl ((absolutelyContinuous_of_le (singularPart_le _ _)).trans h)
Theorem: Finset.orderEmbOfFin_eq_orderEmbOfFin_iff
File: Mathlib/Data/Finset/Sort.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
k l : ℕ
s : Finset α
i : Fin k
j : Fin l
h : s.card = k
h' : s.card = l
⊢ (s.orderEmbOfFin h) i = (s.orderEmbOfFin h') j ↔ ↑i = ↑j
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
i j : Fin s.card
⊢ (s.orderEmbOfFin ⋯) i = (s.orderEmbOfFin ⋯) j ↔ ↑i = ↑j
tactic: substs k l
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
i j : Fin s.card
⊢ (s.orderEmbOfFin ⋯) i = (s.orderEmbOfFin ⋯) j ↔ ↑i = ↑j
state_after: no goals
tactic: exact (s.orderEmbOfFin rfl).eq_iff_eq.trans Fin.ext_iff
Theorem: Part.ext'
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o : od → α
pd : Prop
p : pd → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := pd, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := pd, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := pd, get := p }.get h₂
⊢ { Dom := od, get := o } = { Dom := pd, get := p }
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o : od → α
pd : Prop
p : pd → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := pd, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := pd, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := pd, get := p }.get h₂
t : od = pd
⊢ { Dom := od, get := o } = { Dom := pd, get := p }
tactic: have t : od = pd := propext H1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o : od → α
pd : Prop
p : pd → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := pd, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := pd, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := pd, get := p }.get h₂
t : od = pd
⊢ { Dom := od, get := o } = { Dom := pd, get := p }
state_after: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o p : od → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := od, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := od, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := od, get := p }.get h₂
⊢ { Dom := od, get := o } = { Dom := od, get := p }
tactic: cases t
state_before: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o p : od → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := od, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := od, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := od, get := p }.get h₂
⊢ { Dom := od, get := o } = { Dom := od, get := p }
state_after: no goals
tactic: rw [show o = p from funext fun p => H2 p p]
Theorem: CategoryTheory.MonoidalCategory.inv_whiskerRight
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝¹ : MonoidalCategory C
X Y : C
f : X ⟶ Y
Z : C
inst✝ : IsIso f
⊢ inv (f ▷ Z) = inv f ▷ Z
state_after: no goals
tactic: aesop_cat
Theorem: List.head!_eq_head?
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : Inhabited α
l : List α
⊢ l.head! = l.head?.iget
state_after: no goals
tactic: cases l <;> rfl
Theorem: LieDerivation.IsKilling.ad_mem_orthogonal_of_mem_orthogonal
File: Mathlib/Algebra/Lie/Derivation/Killing.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝³ : Field R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : Module.Finite R L
D : LieDerivation R L L
hD : D ∈ (killingForm R (LieDerivation R L L)).orthogonal (ad R L).range.toSubmodule
x : L
⊢ (ad R L) (D x) ∈ (killingForm R (LieDerivation R L L)).orthogonal (ad R L).range.toSubmodule
state_after: R : Type u_1
L : Type u_2
inst✝³ : Field R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : Module.Finite R L
D : LieDerivation R L L
hD : D ∈ (killingForm R (LieDerivation R L L)).orthogonal (ad R L).range.toSubmodule
x : L
⊢ ⁅x, D⁆ ∈ (killingForm R (LieDerivation R L L)).orthogonal (LinearMap.range ↑(ad R L))
tactic: simp only [ad_apply_lieDerivation, LieHom.range_coeSubmodule, neg_mem_iff]
state_before: R : Type u_1
L : Type u_2
inst✝³ : Field R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : Module.Finite R L
D : LieDerivation R L L
hD : D ∈ (killingForm R (LieDerivation R L L)).orthogonal (ad R L).range.toSubmodule
x : L
⊢ ⁅x, D⁆ ∈ (killingForm R (LieDerivation R L L)).orthogonal (LinearMap.range ↑(ad R L))
state_after: no goals
tactic: exact (rangeAdOrthogonal R L).lie_mem hD
Theorem: hasSum_zero
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
⊢ HasProd (fun x => 1) 1
state_after: no goals
tactic: simp [HasProd, tendsto_const_nhds]
Theorem: Metric.forall_of_forall_mem_ball
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
p : α → Prop
x : α
H : ∃ᶠ (R : ℝ) in atTop, ∀ y ∈ ball x R, p y
y : α
⊢ p y
state_after: case intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
p : α → Prop
x : α
H : ∃ᶠ (R : ℝ) in atTop, ∀ y ∈ ball x R, p y
y : α
R : ℝ
hR : R > dist y x
h : ∀ z ∈ ball x R, p z
⊢ p y
tactic: obtain ⟨R, hR, h⟩ : ∃ R > dist y x, ∀ z : α, z ∈ ball x R → p z :=
    frequently_iff.1 H (Ioi_mem_atTop (dist y x))
state_before: case intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
p : α → Prop
x : α
H : ∃ᶠ (R : ℝ) in atTop, ∀ y ∈ ball x R, p y
y : α
R : ℝ
hR : R > dist y x
h : ∀ z ∈ ball x R, p z
⊢ p y
state_after: no goals
tactic: exact h _ hR
Theorem: Finset.diag_mem_sym2_mem_iff
File: Mathlib/Data/Finset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ (∀ b ∈ Sym2.diag a, b ∈ s) ↔ a ∈ s
state_after: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ Sym2.diag a ∈ s.sym2 ↔ a ∈ s
tactic: rw [← mem_sym2_iff]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ Sym2.diag a ∈ s.sym2 ↔ a ∈ s
state_after: no goals
tactic: exact mk_mem_sym2_iff.trans <| and_self_iff
Theorem: Stream'.Seq.destruct_eq_nil
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ s.destruct = none → s = nil
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ Option.map (fun a' => (a', s.tail)) (s.get? 0) = none → s = nil
tactic: dsimp [destruct]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ Option.map (fun a' => (a', s.tail)) (s.get? 0) = none → s = nil
state_after: case none
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
⊢ s = nil

case some
α : Type u
β : Type v
γ : Type w
s : Seq α
val✝ : α
f0 : s.get? 0 = some val✝
h : Option.map (fun a' => (a', s.tail)) (some val✝) = none
⊢ s = nil
tactic: induction' f0 : get? s 0 <;> intro h
Theorem: OnePoint.isClosed_iff_of_not_mem
File: Mathlib/Topology/Compactification/OnePoint.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ∞ ∉ s
⊢ IsClosed s ↔ IsClosed (some ⁻¹' s) ∧ IsCompact (some ⁻¹' s)
state_after: no goals
tactic: rw [← isOpen_compl_iff, isOpen_iff_of_mem (mem_compl h), ← preimage_compl, compl_compl]
Theorem: CategoryTheory.ShortComplex.opcyclesIsoX₂_inv
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{?u.84561, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : S.HasRightHomology
hf : S.f = 0
⊢ S.opcycles ≅ S.X₂
state_after: C : Type u_1
inst✝² : Category.{?u.84561, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : S.HasRightHomology
hf : S.f = 0
this : IsIso S.pOpcycles
⊢ S.opcycles ≅ S.X₂
tactic: have := S.isIso_pOpcycles hf
state_before: C : Type u_1
inst✝² : Category.{?u.84561, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : S.HasRightHomology
hf : S.f = 0
this : IsIso S.pOpcycles
⊢ S.opcycles ≅ S.X₂
state_after: no goals
tactic: exact (asIso S.pOpcycles).symm
Theorem: CategoryTheory.finallySmall_iff_exists_small_weakly_terminal_set
File: Mathlib/CategoryTheory/Limits/FinallySmall.lean

Proof steps:
state_before: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsFilteredOrEmpty J
⊢ FinallySmall J ↔ ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
state_after: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsFilteredOrEmpty J
h : ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
⊢ FinallySmall J
tactic: refine ⟨fun _ => FinallySmall.exists_small_weakly_terminal_set _, fun h => ?_⟩
state_before: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsFilteredOrEmpty J
h : ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
⊢ FinallySmall J
state_after: case intro.intro
J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsFilteredOrEmpty J
s : Set J
hs : Small.{v, u} ↑s
hs' : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
⊢ FinallySmall J
tactic: rcases h with ⟨s, hs, hs'⟩
state_before: case intro.intro
J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : IsFilteredOrEmpty J
s : Set J
hs : Small.{v, u} ↑s
hs' : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
⊢ FinallySmall J
state_after: no goals
tactic: exact finallySmall_of_small_weakly_terminal_set s hs'
Theorem: CategoryTheory.Limits.map_lift_pullbackComparison
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
W✝ X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ G.map h ≫ G.map f = G.map k ≫ G.map g
state_after: no goals
tactic: simp only [← G.map_comp, w]
state_before: C : Type u
inst✝³ : Category.{v, u} C
W✝ X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ G.map (pullback.lift h k w) ≫ pullbackComparison G f g = pullback.lift (G.map h) (G.map k) ⋯
state_after: no goals
tactic: ext <;> simp [← G.map_comp]
Theorem: Mathlib.Meta.NormNum.isRat_inv_pos
File: Mathlib/Tactic/NormNum/Inv.lean

Proof steps:
state_before: u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
a : α
n d : ℕ
⊢ IsRat a (Int.ofNat n.succ) d → IsRat a⁻¹ (Int.ofNat d) n.succ
state_after: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
⊢ IsRat (↑(Int.ofNat n.succ) * ⅟↑d)⁻¹ (Int.ofNat d) n.succ
tactic: rintro ⟨_, rfl⟩
state_before: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
⊢ IsRat (↑(Int.ofNat n.succ) * ⅟↑d)⁻¹ (Int.ofNat d) n.succ
state_after: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
this : Invertible ↑n.succ
⊢ IsRat (↑(Int.ofNat n.succ) * ⅟↑d)⁻¹ (Int.ofNat d) n.succ
tactic: have := invertibleOfNonzero (α := α) (Nat.cast_ne_zero.2 (Nat.succ_ne_zero n))
state_before: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
this : Invertible ↑n.succ
⊢ IsRat (↑(Int.ofNat n.succ) * ⅟↑d)⁻¹ (Int.ofNat d) n.succ
state_after: no goals
tactic: exact ⟨this, by simp⟩
Theorem: CategoryTheory.PreGaloisCategory.fiberBinaryProductEquiv_symm_fst_apply
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ F.map prod.fst ((fiberBinaryProductEquiv F X Y).symm (x, y)) = x
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ F.map prod.fst
      ((PreservesLimitPair.iso (F ⋙ FintypeCat.incl) X Y).inv
        ((Types.binaryProductIso ↑(F.obj X) ↑(F.obj Y)).inv (x, y))) =
    x
tactic: simp only [fiberBinaryProductEquiv, comp_obj, FintypeCat.incl_obj, Iso.toEquiv_comp,
    Equiv.symm_trans_apply, Iso.toEquiv_symm_fun]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ F.map prod.fst
      ((PreservesLimitPair.iso (F ⋙ FintypeCat.incl) X Y).inv
        ((Types.binaryProductIso ↑(F.obj X) ↑(F.obj Y)).inv (x, y))) =
    x
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ ((Types.binaryProductIso ↑(F.obj X) ↑(F.obj Y)).inv ≫
        (PreservesLimitPair.iso (F ⋙ FintypeCat.incl) X Y).inv ≫ (F ⋙ FintypeCat.incl).map prod.fst)
      (x, y) =
    x
tactic: change ((Types.binaryProductIso _ _).inv ≫ _ ≫ (F ⋙ FintypeCat.incl).map prod.fst) _ = _
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
x : ↑(F.obj X)
y : ↑(F.obj Y)
⊢ ((Types.binaryProductIso ↑(F.obj X) ↑(F.obj Y)).inv ≫
        (PreservesLimitPair.iso (F ⋙ FintypeCat.incl) X Y).inv ≫ (F ⋙ FintypeCat.incl).map prod.fst)
      (x, y) =
    x
state_after: no goals
tactic: erw [PreservesLimitPair.iso_inv_fst, Types.binaryProductIso_inv_comp_fst]
Theorem: div_le_one_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ a / b ≤ 1 ↔ b ≤ a
state_after: no goals
tactic: rw [div_le_iff_of_neg hb, one_mul]
Theorem: addOrderOf_eq_iff
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
h : 0 < n
⊢ orderOf x = n ↔ x ^ n = 1 ∧ ∀ m < n, 0 < m → x ^ m ≠ 1
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
h : 0 < n
⊢ (if h : 1 ∈ periodicPts fun x_1 => x * x_1 then Nat.find h else 0) = n ↔
    IsPeriodicPt (fun x_1 => x * x_1) n 1 ∧ ∀ m < n, 0 < m → ¬IsPeriodicPt (fun x_1 => x * x_1) m 1
tactic: simp_rw [Ne, ← isPeriodicPt_mul_iff_pow_eq_one, orderOf, minimalPeriod]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
h : 0 < n
⊢ (if h : 1 ∈ periodicPts fun x_1 => x * x_1 then Nat.find h else 0) = n ↔
    IsPeriodicPt (fun x_1 => x * x_1) n 1 ∧ ∀ m < n, 0 < m → ¬IsPeriodicPt (fun x_1 => x * x_1) m 1
state_after: case pos
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
h : 0 < n
h1 : 1 ∈ periodicPts fun x_1 => x * x_1
⊢ Nat.find h1 = n ↔ IsPeriodicPt (fun x_1 => x * x_1) n 1 ∧ ∀ m < n, 0 < m → ¬IsPeriodicPt (fun x_1 => x * x_1) m 1

case neg
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
h : 0 < n
h1 : 1 ∉ periodicPts fun x_1 => x * x_1
⊢ 0 = n ↔ IsPeriodicPt (fun x_1 => x * x_1) n 1 ∧ ∀ m < n, 0 < m → ¬IsPeriodicPt (fun x_1 => x * x_1) m 1
tactic: split_ifs with h1
Theorem: Wbtw.trans_sbtw_right
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R w x z
h₂ : Sbtw R x y z
⊢ Sbtw R w y z
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R z x w
h₂ : Sbtw R x y z
⊢ Sbtw R w y z
tactic: rw [wbtw_comm] at *
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R z x w
h₂ : Sbtw R x y z
⊢ Sbtw R w y z
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R z x w
h₂ : Sbtw R z y x
⊢ Sbtw R z y w
tactic: rw [sbtw_comm] at *
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R z x w
h₂ : Sbtw R z y x
⊢ Sbtw R z y w
state_after: no goals
tactic: exact h₁.trans_sbtw_left h₂
Theorem: schnirelmannDensity_insert_zero
File: Mathlib/Combinatorics/Schnirelmann.lean

Proof steps:
state_before: A : Set ℕ
inst✝¹ : DecidablePred fun x => x ∈ A
inst✝ : DecidablePred fun x => x ∈ insert 0 A
⊢ ∀ n > 0, n ∈ insert 0 A ↔ n ∈ A
state_after: no goals
tactic: aesop
Theorem: lp.single_neg
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
⊢ lp.single p i (-a) = -lp.single p i a
state_after: α : Type u_1
E : α → Type u_2
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
j : α
⊢ ↑(lp.single p i (-a)) j = ↑(-lp.single p i a) j
tactic: refine ext (funext (fun (j : α) => ?_))
state_before: α : Type u_1
E : α → Type u_2
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
j : α
⊢ ↑(lp.single p i (-a)) j = ↑(-lp.single p i a) j
state_after: case pos
α : Type u_1
E : α → Type u_2
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
j : α
hi : j = i
⊢ ↑(lp.single p i (-a)) j = ↑(-lp.single p i a) j

case neg
α : Type u_1
E : α → Type u_2
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
j : α
hi : ¬j = i
⊢ ↑(lp.single p i (-a)) j = ↑(-lp.single p i a) j
tactic: by_cases hi : j = i
Theorem: List.mapIdx_append
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
K L : List α
f : ℕ → α → β
⊢ mapIdx f (K ++ L) = mapIdx f K ++ mapIdx (fun i a => f (i + K.length) a) L
state_after: case nil
α : Type u
β : Type v
L : List α
f : ℕ → α → β
⊢ mapIdx f ([] ++ L) = mapIdx f [] ++ mapIdx (fun i a => f (i + [].length) a) L

case cons
α : Type u
β : Type v
L : List α
a : α
J : List α
IH : ∀ (f : ℕ → α → β), mapIdx f (J ++ L) = mapIdx f J ++ mapIdx (fun i a => f (i + J.length) a) L
f : ℕ → α → β
⊢ mapIdx f (a :: J ++ L) = mapIdx f (a :: J) ++ mapIdx (fun i a_1 => f (i + (a :: J).length) a_1) L
tactic: induction' K with a J IH generalizing f