tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.Concrete.multiequalizer_ext
File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

tactic: apply Concrete.limit_ext
state_before: C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type w
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesLimit F (forget C)
I : MulticospanIndex C
inst✝¹ : HasMultiequalizer I
inst✝ : PreservesLimit (MulticospanIndex.multicospan I) (forget C)
x y : (forget C).obj (multiequalizer I)
h : ∀ (t : I.L), (forget C).map (Multiequalizer.ι I t) x = (forget C).map (Multiequalizer.ι I t) y
⊢ x = y

tactic: rintro (a | b)
state_before: case a
C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type w
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesLimit F (forget C)
I : MulticospanIndex C
inst✝¹ : HasMultiequalizer I
inst✝ : PreservesLimit (MulticospanIndex.multicospan I) (forget C)
x y : (forget C).obj (multiequalizer I)
h : ∀ (t : I.L), (forget C).map (Multiequalizer.ι I t) x = (forget C).map (Multiequalizer.ι I t) y
⊢ ∀ (j : WalkingMulticospan I.fstTo I.sndTo),
    (forget C).map (limit.π (MulticospanIndex.multicospan I) j) x =
      (forget C).map (limit.π (MulticospanIndex.multicospan I) j) y

tactic: apply h
state_before: case a.left
C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type w
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesLimit F (forget C)
I : MulticospanIndex C
inst✝¹ : HasMultiequalizer I
inst✝ : PreservesLimit (MulticospanIndex.multicospan I) (forget C)
x y : (forget C).obj (multiequalizer I)
h : ∀ (t : I.L), (forget C).map (Multiequalizer.ι I t) x = (forget C).map (Multiequalizer.ι I t) y
a : I.L
⊢ (forget C).map (limit.π (MulticospanIndex.multicospan I) (WalkingMulticospan.left a)) x =
    (forget C).map (limit.π (MulticospanIndex.multicospan I) (WalkingMulticospan.left a)) y

tactic: rw [← limit.w I.multicospan (WalkingMulticospan.Hom.fst b), comp_apply, comp_apply, h]
state_before: case a.right
C : Type u
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
J : Type w
inst✝³ : SmallCategory J
F : J ⥤ C
inst✝² : PreservesLimit F (forget C)
I : MulticospanIndex C
inst✝¹ : HasMultiequalizer I
inst✝ : PreservesLimit (MulticospanIndex.multicospan I) (forget C)
x y : (forget C).obj (multiequalizer I)
h : ∀ (t : I.L), (forget C).map (Multiequalizer.ι I t) x = (forget C).map (Multiequalizer.ι I t) y
b : I.R
⊢ (forget C).map (limit.π (MulticospanIndex.multicospan I) (WalkingMulticospan.right b)) x =
    (forget C).map (limit.π (MulticospanIndex.multicospan I) (WalkingMulticospan.right b)) y
Theorem: IsPreconnected.eq_of_sq_eq
File: Mathlib/Topology/Algebra/Field.lean

tactic: rcases hS.eq_or_eq_neg_of_sq_eq hf hg @hsq @hg_ne with (h | h)
state_before: K : Type ?u.37022
inst✝⁷ : DivisionRing K
inst✝⁶ : TopologicalSpace K
α : Type u_2
𝕜 : Type u_1
f g : α → 𝕜
S : Set α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : T1Space 𝕜
inst✝² : Field 𝕜
inst✝¹ : HasContinuousInv₀ 𝕜
inst✝ : ContinuousMul 𝕜
hS : IsPreconnected S
hf : ContinuousOn f S
hg : ContinuousOn g S
hsq : EqOn (f ^ 2) (g ^ 2) S
hg_ne : ∀ {x : α}, x ∈ S → g x ≠ 0
y : α
hy : y ∈ S
hy' : f y = g y
x : α
hx : x ∈ S
⊢ f x = g x

tactic: exact h hx
state_before: case inl
K : Type ?u.37022
inst✝⁷ : DivisionRing K
inst✝⁶ : TopologicalSpace K
α : Type u_2
𝕜 : Type u_1
f g : α → 𝕜
S : Set α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : T1Space 𝕜
inst✝² : Field 𝕜
inst✝¹ : HasContinuousInv₀ 𝕜
inst✝ : ContinuousMul 𝕜
hS : IsPreconnected S
hf : ContinuousOn f S
hg : ContinuousOn g S
hsq : EqOn (f ^ 2) (g ^ 2) S
hg_ne : ∀ {x : α}, x ∈ S → g x ≠ 0
y : α
hy : y ∈ S
hy' : f y = g y
x : α
hx : x ∈ S
h : EqOn f g S
⊢ f x = g x

tactic: rw [h _, Pi.neg_apply, neg_eq_iff_add_eq_zero, ← two_mul, mul_eq_zero,
  iff_false_iff.2 (hg_ne _)] at hy' ⊢ <;> assumption
state_before: case inr
K : Type ?u.37022
inst✝⁷ : DivisionRing K
inst✝⁶ : TopologicalSpace K
α : Type u_2
𝕜 : Type u_1
f g : α → 𝕜
S : Set α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : T1Space 𝕜
inst✝² : Field 𝕜
inst✝¹ : HasContinuousInv₀ 𝕜
inst✝ : ContinuousMul 𝕜
hS : IsPreconnected S
hf : ContinuousOn f S
hg : ContinuousOn g S
hsq : EqOn (f ^ 2) (g ^ 2) S
hg_ne : ∀ {x : α}, x ∈ S → g x ≠ 0
y : α
hy : y ∈ S
hy' : f y = g y
x : α
hx : x ∈ S
h : EqOn f (-g) S
⊢ f x = g x
Theorem: riesz_content_aux_image_nonempty
File: Mathlib/MeasureTheory/Integral/RieszMarkovKakutani.lean

tactic: rw [nonempty_image_iff]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
⊢ Set.Nonempty (↑Λ '' {f | ∀ (x : X), x ∈ K → 1 ≤ ↑f x})

tactic: use (1 : X →ᵇ ℝ≥0)
state_before: X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
⊢ Set.Nonempty {f | ∀ (x : X), x ∈ K → 1 ≤ ↑f x}

tactic: intro x _
state_before: X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
⊢ 1 ∈ {f | ∀ (x : X), x ∈ K → 1 ≤ ↑f x}

tactic: simp only [BoundedContinuousFunction.coe_one, Pi.one_apply]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
x : X
a✝ : x ∈ K
⊢ 1 ≤ ↑1 x

tactic: rfl
state_before: X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
x : X
a✝ : x ∈ K
⊢ 1 ≤ 1
Theorem: Num.bit_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases b <;> cases n <;> rfl
state_before: α : Type ?u.402487
b : Bool
n : Num
⊢ ↑(bit b n) = Nat.bit b ↑n
Theorem: FreeAlgebra.lift_unique
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: rw [← (lift R).symm_apply_eq, lift]
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
g : FreeAlgebra R X →ₐ[R] A
⊢ ↑g ∘ ι R = f ↔ g = ↑(lift R) f

tactic: rfl
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
g : FreeAlgebra R X →ₐ[R] A
⊢ ↑g ∘ ι R = f ↔
    ↑{ toFun := FreeAlgebra.liftAux R, invFun := fun F => ↑F ∘ ι R,
              left_inv := (_ : ∀ (f : X → A), (fun F => ↑F ∘ ι R) (FreeAlgebra.liftAux R f) = f),
              right_inv :=
                (_ : ∀ (F : FreeAlgebra R X →ₐ[R] A), FreeAlgebra.liftAux R ((fun F => ↑F ∘ ι R) F) = F) }.symm
        g =
      f
Theorem: summable_abs_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: simp only [h1, h2]
state_before: ι : Type u_2
κ : Type ?u.62135
α : Type u_1
inst✝³ : LinearOrderedAddCommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : CompleteSpace α
f : ι → α
s : Set ι := {x | 0 ≤ f x}
h1 : ∀ (x : ↑s), abs (f ↑x) = f ↑x
h2 : ∀ (x : ↑(sᶜ)), abs (f ↑x) = -f ↑x
⊢ ((Summable fun x => abs (f ↑x)) ∧ Summable fun x => abs (f ↑x)) ↔ (Summable fun x => f ↑x) ∧ Summable fun x => -f ↑x

tactic: simp only [summable_neg_iff, summable_subtype_and_compl]
state_before: ι : Type u_2
κ : Type ?u.62135
α : Type u_1
inst✝³ : LinearOrderedAddCommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : CompleteSpace α
f : ι → α
s : Set ι := {x | 0 ≤ f x}
h1 : ∀ (x : ↑s), abs (f ↑x) = f ↑x
h2 : ∀ (x : ↑(sᶜ)), abs (f ↑x) = -f ↑x
⊢ ((Summable fun x => f ↑x) ∧ Summable fun x => -f ↑x) ↔ Summable f
Theorem: Substring.Valid.contains
File: Std/Data/String/Lemmas.lean

tactic: simp [h.contains, h.toString]
state_before: c : Char
x✝ : Substring
h✝ : Valid x✝
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ Substring.contains x✝ c = true ↔ c ∈ (toString x✝).data
Theorem: QuadraticForm.polar_sub_right
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, polar_add_right, polar_neg_right]
state_before: S : Type ?u.171562
R : Type u_1
R₁ : Type ?u.171568
M : Type u_2
inst✝³ : Ring R
inst✝² : CommRing R₁
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y y' : M
⊢ polar (↑Q) x (y - y') = polar (↑Q) x y - polar (↑Q) x y'
Theorem: Localization.subalgebra.mem_range_mapToFractionRing_iff_ofField
File: Mathlib/RingTheory/Localization/AsSubring.lean

tactic: rw [mem_range_mapToFractionRing_iff]
state_before: A : Type u_2
K : Type u_3
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
⊢ x ∈ AlgHom.range (mapToFractionRing K S B hS) ↔ ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹

tactic: convert Iff.rfl
state_before: A : Type u_2
K : Type u_3
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
⊢ (∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }) ↔
    ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹

tactic: congr
state_before: case h.e'_2.h.e'_2.h.h.e'_2.h.h.e'_2.h.h.e'_3
A : Type u_2
K : Type u_3
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
x✝² x✝¹ : A
x✝ : x✝¹ ∈ S
⊢ ↑(algebraMap A K) x✝² * (↑(algebraMap A K) x✝¹)⁻¹ =
    IsLocalization.mk' K x✝² { val := x✝¹, property := (_ : x✝¹ ∈ A⁰) }

tactic: rw [Units.val_inv_eq_inv_val]
state_before: case h.e'_2.h.e'_2.h.h.e'_2.h.h.e'_2.h.h.e'_3.e_a
A : Type u_2
K : Type u_3
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
x✝² x✝¹ : A
x✝ : x✝¹ ∈ S
⊢ (↑(algebraMap A K) x✝¹)⁻¹ =
    ↑(↑(IsUnit.liftRight
              (MonoidHom.restrict (Submonoid.LocalizationMap.toMap (IsLocalization.toLocalizationMap A⁰ K)) A⁰)
              (_ :
                ∀ (y : { x // x ∈ A⁰ }),
                  IsUnit (↑(Submonoid.LocalizationMap.toMap (IsLocalization.toLocalizationMap A⁰ K)) ↑y)))
          { val := x✝¹, property := (_ : x✝¹ ∈ A⁰) })⁻¹

tactic: rfl
state_before: case h.e'_2.h.e'_2.h.h.e'_2.h.h.e'_2.h.h.e'_3.e_a
A : Type u_2
K : Type u_3
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
x✝² x✝¹ : A
x✝ : x✝¹ ∈ S
⊢ (↑(algebraMap A K) x✝¹)⁻¹ =
    (↑(↑(IsUnit.liftRight
              (MonoidHom.restrict (Submonoid.LocalizationMap.toMap (IsLocalization.toLocalizationMap A⁰ K)) A⁰)
              (_ :
                ∀ (y : { x // x ∈ A⁰ }),
                  IsUnit (↑(Submonoid.LocalizationMap.toMap (IsLocalization.toLocalizationMap A⁰ K)) ↑y)))
          { val := x✝¹, property := (_ : x✝¹ ∈ A⁰) }))⁻¹
Theorem: Real.volume_Ico
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp [volume_val]
state_before: ι : Type ?u.117608
inst✝ : Fintype ι
a b : ℝ
⊢ ↑↑volume (Ico a b) = ofReal (b - a)
Theorem: Finset.prod_dite
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simpa using (mem_filter.mp x.2).2
state_before: ι : Type ?u.394402
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
f : (x : α) → p x → β
g : (x : α) → ¬p x → β
x : { x // x ∈ filter p s }
⊢ p ↑x

tactic: simpa using (mem_filter.mp x.2).2
state_before: ι : Type ?u.394402
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
f : (x : α) → p x → β
g : (x : α) → ¬p x → β
x : { x // x ∈ filter (fun x => ¬p x) s }
⊢ ¬p ↑x

tactic: simp [prod_apply_dite _ _ fun x => x]
state_before: ι : Type ?u.394402
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
f : (x : α) → p x → β
g : (x : α) → ¬p x → β
⊢ (∏ x in s, if hx : p x then f x hx else g x hx) =
    (∏ x in attach (filter p s), f ↑x (_ : p ↑x)) * ∏ x in attach (filter (fun x => ¬p x) s), g ↑x (_ : ¬p ↑x)
Theorem: Filter.Tendsto.atTop_zsmul_neg_const
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simpa using hf.atTop_zsmul_const (neg_pos.2 hr)
state_before: α : Type u_2
R : Type u_1
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : r < 0
hf : Tendsto f l atTop
⊢ Tendsto (fun x => f x • r) l atBot
Theorem: isLeftRegular_of_non_zero_divisor
File: Mathlib/Algebra/Ring/Regular.lean

tactic: refine' fun x y (h' : k * x = k * y) => sub_eq_zero.mp (h _ _)
state_before: α : Type u_1
inst✝ : NonUnitalNonAssocRing α
k : α
h : ∀ (x : α), k * x = 0 → x = 0
⊢ IsLeftRegular k

tactic: rw [mul_sub, sub_eq_zero, h']
state_before: α : Type u_1
inst✝ : NonUnitalNonAssocRing α
k : α
h : ∀ (x : α), k * x = 0 → x = 0
x y : α
h' : k * x = k * y
⊢ k * (x - y) = 0
Theorem: Submonoid.mem_closure_pair
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: rw [← Set.singleton_union, Submonoid.closure_union, mem_sup]
state_before: M : Type ?u.264602
A✝ : Type ?u.264605
B : Type ?u.264608
A : Type u_1
inst✝ : CommMonoid A
a b c : A
⊢ c ∈ closure {a, b} ↔ ∃ m n, a ^ m * b ^ n = c

tactic: simp_rw [mem_closure_singleton, exists_exists_eq_and]
state_before: M : Type ?u.264602
A✝ : Type ?u.264605
B : Type ?u.264608
A : Type u_1
inst✝ : CommMonoid A
a b c : A
⊢ (∃ y, y ∈ closure {a} ∧ ∃ z, z ∈ closure {b} ∧ y * z = c) ↔ ∃ m n, a ^ m * b ^ n = c
Theorem: PEquiv.symm_symm
File: Mathlib/Data/PEquiv.lean

tactic: cases f
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
⊢ PEquiv.symm (PEquiv.symm f) = f

tactic: rfl
state_before: case mk
α : Type u
β : Type v
γ : Type w
δ : Type x
toFun✝ : α → Option β
invFun✝ : β → Option α
inv✝ : ∀ (a : α) (b : β), a ∈ invFun✝ b ↔ b ∈ toFun✝ a
⊢ PEquiv.symm (PEquiv.symm { toFun := toFun✝, invFun := invFun✝, inv := inv✝ }) =
    { toFun := toFun✝, invFun := invFun✝, inv := inv✝ }
Theorem: one_lt_sq_iff_one_lt_abs
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa only [one_pow, abs_one] using @sq_lt_sq _ _ 1 x
state_before: β : Type ?u.270901
A : Type ?u.270904
G : Type ?u.270907
M : Type ?u.270910
R : Type u_1
inst✝ : LinearOrderedRing R
x✝ y x : R
⊢ 1 < x ^ 2 ↔ 1 < abs x
Theorem: CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim_inv_π_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: dsimp [limitCurrySwapCompLimIsoLimitCurryCompLim]
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasLimits C
j : J
k : K
⊢ (limitCurrySwapCompLimIsoLimitCurryCompLim G).inv ≫
      limit.π (curry.obj (Prod.swap K J ⋙ G) ⋙ lim) k ≫ limit.π ((curry.obj (Prod.swap K J ⋙ G)).obj k) j =
    limit.π (curry.obj G ⋙ lim) j ≫ limit.π ((curry.obj G).obj j) k

tactic: simp only [Iso.refl_hom, Prod.braiding_counitIso_hom_app, Limits.HasLimit.isoOfEquivalence_inv_π,
  Iso.refl_inv, limitIsoLimitCurryCompLim_hom_π_π, eqToIso_refl, Category.assoc]
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasLimits C
j : J
k : K
⊢ ((limitIsoLimitCurryCompLim G).inv ≫
        (HasLimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).inv ≫
          (limitIsoLimitCurryCompLim (Prod.swap K J ⋙ G)).hom) ≫
      limit.π (curry.obj (Prod.swap K J ⋙ G) ⋙ lim) k ≫ limit.π ((curry.obj (Prod.swap K J ⋙ G)).obj k) j =
    limit.π (curry.obj G ⋙ lim) j ≫ limit.π ((curry.obj G).obj j) k

tactic: erw [NatTrans.id_app]
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasLimits C
j : J
k : K
⊢ (limitIsoLimitCurryCompLim G).inv ≫
      limit.π G ((Prod.braiding K J).functor.obj (k, j)) ≫ (𝟙 ((Prod.braiding K J).functor ⋙ G)).app (k, j) =
    limit.π (curry.obj G ⋙ lim) j ≫ limit.π ((curry.obj G).obj j) k

tactic: simp
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasLimits C
j : J
k : K
⊢ (limitIsoLimitCurryCompLim G).inv ≫
      limit.π G ((Prod.braiding K J).functor.obj (k, j)) ≫ 𝟙 (((Prod.braiding K J).functor ⋙ G).obj (k, j)) =
    limit.π (curry.obj G ⋙ lim) j ≫ limit.π ((curry.obj G).obj j) k
Theorem: List.head?_map
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> rfl
state_before: ι : Type ?u.44944
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
⊢ head? (map f l) = Option.map f (head? l)
Theorem: CategoryTheory.Adjunction.homEquiv_leftAdjointUniq_hom_app
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: apply (adj1.homEquiv _ _).symm.injective
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ ↑(homEquiv adj1 x (F'.obj x)) ((leftAdjointUniq adj1 adj2).hom.app x) = adj2.unit.app x

tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ ↑(homEquiv adj1 x (F'.obj x)).symm (↑(homEquiv adj1 x (F'.obj x)) ((leftAdjointUniq adj1 adj2).hom.app x)) =
    ↑(homEquiv adj1 x (F'.obj x)).symm (adj2.unit.app x)

tactic: apply coyoneda.map_injective
state_before: case a.a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ (↑(homEquiv adj1 x (F'.obj x)).symm (↑(homEquiv adj1 x (F'.obj x)) ((leftAdjointUniq adj1 adj2).hom.app x))).op =
    (↑(homEquiv adj1 x (F'.obj x)).symm (adj2.unit.app x)).op

tactic: ext
state_before: case a.a.a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ coyoneda.map
      (↑(homEquiv adj1 x (F'.obj x)).symm (↑(homEquiv adj1 x (F'.obj x)) ((leftAdjointUniq adj1 adj2).hom.app x))).op =
    coyoneda.map (↑(homEquiv adj1 x (F'.obj x)).symm (adj2.unit.app x)).op

tactic: funext
state_before: case a.a.a.w.h.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
x✝ : D
a✝ : (coyoneda.obj (F'.obj x).op).obj x✝
⊢ (coyoneda.map
          (↑(homEquiv adj1 x (F'.obj x)).symm
              (↑(homEquiv adj1 x (F'.obj x)) ((leftAdjointUniq adj1 adj2).hom.app x))).op).app
      x✝ a✝ =
    (coyoneda.map (↑(homEquiv adj1 x (F'.obj x)).symm (adj2.unit.app x)).op).app x✝ a✝

tactic: simp [leftAdjointUniq, leftAdjointsCoyonedaEquiv]
state_before: case a.a.a.w.h.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
x✝ : D
a✝ : (coyoneda.obj (F'.obj x).op).obj x✝
⊢ (coyoneda.map
          (↑(homEquiv adj1 x (F'.obj x)).symm
              (↑(homEquiv adj1 x (F'.obj x)) ((leftAdjointUniq adj1 adj2).hom.app x))).op).app
      x✝ a✝ =
    (coyoneda.map (↑(homEquiv adj1 x (F'.obj x)).symm (adj2.unit.app x)).op).app x✝ a✝
Theorem: List.length_take_of_le
File: Std/Data/List/Lemmas.lean

tactic: simp [Nat.min_eq_left h]
state_before: n : Nat
α✝ : Type u_1
l : List α✝
h : n ≤ length l
⊢ length (take n l) = n
Theorem: Submonoid.LocalizationMap.mk'_spec'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mul_comm, mk'_spec]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.767746
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
y : { x // x ∈ S }
⊢ ↑(toMap f) ↑y * mk' f x y = ↑(toMap f) x
Theorem: Polynomial.EisensteinCriterionAux.le_natDegree_of_map_eq_mul_X_pow
File: Mathlib/RingTheory/EisensteinCriterion.lean

tactic: rw [hq, degree_mul, hc0, zero_add, degree_pow, degree_X, nsmul_one, Nat.cast_withBot]
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
P : Ideal R
hP : Ideal.IsPrime P
q : R[X]
c : (R ⧸ P)[X]
hq : map (mk P) q = c * X ^ n
hc0 : degree c = 0
⊢ ↑n = degree (map (mk P) q)
Theorem: LocalHomeomorph.tendsto_symm
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: simpa only [ContinuousAt, e.left_inv hx] using e.continuousAt_symm (e.map_source hx)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30205
δ : Type ?u.30208
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
x : α
hx : x ∈ e.source
⊢ Tendsto (↑(LocalHomeomorph.symm e)) (𝓝 (↑e x)) (𝓝 x)
Theorem: Ordnode.dual_dual
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [dual, dual, dual_dual l, dual_dual r]
state_before: α : Type u_1
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
⊢ dual (dual (node s l x r)) = node s l x r
Theorem: Subtype.dense_iff
File: Mathlib/Topology/Constructions.lean

tactic: rw [inducing_subtype_val.dense_iff, SetCoe.forall]
state_before: α : Type u
β : Type v
γ : Type ?u.158230
δ : Type ?u.158233
ε : Type ?u.158236
ζ : Type ?u.158239
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
p : α → Prop
s : Set α
t : Set ↑s
⊢ Dense t ↔ s ⊆ closure (val '' t)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type ?u.158230
δ : Type ?u.158233
ε : Type ?u.158236
ζ : Type ?u.158239
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
p : α → Prop
s : Set α
t : Set ↑s
⊢ (∀ (x : α) (h : x ∈ s), ↑{ val := x, property := h } ∈ closure (val '' t)) ↔ s ⊆ closure (val '' t)
Theorem: Basis.orientation_isEmpty
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: rw [Basis.orientation]
state_before: R : Type u_1
inst✝⁸ : StrictOrderedCommRing R
M : Type u_3
N : Type ?u.117323
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R M
inst✝⁴ : Module R N
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : IsEmpty ι
b : Basis ι R M
⊢ Basis.orientation b = positiveOrientation

tactic: congr
state_before: R : Type u_1
inst✝⁸ : StrictOrderedCommRing R
M : Type u_3
N : Type ?u.117323
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R M
inst✝⁴ : Module R N
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : IsEmpty ι
b : Basis ι R M
⊢ rayOfNeZero R (det b) (_ : det b ≠ 0) = positiveOrientation

tactic: exact b.det_isEmpty
state_before: case e_v
R : Type u_1
inst✝⁸ : StrictOrderedCommRing R
M : Type u_3
N : Type ?u.117323
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R M
inst✝⁴ : Module R N
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : IsEmpty ι
b : Basis ι R M
⊢ det b = ↑AlternatingMap.constLinearEquivOfIsEmpty 1
Theorem: AddLECancellable.tsub_lt_self
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: refine' tsub_le_self.lt_of_ne fun h => _
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h₁ : 0 < a
h₂ : 0 < b
⊢ a - b < a

tactic: rw [← h, tsub_pos_iff_lt] at h₁
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h₁ : 0 < a
h₂ : 0 < b
h : a - b = a
⊢ False

tactic: exact h₂.not_le (ha.add_le_iff_nonpos_left.1 <| add_le_of_le_tsub_left_of_le h₁.le h.ge)
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h₁ : b < a
h₂ : 0 < b
h : a - b = a
⊢ False