1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: WellFounded.monotone_chain_condition'
File: Mathlib/Order/OrderIsoNat.lean

tactic: refine ⟨fun h a => ?_, fun h => ?_⟩
state_before: α : Type u_1
inst✝ : Preorder α
⊢ (WellFounded fun x x_1 => x > x_1) ↔ ∀ (a : ℕ →o α), ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
state_after: case refine_1
α : Type u_1
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
⊢ ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m

case refine_2
α : Type u_1
inst✝ : Preorder α
h : ∀ (a : ℕ →o α), ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
⊢ WellFounded fun x x_1 => x > x_1

tactic: have hne : (Set.range a).Nonempty := ⟨a 0, by simp⟩
state_before: case refine_1
α : Type u_1
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
⊢ ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
state_after: case refine_1
α : Type u_1
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
hne : (Set.range ⇑a).Nonempty
⊢ ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m

tactic: obtain ⟨x, ⟨n, rfl⟩, H⟩ := h.has_min _ hne
state_before: case refine_1
α : Type u_1
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
hne : (Set.range ⇑a).Nonempty
⊢ ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
state_after: case refine_1.intro.intro.intro
α : Type u_1
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
hne : (Set.range ⇑a).Nonempty
n : ℕ
H : ∀ x ∈ Set.range ⇑a, ¬x > a n
⊢ ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m

tactic: exact ⟨n, fun m _ => H _ (Set.mem_range_self _)⟩
state_before: case refine_1.intro.intro.intro
α : Type u_1
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
hne : (Set.range ⇑a).Nonempty
n : ℕ
H : ∀ x ∈ Set.range ⇑a, ¬x > a n
⊢ ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
⊢ a 0 ∈ Set.range ⇑a
state_after: no goals

tactic: refine RelEmbedding.wellFounded_iff_no_descending_seq.2 ⟨fun a => ?_⟩
state_before: case refine_2
α : Type u_1
inst✝ : Preorder α
h : ∀ (a : ℕ →o α), ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
⊢ WellFounded fun x x_1 => x > x_1
state_after: case refine_2
α : Type u_1
inst✝ : Preorder α
h : ∀ (a : ℕ →o α), ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
a : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ False

tactic: exact hn n.succ n.lt_succ_self.le ((RelEmbedding.map_rel_iff _).2 n.lt_succ_self)
state_before: case refine_2.intro
α : Type u_1
inst✝ : Preorder α
h : ∀ (a : ℕ →o α), ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
a : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
n : ℕ
hn : ∀ (m : ℕ), n ≤ m → ¬a.swap.toRelHom.toOrderHom n < a.swap.toRelHom.toOrderHom m
⊢ False
state_after: no goals
Theorem: ProbabilityTheory.kernel.sum_add
File: Mathlib/Probability/Kernel/Basic.lean

tactic: ext a s hs
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
inst✝ : Countable ι
κ η : ι → ↥(kernel α β)
⊢ (kernel.sum fun n => κ n + η n) = kernel.sum κ + kernel.sum η
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
inst✝ : Countable ι
κ η : ι → ↥(kernel α β)
a : α
s : Set β
hs : MeasurableSet s
⊢ ((kernel.sum fun n => κ n + η n) a) s = ((kernel.sum κ + kernel.sum η) a) s

tactic: simp only [coeFn_add, Pi.add_apply, sum_apply, Measure.sum_apply _ hs, Pi.add_apply,
  Measure.coe_add, tsum_add ENNReal.summable ENNReal.summable]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
inst✝ : Countable ι
κ η : ι → ↥(kernel α β)
a : α
s : Set β
hs : MeasurableSet s
⊢ ((kernel.sum fun n => κ n + η n) a) s = ((kernel.sum κ + kernel.sum η) a) s
state_after: no goals
Theorem: CategoryTheory.FreeBicategory.liftHom₂_congr
File: Mathlib/CategoryTheory/Bicategory/Free.lean

tactic: induction H <;> (dsimp [liftHom₂]; aesop_cat)
state_before: B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
H : Rel η θ
⊢ liftHom₂ F η = liftHom₂ F θ
state_after: no goals

tactic: dsimp [liftHom₂]
state_before: case triangle
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
⊢ liftHom₂ F ((Hom₂.associator f✝ (Hom.id b✝) g✝).vcomp (Hom₂.whisker_left f✝ (Hom₂.left_unitor g✝))) =
    liftHom₂ F (Hom₂.whisker_right g✝ (Hom₂.right_unitor f✝))
state_after: case triangle
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
⊢ (α_ (liftHom F f✝) (𝟙 (F.obj b✝)) (liftHom F g✝)).hom ≫ liftHom F f✝ ◁ (λ_ (liftHom F g✝)).hom =
    (ρ_ (liftHom F f✝)).hom ▷ liftHom F g✝

tactic: aesop_cat
state_before: case triangle
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
⊢ (α_ (liftHom F f✝) (𝟙 (F.obj b✝)) (liftHom F g✝)).hom ≫ liftHom F f✝ ◁ (λ_ (liftHom F g✝)).hom =
    (ρ_ (liftHom F f✝)).hom ▷ liftHom F g✝
state_after: no goals
Theorem: ProbabilityTheory.iIndepSets_iff
File: Mathlib/Probability/Independence/Basic.lean

tactic: simp only [iIndepSets, kernel.iIndepSets, ae_dirac_eq, Filter.eventually_pure, kernel.const_apply]
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π✝ : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
π : ι → Set (Set Ω)
μ : Measure Ω
⊢ iIndepSets π μ ↔ ∀ (s : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s, f i ∈ π i) → μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)
state_after: no goals
Theorem: Hyperreal.infinite_mul_of_not_infinitesimal_infinite
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [mul_comm]
state_before: x y : ℝ*
hx : ¬x.Infinitesimal
hy : y.Infinite
⊢ (x * y).Infinite
state_after: x y : ℝ*
hx : ¬x.Infinitesimal
hy : y.Infinite
⊢ (y * x).Infinite

tactic: exact infinite_mul_of_infinite_not_infinitesimal hy hx
state_before: x y : ℝ*
hx : ¬x.Infinitesimal
hy : y.Infinite
⊢ (y * x).Infinite
state_after: no goals
Theorem: UnionFind.model'
File: Mathlib/Data/UnionFind.lean

tactic: let ⟨n, m, hm⟩ := self.model
state_before: α : Type u_1
self : UnionFind α
⊢ ∃ m, UFModel.Models self.arr m
state_after: α : Type u_1
self : UnionFind α
n : ℕ
m : UFModel n
hm : UFModel.Models self.arr m
⊢ ∃ m, UFModel.Models self.arr m

tactic: cases hm.size_eq
state_before: α : Type u_1
self : UnionFind α
n : ℕ
m : UFModel n
hm : UFModel.Models self.arr m
⊢ ∃ m, UFModel.Models self.arr m
state_after: case refl
α : Type u_1
self : UnionFind α
m : UFModel self.arr.size
hm : UFModel.Models self.arr m
⊢ ∃ m, UFModel.Models self.arr m

tactic: exact ⟨m, hm⟩
state_before: case refl
α : Type u_1
self : UnionFind α
m : UFModel self.arr.size
hm : UFModel.Models self.arr m
⊢ ∃ m, UFModel.Models self.arr m
state_after: no goals
Theorem: Polynomial.roots_map
File: Mathlib/Algebra/Polynomial/Splits.lean

tactic: convert (natDegree_eq_card_roots hf).symm
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : Splits (RingHom.id K) f
⊢ Multiset.card f.roots = f.natDegree
state_after: case h.e'_2.h.e'_6.h.e'_4
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : Splits (RingHom.id K) f
⊢ f = map (RingHom.id K) f

tactic: rw [map_id]
state_before: case h.e'_2.h.e'_6.h.e'_4
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : Splits (RingHom.id K) f
⊢ f = map (RingHom.id K) f
state_after: no goals
Theorem: mem_rootsOfUnity'
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [mem_rootsOfUnity]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k✝ l k : ℕ+
ζ : Mˣ
⊢ ζ ∈ rootsOfUnity k M ↔ ↑ζ ^ ↑k = 1
state_after: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k✝ l k : ℕ+
ζ : Mˣ
⊢ ζ ^ ↑k = 1 ↔ ↑ζ ^ ↑k = 1

tactic: norm_cast
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k✝ l k : ℕ+
ζ : Mˣ
⊢ ζ ^ ↑k = 1 ↔ ↑ζ ^ ↑k = 1
state_after: no goals
Theorem: SimpleGraph.neighborFinset_compl
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

tactic: simp only [neighborFinset, neighborSet_compl, Set.toFinset_diff, Set.toFinset_compl,
  Set.toFinset_singleton]
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableEq V
inst✝ : DecidableRel G.Adj
v : V
⊢ Gᶜ.neighborFinset v = (G.neighborFinset v)ᶜ \ {v}
state_after: no goals
Theorem: IsRingHom.comp
File: Mathlib/Deprecated/Ring.lean

tactic: simp only [Function.comp_apply, map_add hf, map_add hg]
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x✝ y✝ : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
x y : α
⊢ (g ∘ f) (x + y) = (g ∘ f) x + (g ∘ f) y
state_after: no goals

tactic: simp only [Function.comp_apply, map_mul hf, map_mul hg]
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x✝ y✝ : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
x y : α
⊢ (g ∘ f) (x * y) = (g ∘ f) x * (g ∘ f) y
state_after: no goals

tactic: simp only [Function.comp_apply, map_one hf, map_one hg]
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
⊢ (g ∘ f) 1 = 1
state_after: no goals
Theorem: MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range'
File: Mathlib/Probability/Process/Stopping.lean

tactic: exact hτ.measurableSet_eq_of_countable_range h_countable i
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet {ω | τ ω = i}
state_after: no goals
Theorem: Matrix.vec3_eq
File: Mathlib/Data/Matrix/Notation.lean

tactic: subst_vars
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
a₀ a₁ a₂ b₀ b₁ b₂ : α
h₀ : a₀ = b₀
h₁ : a₁ = b₁
h₂ : a₂ = b₂
⊢ ![a₀, a₁, a₂] = ![b₀, b₁, b₂]
state_after: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
b₀ b₁ b₂ : α
⊢ ![b₀, b₁, b₂] = ![b₀, b₁, b₂]

tactic: rfl
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
b₀ b₁ b₂ : α
⊢ ![b₀, b₁, b₂] = ![b₀, b₁, b₂]
state_after: no goals
Theorem: CategoryTheory.Limits.PreservesPushout.inl_iso_inv
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean

tactic: simp [PreservesPushout.iso, Iso.comp_inv_eq]
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
W X Y Z : C
h : X ⟶ Z
k : Y ⟶ Z
f : W ⟶ X
g : W ⟶ Y
comm : f ≫ h = g ≫ k
inst✝² : PreservesColimit (span f g) G
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
⊢ G.map pushout.inl ≫ (iso G f g).inv = pushout.inl
state_after: no goals
Theorem: finSuccEquiv'_ne_last_apply
File: Mathlib/Logic/Equiv/Fin.lean

tactic: rcases Fin.exists_succAbove_eq hj with ⟨j, rfl⟩
state_before: m n : ℕ
i j : Fin (n + 1)
hi : i ≠ Fin.last n
hj : j ≠ i
⊢ (finSuccEquiv' i) j = some ((i.castLT ⋯).predAbove j)
state_after: case intro
m n : ℕ
i : Fin (n + 1)
hi : i ≠ Fin.last n
j : Fin n
hj : i.succAbove j ≠ i
⊢ (finSuccEquiv' i) (i.succAbove j) = some ((i.castLT ⋯).predAbove (i.succAbove j))

tactic: rcases Fin.exists_castSucc_eq.2 hi with ⟨i, rfl⟩
state_before: case intro
m n : ℕ
i : Fin (n + 1)
hi : i ≠ Fin.last n
j : Fin n
hj : i.succAbove j ≠ i
⊢ (finSuccEquiv' i) (i.succAbove j) = some ((i.castLT ⋯).predAbove (i.succAbove j))
state_after: case intro.intro
m n : ℕ
j i : Fin n
hi : i.castSucc ≠ Fin.last n
hj : i.castSucc.succAbove j ≠ i.castSucc
⊢ (finSuccEquiv' i.castSucc) (i.castSucc.succAbove j) = some ((i.castSucc.castLT ⋯).predAbove (i.castSucc.succAbove j))

tactic: simp
state_before: case intro.intro
m n : ℕ
j i : Fin n
hi : i.castSucc ≠ Fin.last n
hj : i.castSucc.succAbove j ≠ i.castSucc
⊢ (finSuccEquiv' i.castSucc) (i.castSucc.succAbove j) = some ((i.castSucc.castLT ⋯).predAbove (i.castSucc.succAbove j))
state_after: no goals
Theorem: List.mapIdx_eq_nil
File: Mathlib/Data/List/Indexes.lean

tactic: rw [List.mapIdx_eq_enum_map, List.map_eq_nil, List.enum_eq_nil]
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
⊢ mapIdx f l = [] ↔ l = []
state_after: no goals
Theorem: Set.preimage_mul_const_Ico_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iio, ← Ioi_inter_Iic, h, inter_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x => x * c) ⁻¹' Ico a b = Ioc (b / c) (a / c)
state_after: no goals
Theorem: PowerSeries.exists_coeff_ne_zero_iff_ne_zero
File: Mathlib/RingTheory/PowerSeries/Order.lean

tactic: refine not_iff_not.mp ?_
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (∃ n, (coeff R n) φ ≠ 0) ↔ φ ≠ 0
state_after: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (¬∃ n, (coeff R n) φ ≠ 0) ↔ ¬φ ≠ 0

tactic: push_neg
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (¬∃ n, (coeff R n) φ ≠ 0) ↔ ¬φ ≠ 0
state_after: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (∀ (n : ℕ), (coeff R n) φ = 0) ↔ φ = 0

tactic: simp [PowerSeries.ext_iff, (coeff R _).map_zero]
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (∀ (n : ℕ), (coeff R n) φ = 0) ↔ φ = 0
state_after: no goals
Theorem: norm_div_sub_norm_div_le_norm_div
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [div_div_div_cancel_right'] using norm_sub_norm_le' (u / w) (v / w)
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v w : E
⊢ ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖
state_after: no goals
Theorem: Finset.image_insert
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [insert_eq, image_singleton, image_union]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
a : α
s : Finset α
⊢ image f (insert a s) = insert (f a) (image f s)
state_after: no goals
Theorem: CategoryTheory.coconeOfRepresentable_naturality
File: Mathlib/CategoryTheory/Limits/Presheaf.lean

tactic: ext T f
state_before: C : Type u₁
inst✝¹ : SmallCategory C
ℰ : Type u₂
inst✝ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
P₁ P₂ : Cᵒᵖ ⥤ Type u₁
α : P₁ ⟶ P₂
j : P₁.Elementsᵒᵖ
⊢ (coconeOfRepresentable P₁).ι.app j ≫ α = (coconeOfRepresentable P₂).ι.app ((CategoryOfElements.map α).op.obj j)
state_after: case w.h.h
C : Type u₁
inst✝¹ : SmallCategory C
ℰ : Type u₂
inst✝ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
P₁ P₂ : Cᵒᵖ ⥤ Type u₁
α : P₁ ⟶ P₂
j : P₁.Elementsᵒᵖ
T : Cᵒᵖ
f : ((functorToRepresentables P₁).obj j).obj T
⊢ ((coconeOfRepresentable P₁).ι.app j ≫ α).app T f =
    ((coconeOfRepresentable P₂).ι.app ((CategoryOfElements.map α).op.obj j)).app T f

tactic: simpa [coconeOfRepresentable_ι_app] using FunctorToTypes.naturality _ _ α f.op _
state_before: case w.h.h
C : Type u₁
inst✝¹ : SmallCategory C
ℰ : Type u₂
inst✝ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
P₁ P₂ : Cᵒᵖ ⥤ Type u₁
α : P₁ ⟶ P₂
j : P₁.Elementsᵒᵖ
T : Cᵒᵖ
f : ((functorToRepresentables P₁).obj j).obj T
⊢ ((coconeOfRepresentable P₁).ι.app j ≫ α).app T f =
    ((coconeOfRepresentable P₂).ι.app ((CategoryOfElements.map α).op.obj j)).app T f
state_after: no goals
Theorem: WithTop.iInf_coe_eq_top
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: simp [isEmpty_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
f : ι → α
⊢ ⨅ x, ↑(f x) = ⊤ ↔ IsEmpty ι
state_after: no goals
Theorem: ProbabilityTheory.iIndepFun_iff_iIndep
File: Mathlib/Probability/Independence/Basic.lean

tactic: simp only [iIndepFun, iIndep, kernel.iIndepFun]
state_before: Ω : Type u_1
ι : Type u_2
β✝ : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m✝ : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
β : ι → Type u_6
m : (x : ι) → MeasurableSpace (β x)
f : (x : ι) → Ω → β x
μ : Measure Ω
⊢ iIndepFun m f μ ↔ iIndep (fun x => MeasurableSpace.comap (f x) (m x)) μ
state_after: no goals
Theorem: CategoryTheory.SingleFunctors.shiftIso_zero_inv_app
File: Mathlib/CategoryTheory/Shift/SingleFunctors.lean

tactic: rw [shiftIso_zero]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁵ : Category.{u_7, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
inst✝³ : Category.{?u.27723, u_3} E
A : Type u_5
inst✝² : AddMonoid A
inst✝¹ : HasShift D A
inst✝ : HasShift E A
F G H : SingleFunctors C D A
a : A
X : C
⊢ (F.shiftIso 0 a a ⋯).inv.app X = (shiftFunctorZero D A).inv.app ((F.functor a).toPrefunctor.1 X)
state_after: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁵ : Category.{u_7, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
inst✝³ : Category.{?u.27723, u_3} E
A : Type u_5
inst✝² : AddMonoid A
inst✝¹ : HasShift D A
inst✝ : HasShift E A
F G H : SingleFunctors C D A
a : A
X : C
⊢ (isoWhiskerLeft (F.functor a) (shiftFunctorZero D A)).inv.app X =
    (shiftFunctorZero D A).inv.app ((F.functor a).toPrefunctor.1 X)

tactic: rfl
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁵ : Category.{u_7, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
inst✝³ : Category.{?u.27723, u_3} E
A : Type u_5
inst✝² : AddMonoid A
inst✝¹ : HasShift D A
inst✝ : HasShift E A
F G H : SingleFunctors C D A
a : A
X : C
⊢ (isoWhiskerLeft (F.functor a) (shiftFunctorZero D A)).inv.app X =
    (shiftFunctorZero D A).inv.app ((F.functor a).toPrefunctor.1 X)
state_after: no goals
Theorem: CategoryTheory.ε_inv_naturality
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: aesop_cat
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
X Y : C
f : X ⟶ Y
⊢ F.εIso.inv.app X ≫ (𝟙_ (C ⥤ C)).map f = F.εIso.inv.app X ≫ f
state_after: no goals
Theorem: Topology.IsUpperSet.upperSet_le_upper
File: Mathlib/Topology/Order/UpperLowerSetTopology.lean

tactic: rw [@isOpen_iff_isUpperSet α _ t₁]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Preorder α
inst✝² : Preorder β
t₁ t₂ : TopologicalSpace α
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper α
s : Set α
hs : IsOpen s
⊢ IsOpen s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Preorder α
inst✝² : Preorder β
t₁ t₂ : TopologicalSpace α
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper α
s : Set α
hs : IsOpen s
⊢ IsUpperSet s

tactic: exact IsUpper.isUpperSet_of_isOpen hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Preorder α
inst✝² : Preorder β
t₁ t₂ : TopologicalSpace α
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper α
s : Set α
hs : IsOpen s
⊢ IsUpperSet s
state_after: no goals
Theorem: ContextFreeRule.reverse_involutive
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: intro x
state_before: T : Type uT
N : Type uN
⊢ Function.Involutive reverse
state_after: T : Type uT
N : Type uN
x : ContextFreeRule T N
⊢ x.reverse.reverse = x

tactic: simp [ContextFreeRule.reverse]
state_before: T : Type uT
N : Type uN
x : ContextFreeRule T N
⊢ x.reverse.reverse = x
state_after: no goals
Theorem: Subalgebra.isClosed_topologicalClosure
File: Mathlib/Topology/Algebra/Algebra.lean

tactic: convert @isClosed_closure A s _
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u
inst✝³ : TopologicalSpace A
inst✝² : Semiring A
inst✝¹ : Algebra R A
inst✝ : TopologicalSemiring A
s : Subalgebra R A
⊢ IsClosed ↑s.topologicalClosure
state_after: no goals
Theorem: Ordinal.nadd_def
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd]
state_before: a✝ b✝ c a b : Ordinal.{u}
⊢ a ♯ b = max (a.blsub fun a' x => a' ♯ b) (b.blsub fun b' x => a ♯ b')
state_after: no goals
Theorem: ConvexOn.secant_mono_aux2
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have hxy' : 0 < y - x := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
⊢ (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)

tactic: have hxz' : 0 < z - x := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
⊢ (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
hxz' : 0 < z - x
⊢ (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)

tactic: rw [div_le_div_iff hxy' hxz']
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
hxz' : 0 < z - x
⊢ (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
hxz' : 0 < z - x
⊢ (f y - f x) * (z - x) ≤ (f z - f x) * (y - x)

tactic: linarith only [hf.secant_mono_aux1 hx hz hxy hyz]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
hxz' : 0 < z - x
⊢ (f y - f x) * (z - x) ≤ (f z - f x) * (y - x)
state_after: no goals

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ 0 < y - x
state_after: no goals

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
⊢ 0 < z - x
state_after: no goals
Theorem: PiLp.norm_equiv_symm_const'
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: simp
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : Fintype ι
inst✝⁶ : Semiring 𝕜
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝³ : (i : ι) → Module 𝕜 (α i)
inst✝² : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝¹ : SeminormedAddCommGroup β
inst✝ : Nonempty ι
b : β
⊢ ↑(↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊) = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖
state_after: no goals