tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.braiding_rightUnitor_aux₁
File: Mathlib/CategoryTheory/Monoidal/Braided.lean

tactic: rw [← rightUnitor_tensor, rightUnitor_naturality]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (α_ X (𝟙_ C) (𝟙_ C)).inv ≫ ((β_ (𝟙_ C) X).inv ⊗ 𝟙 (𝟙_ C)) ≫ (α_ (𝟙_ C) X (𝟙_ C)).hom ≫ (𝟙 (𝟙_ C) ⊗ (ρ_ X).hom) =
    (𝟙 X ⊗ (ρ_ (𝟙_ C)).hom) ≫ (β_ (𝟙_ C) X).inv

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (α_ X (𝟙_ C) (𝟙_ C)).inv ≫ (ρ_ (X ⊗ 𝟙_ C)).hom ≫ (β_ (𝟙_ C) X).inv = (𝟙 X ⊗ (ρ_ (𝟙_ C)).hom) ≫ (β_ (𝟙_ C) X).inv
Theorem: ChainComplex.of_d
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: dsimp [of]
state_before: ι : Type ?u.74447
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
α : Type u_1
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X (n + 1) ⟶ X n
sq : ∀ (n : α), d (n + 1) ≫ d n = 0
j : α
⊢ HomologicalComplex.d (of X d sq) (j + 1) j = d j

tactic: rw [if_pos rfl, Category.id_comp]
state_before: ι : Type ?u.74447
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
α : Type u_1
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X (n + 1) ⟶ X n
sq : ∀ (n : α), d (n + 1) ≫ d n = 0
j : α
⊢ (if j + 1 = j + 1 then 𝟙 (X (j + 1)) ≫ d j else 0) = d j
Theorem: Configuration.ProjectivePlane.one_lt_order
File: Mathlib/Combinatorics/Configuration.lean

tactic: obtain ⟨p₁, p₂, p₃, l₁, l₂, l₃, -, -, h₂₁, h₂₂, h₂₃, h₃₁, h₃₂, h₃₃⟩ := @exists_config P L _ _
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
⊢ 1 < order P L

tactic: cases nonempty_fintype { p : P // p ∈ l₂ }
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p₁ p₂ p₃ : P
l₁ l₂ l₃ : L
h₂₁ : ¬p₂ ∈ l₁
h₂₂ : p₂ ∈ l₂
h₂₃ : p₂ ∈ l₃
h₃₁ : ¬p₃ ∈ l₁
h₃₂ : p₃ ∈ l₂
h₃₃ : ¬p₃ ∈ l₃
⊢ 1 < order P L

tactic: rw [← add_lt_add_iff_right 1, ← pointCount_eq _ l₂, pointCount, Nat.card_eq_fintype_card,
  Fintype.two_lt_card_iff]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p₁ p₂ p₃ : P
l₁ l₂ l₃ : L
h₂₁ : ¬p₂ ∈ l₁
h₂₂ : p₂ ∈ l₂
h₂₃ : p₂ ∈ l₃
h₃₁ : ¬p₃ ∈ l₁
h₃₂ : p₃ ∈ l₂
h₃₃ : ¬p₃ ∈ l₃
val✝ : Fintype { p // p ∈ l₂ }
⊢ 1 < order P L

tactic: simp_rw [Ne, Subtype.ext_iff]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p₁ p₂ p₃ : P
l₁ l₂ l₃ : L
h₂₁ : ¬p₂ ∈ l₁
h₂₂ : p₂ ∈ l₂
h₂₃ : p₂ ∈ l₃
h₃₁ : ¬p₃ ∈ l₁
h₃₂ : p₃ ∈ l₂
h₃₃ : ¬p₃ ∈ l₃
val✝ : Fintype { p // p ∈ l₂ }
⊢ ∃ a b c, a ≠ b ∧ a ≠ c ∧ b ≠ c

tactic: have h := mkPoint_ax fun h => h₂₁ ((congr_arg _ h).mpr h₂₂)
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p₁ p₂ p₃ : P
l₁ l₂ l₃ : L
h₂₁ : ¬p₂ ∈ l₁
h₂₂ : p₂ ∈ l₂
h₂₃ : p₂ ∈ l₃
h₃₁ : ¬p₃ ∈ l₁
h₃₂ : p₃ ∈ l₂
h₃₃ : ¬p₃ ∈ l₃
val✝ : Fintype { p // p ∈ l₂ }
⊢ ∃ a b c, ¬↑a = ↑b ∧ ¬↑a = ↑c ∧ ¬↑b = ↑c

tactic: exact
  ⟨⟨mkPoint _, h.2⟩, ⟨p₂, h₂₂⟩, ⟨p₃, h₃₂⟩, ne_of_mem_of_not_mem h.1 h₂₁,
    ne_of_mem_of_not_mem h.1 h₃₁, ne_of_mem_of_not_mem h₂₃ h₃₃⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p₁ p₂ p₃ : P
l₁ l₂ l₃ : L
h₂₁ : ¬p₂ ∈ l₁
h₂₂ : p₂ ∈ l₂
h₂₃ : p₂ ∈ l₃
h₃₁ : ¬p₃ ∈ l₁
h₃₂ : p₃ ∈ l₂
h₃₃ : ¬p₃ ∈ l₃
val✝ : Fintype { p // p ∈ l₂ }
h : mkPoint (_ : l₁ = l₂ → False) ∈ l₁ ∧ mkPoint (_ : l₁ = l₂ → False) ∈ l₂
⊢ ∃ a b c, ¬↑a = ↑b ∧ ¬↑a = ↑c ∧ ¬↑b = ↑c
Theorem: CategoryTheory.coevaluation_comp_rightAdjointMate
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: apply_fun (tensorLeftHomEquiv _ Y (Yᘁ) _).symm
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasRightDual X
inst✝ : HasRightDual Y
f : X ⟶ Y
⊢ η_ Y Yᘁ ≫ (𝟙 Y ⊗ fᘁ) = η_ X Xᘁ ≫ (f ⊗ 𝟙 Xᘁ)

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasRightDual X
inst✝ : HasRightDual Y
f : X ⟶ Y
⊢ ↑(tensorLeftHomEquiv (𝟙_ C) Y Yᘁ Xᘁ).symm (η_ Y Yᘁ ≫ (𝟙 Y ⊗ fᘁ)) =
    ↑(tensorLeftHomEquiv (𝟙_ C) Y Yᘁ Xᘁ).symm (η_ X Xᘁ ≫ (f ⊗ 𝟙 Xᘁ))
Theorem: Function.support_smul_subset_left
File: Mathlib/Algebra/Support.lean

tactic: rw [Pi.smul_apply', hf, zero_smul]
state_before: α : Type u_3
β : Type u_2
A : Type ?u.91300
B : Type ?u.91303
M : Type u_1
N : Type ?u.91309
P : Type ?u.91312
R : Type ?u.91315
S : Type ?u.91318
G : Type ?u.91321
M₀ : Type ?u.91324
G₀ : Type ?u.91327
ι : Sort ?u.91330
inst✝² : Zero M
inst✝¹ : Zero β
inst✝ : SMulWithZero M β
f : α → M
g : α → β
x : α
hfg : x ∈ support (f • g)
hf : f x = 0
⊢ (f • g) x = 0
Theorem: Equiv.Perm.coe_subsingleton
File: Mathlib/Logic/Equiv/Defs.lean

tactic: rw [Perm.subsingleton_eq_refl e, coe_refl]
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
inst✝ : Subsingleton α
e : Perm α
⊢ ↑e = id
Theorem: Filter.HasBasis.disjoint_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [_root_.disjoint_iff, ← Ne.def, ← neBot_iff, inf_eq_inter,
hl.inf_basis_neBot_iff hl', not_exists, not_and, bot_eq_empty, ← nonempty_iff_ne_empty]
state_before: α : Type u_1
β : Type ?u.51338
γ : Type ?u.51341
ι : Sort u_2
ι' : Sort u_3
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
hl' : HasBasis l' p' s'
⊢ ¬Disjoint l l' ↔ ¬∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i')
Theorem: xor_not_not
File: Mathlib/Logic/Basic.lean

tactic: simp [Xor', or_comm, and_comm]
state_before: a b : Prop
⊢ Xor' (¬a) ¬b ↔ Xor' a b
Theorem: List.next_reverse_eq_prev
File: Mathlib/Data/List/Cycle.lean

tactic: convert (prev_reverse_eq_next l.reverse (nodup_reverse.mpr h) x ((mem_reverse _ _).mpr hx)).symm
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
h : Nodup l
x : α
hx : x ∈ l
⊢ next (reverse l) x (_ : x ∈ reverse l) = prev l x hx

tactic: exact (reverse_reverse l).symm
state_before: case h.e'_3.h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
h : Nodup l
x : α
hx : x ∈ l
⊢ l = reverse (reverse l)
Theorem: Function.Injective.swap_apply
File: Mathlib/Logic/Equiv/Basic.lean

tactic: by_cases hx:z = x
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
⊢ ↑(Equiv.swap (f x) (f y)) (f z) = f (↑(Equiv.swap x y) z)

tactic: by_cases hy:z = y
state_before: case neg
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
hx : ¬z = x
⊢ ↑(Equiv.swap (f x) (f y)) (f z) = f (↑(Equiv.swap x y) z)

tactic: rw [Equiv.swap_apply_of_ne_of_ne hx hy, Equiv.swap_apply_of_ne_of_ne (hf.ne hx) (hf.ne hy)]
state_before: case neg
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
hx : ¬z = x
hy : ¬z = y
⊢ ↑(Equiv.swap (f x) (f y)) (f z) = f (↑(Equiv.swap x y) z)

tactic: simp [hx]
state_before: case pos
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
hx : z = x
⊢ ↑(Equiv.swap (f x) (f y)) (f z) = f (↑(Equiv.swap x y) z)

tactic: simp [hy]
state_before: case pos
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
hx : ¬z = x
hy : z = y
⊢ ↑(Equiv.swap (f x) (f y)) (f z) = f (↑(Equiv.swap x y) z)
Theorem: Int.cast_neg
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: erw [cast_zero, neg_zero]
state_before: R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑(-↑0) = -↑↑0

tactic: erw [cast_ofNat, cast_negSucc]
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
⊢ ↑(-↑(n + 1)) = -↑↑(n + 1)

tactic: erw [cast_ofNat, cast_negSucc, neg_neg]
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
⊢ ↑(- -[n+1]) = -↑-[n+1]
Theorem: IsometryEquiv.ediam_univ
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.range_eq_univ, h.isometry.ediam_range]
state_before: ι : Type ?u.639491
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
⊢ EMetric.diam univ = EMetric.diam univ
Theorem: abs_abs_sub_abs_le_abs_sub
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [abs_sub_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ abs b - abs a ≤ abs (a - b)

tactic: apply abs_sub_abs_le_abs_sub
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ abs b - abs a ≤ abs (b - a)
Theorem: Module.comap_eval_surjective
File: Mathlib/LinearAlgebra/Dual.lean

tactic: apply Submodule.comap_surjective_of_injective
state_before: K : Type u₁
V : Type u₂
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ Function.Surjective (Submodule.comap (eval K V))

tactic: rw [← LinearMap.ker_eq_bot]
state_before: case hf
K : Type u₁
V : Type u₂
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ Function.Injective ↑(eval K V)

tactic: apply eval_ker K V
state_before: case hf
K : Type u₁
V : Type u₂
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ ker (eval K V) = ⊥
Theorem: SimpleGraph.Subgraph.deleteVerts_adj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [and_assoc]
state_before: ι : Sort ?u.266506
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set V
u v : V
⊢ Adj (deleteVerts G' s) u v ↔ u ∈ G'.verts ∧ ¬u ∈ s ∧ v ∈ G'.verts ∧ ¬v ∈ s ∧ Adj G' u v
Theorem: Disjoint.symmDiff_eq_sup
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff, h.sdiff_eq_left, h.sdiff_eq_right]
state_before: ι : Type ?u.26272
α : Type u_1
β : Type ?u.26278
π : ι → Type ?u.26283
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
h : Disjoint a b
⊢ a ∆ b = a ⊔ b
Theorem: ExceptT.bind_throw
File: src/lean/Init/Control/Lawful.lean

tactic: simp [throw, throwThe, MonadExceptOf.throw, bind, ExceptT.bind, ExceptT.bindCont, ExceptT.mk]
state_before: m : Type u_1 → Type u_2
α ε β : Type u_1
e : ε
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → ExceptT ε m β
⊢ throw e >>= f = throw e
Theorem: iteratedFDeriv_neg_apply
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp_rw [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1837321
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i✝ i : ℕ
f : E → F
⊢ iteratedFDeriv 𝕜 i (-f) x = -iteratedFDeriv 𝕜 i f x

tactic: exact iteratedFDerivWithin_neg_apply uniqueDiffOn_univ (Set.mem_univ _)
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1837321
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i✝ i : ℕ
f : E → F
⊢ iteratedFDerivWithin 𝕜 i (-f) univ x = -iteratedFDerivWithin 𝕜 i f univ x
Theorem: WittVector.ghostFun_nsmul
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: ghost_fun_tac m • (X 0 : MvPolynomial _ ℤ), ![x.coeff]
state_before: p : ℕ
R : Type u_1
S : Type ?u.786921
T : Type ?u.786924
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.786939
β : Type ?u.786942
x y : 𝕎 R
m : ℕ
⊢ WittVector.ghostFun (m • x) = m • WittVector.ghostFun x
Theorem: ModuleCat.Colimits.cocone_naturality_components
File: Mathlib/Algebra/Category/ModuleCat/Colimits.lean

tactic: rw [← cocone_naturality F f]
state_before: R : Type u
inst✝¹ : Ring R
J : Type w
inst✝ : Category J
F : J ⥤ ModuleCat R
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ ↑(coconeMorphism F j') (↑(F.map f) x) = ↑(coconeMorphism F j) x

tactic: rfl
state_before: R : Type u
inst✝¹ : Ring R
J : Type w
inst✝ : Category J
F : J ⥤ ModuleCat R
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ ↑(coconeMorphism F j') (↑(F.map f) x) = ↑(F.map f ≫ coconeMorphism F j') x
Theorem: CategoryTheory.Limits.PullbackCone.condition_one
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: have w := t.π.naturality WalkingCospan.Hom.inl
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
⊢ t.π.app WalkingCospan.one = fst t ≫ f

tactic: dsimp at w
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
w :
  ((Functor.const WalkingCospan).obj t.pt).map inl ≫ t.π.app WalkingCospan.one =
    t.π.app WalkingCospan.left ≫ (cospan f g).map inl
⊢ t.π.app WalkingCospan.one = fst t ≫ f

tactic: simpa using w
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
w : 𝟙 t.pt ≫ t.π.app WalkingCospan.one = fst t ≫ f
⊢ t.π.app WalkingCospan.one = fst t ≫ f
Theorem: Nat.add_mod_eq_add_mod_left
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [add_comm, add_mod_eq_add_mod_right _ H, add_comm]
state_before: m✝ n✝ k✝ m n k i : ℕ
H : m % n = k % n
⊢ (i + m) % n = (i + k) % n
Theorem: mul_nonpos_of_nonneg_of_nonpos
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [mul_zero] using mul_le_mul_of_nonneg_left hb ha
state_before: α : Type u_1
a b c d : α
inst✝² : MulZeroClass α
inst✝¹ : Preorder α
inst✝ : PosMulMono α
ha : 0 ≤ a
hb : b ≤ 0
⊢ a * b ≤ 0
Theorem: nonempty_sections_of_finite_cofiltered_system.init
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: let F' : J ⥤ TopCat := F ⋙ TopCat.discrete
state_before: J : Type u
inst✝¹ : SmallCategory J
inst✝ : IsCofilteredOrEmpty J
F : J ⥤ Type u
hf : ∀ (j : J), Finite (F.obj j)
hne : ∀ (j : J), _root_.Nonempty (F.obj j)
⊢ Set.Nonempty (Functor.sections F)

tactic: haveI : ∀ j, DiscreteTopology (F'.obj j) := fun _ => ⟨rfl⟩
state_before: J : Type u
inst✝¹ : SmallCategory J
inst✝ : IsCofilteredOrEmpty J
F : J ⥤ Type u
hf : ∀ (j : J), Finite (F.obj j)
hne : ∀ (j : J), _root_.Nonempty (F.obj j)
F' : J ⥤ TopCat := F ⋙ TopCat.discrete
⊢ Set.Nonempty (Functor.sections F)

tactic: haveI : ∀ j, Finite (F'.obj j) := hf
state_before: J : Type u
inst✝¹ : SmallCategory J
inst✝ : IsCofilteredOrEmpty J
F : J ⥤ Type u
hf : ∀ (j : J), Finite (F.obj j)
hne : ∀ (j : J), _root_.Nonempty (F.obj j)
F' : J ⥤ TopCat := F ⋙ TopCat.discrete
this : ∀ (j : J), DiscreteTopology ↑(F'.obj j)
⊢ Set.Nonempty (Functor.sections F)

tactic: haveI : ∀ j, Nonempty (F'.obj j) := hne
state_before: J : Type u
inst✝¹ : SmallCategory J
inst✝ : IsCofilteredOrEmpty J
F : J ⥤ Type u
hf : ∀ (j : J), Finite (F.obj j)
hne : ∀ (j : J), _root_.Nonempty (F.obj j)
F' : J ⥤ TopCat := F ⋙ TopCat.discrete
this✝ : ∀ (j : J), DiscreteTopology ↑(F'.obj j)
this : ∀ (j : J), Finite ↑(F'.obj j)
⊢ Set.Nonempty (Functor.sections F)

tactic: obtain ⟨⟨u, hu⟩⟩ := TopCat.nonempty_limitCone_of_compact_t2_cofiltered_system.{u} F'
state_before: J : Type u
inst✝¹ : SmallCategory J
inst✝ : IsCofilteredOrEmpty J
F : J ⥤ Type u
hf : ∀ (j : J), Finite (F.obj j)
hne : ∀ (j : J), _root_.Nonempty (F.obj j)
F' : J ⥤ TopCat := F ⋙ TopCat.discrete
this✝¹ : ∀ (j : J), DiscreteTopology ↑(F'.obj j)
this✝ : ∀ (j : J), Finite ↑(F'.obj j)
this : ∀ (j : J), _root_.Nonempty ↑(F'.obj j)
⊢ Set.Nonempty (Functor.sections F)

tactic: exact ⟨u, hu⟩
state_before: case intro.mk
J : Type u
inst✝¹ : SmallCategory J
inst✝ : IsCofilteredOrEmpty J
F : J ⥤ Type u
hf : ∀ (j : J), Finite (F.obj j)
hne : ∀ (j : J), _root_.Nonempty (F.obj j)
F' : J ⥤ TopCat := F ⋙ TopCat.discrete
this✝¹ : ∀ (j : J), DiscreteTopology ↑(F'.obj j)
this✝ : ∀ (j : J), Finite ↑(F'.obj j)
this : ∀ (j : J), _root_.Nonempty ↑(F'.obj j)
u : (j : J) → ↑(F'.obj j)
hu : u ∈ {u | ∀ {i j : J} (f : i ⟶ j), (forget TopCat).map (F'.map f) (u i) = u j}
⊢ Set.Nonempty (Functor.sections F)
Theorem: AddGroupCat.epi_iff_surjective
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: have i1 : Epi f ↔ Epi (groupAddGroupEquivalence.inverse.map f) := by
  refine' ⟨_, groupAddGroupEquivalence.inverse.epi_of_epi_map⟩
  intro e'
  apply groupAddGroupEquivalence.inverse.map_epi
state_before: A B : AddGroupCat
f : A ⟶ B
⊢ Epi f ↔ Function.Surjective ↑f

tactic: rwa [GroupCat.epi_iff_surjective] at i1
state_before: A B : AddGroupCat
f : A ⟶ B
i1 : Epi f ↔ Epi (groupAddGroupEquivalence.inverse.map f)
⊢ Epi f ↔ Function.Surjective ↑f

tactic: refine' ⟨_, groupAddGroupEquivalence.inverse.epi_of_epi_map⟩
state_before: A B : AddGroupCat
f : A ⟶ B
⊢ Epi f ↔ Epi (groupAddGroupEquivalence.inverse.map f)

tactic: intro e'
state_before: A B : AddGroupCat
f : A ⟶ B
⊢ Epi f → Epi (groupAddGroupEquivalence.inverse.map f)

tactic: apply groupAddGroupEquivalence.inverse.map_epi
state_before: A B : AddGroupCat
f : A ⟶ B
e' : Epi f
⊢ Epi (groupAddGroupEquivalence.inverse.map f)
Theorem: CategoryTheory.Limits.prod.comp_lift
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: apply prod.hom_ext
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ V W X Y : C
inst✝ : HasBinaryProduct X Y
f : V ⟶ W
g : W ⟶ X
h : W ⟶ Y
⊢ f ≫ lift g h = lift (f ≫ g) (f ≫ h)

tactic: simp
state_before: case h₁
C : Type u
inst✝¹ : Category C
X✝ Y✝ V W X Y : C
inst✝ : HasBinaryProduct X Y
f : V ⟶ W
g : W ⟶ X
h : W ⟶ Y
⊢ (f ≫ lift g h) ≫ fst = lift (f ≫ g) (f ≫ h) ≫ fst

case h₂
C : Type u
inst✝¹ : Category C
X✝ Y✝ V W X Y : C
inst✝ : HasBinaryProduct X Y
f : V ⟶ W
g : W ⟶ X
h : W ⟶ Y
⊢ (f ≫ lift g h) ≫ snd = lift (f ≫ g) (f ≫ h) ≫ snd

tactic: simp
state_before: case h₂
C : Type u
inst✝¹ : Category C
X✝ Y✝ V W X Y : C
inst✝ : HasBinaryProduct X Y
f : V ⟶ W
g : W ⟶ X
h : W ⟶ Y
⊢ (f ≫ lift g h) ≫ snd = lift (f ≫ g) (f ≫ h) ≫ snd
Theorem: NormedAddGroupHom.Equalizer.ι_comp_lift
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext
state_before: V : Type u_2
W : Type u_3
V₁ : Type u_1
V₂ : Type ?u.506724
V₃ : Type ?u.506727
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type ?u.506759
W₂ : Type ?u.506762
W₃ : Type ?u.506765
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V
h : NormedAddGroupHom.comp f φ = NormedAddGroupHom.comp g φ
⊢ NormedAddGroupHom.comp (ι f g) (lift φ h) = φ

tactic: rfl
state_before: case H
V : Type u_2
W : Type u_3
V₁ : Type u_1
V₂ : Type ?u.506724
V₃ : Type ?u.506727
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type ?u.506759
W₂ : Type ?u.506762
W₃ : Type ?u.506765
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V
h : NormedAddGroupHom.comp f φ = NormedAddGroupHom.comp g φ
x✝ : V₁
⊢ ↑(NormedAddGroupHom.comp (ι f g) (lift φ h)) x✝ = ↑φ x✝
Theorem: BoundedContinuousFunction.mem_Lp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: refine' Lp.mem_Lp_of_ae_bound ‖f‖ _
state_before: α : Type u_1
E : Type u_2
F : Type ?u.9151247
G : Type ?u.9151250
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : TopologicalSpace α
inst✝² : BorelSpace α
inst✝¹ : SecondCountableTopologyEither α E
inst✝ : IsFiniteMeasure μ
f : α →ᵇ E
⊢ ContinuousMap.toAEEqFun μ f.toContinuousMap ∈ Lp E p

tactic: filter_upwards [f.toContinuousMap.coeFn_toAEEqFun μ] with x _
state_before: α : Type u_1
E : Type u_2
F : Type ?u.9151247
G : Type ?u.9151250
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : TopologicalSpace α
inst✝² : BorelSpace α
inst✝¹ : SecondCountableTopologyEither α E
inst✝ : IsFiniteMeasure μ
f : α →ᵇ E
⊢ ∀ᵐ (x : α) ∂μ, ‖↑(ContinuousMap.toAEEqFun μ f.toContinuousMap) x‖ ≤ ‖f‖

tactic: convert f.norm_coe_le_norm x using 2
state_before: case h
α : Type u_1
E : Type u_2
F : Type ?u.9151247
G : Type ?u.9151250
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : TopologicalSpace α
inst✝² : BorelSpace α
inst✝¹ : SecondCountableTopologyEither α E
inst✝ : IsFiniteMeasure μ
f : α →ᵇ E
x : α
a✝ : ↑(ContinuousMap.toAEEqFun μ f.toContinuousMap) x = ↑f.toContinuousMap x
⊢ ‖↑(ContinuousMap.toAEEqFun μ f.toContinuousMap) x‖ ≤ ‖f‖
Theorem: Subgroup.coe_inclusion
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: cases a
state_before: G : Type u_1
G' : Type ?u.156101
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.156110
inst✝ : AddGroup A
H✝ K✝ H K : Subgroup G
h : H ≤ K
a : { x // x ∈ H }
⊢ ↑(↑(inclusion h) a) = ↑a

tactic: simp only [inclusion, coe_mk, MonoidHom.mk'_apply]
state_before: case mk
G : Type u_1
G' : Type ?u.156101
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.156110
inst✝ : AddGroup A
H✝ K✝ H K : Subgroup G
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ H
⊢ ↑(↑(inclusion h) { val := val✝, property := property✝ }) = ↑{ val := val✝, property := property✝ }
Theorem: Stream'.const_eq
File: Mathlib/Data/Stream/Init.lean

tactic: apply Stream'.ext
state_before: α : Type u
β : Type v
δ : Type w
a : α
⊢ const a = a :: const a

tactic: intro n
state_before: case a
α : Type u
β : Type v
δ : Type w
a : α
⊢ ∀ (n : ℕ), nth (const a) n = nth (a :: const a) n

tactic: cases n <;> rfl
state_before: case a
α : Type u
β : Type v
δ : Type w
a : α
n : ℕ
⊢ nth (const a) n = nth (a :: const a) n
Theorem: Multiset.countp_eq_zero
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.336299
γ : Type ?u.336302
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
_l : List α
⊢ countp p (Quot.mk Setoid.r _l) = 0 ↔ ∀ (a : α), a ∈ Quot.mk Setoid.r _l → ¬p a
Theorem: Dense.inter_of_open_left
File: Mathlib/Topology/Basic.lean

tactic: simp [hs.closure_eq, ht.closure_eq]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s t : Set α
hs : Dense s
ht : Dense t
hso : IsOpen s
x : α
⊢ x ∈ closure (s ∩ closure t)
Theorem: Matrix.transpose_zero
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.923940
m : Type u_1
n : Type u_2
o : Type ?u.923949
m' : o → Type ?u.923954
n' : o → Type ?u.923959
R : Type ?u.923962
S : Type ?u.923965
α : Type v
β : Type w
γ : Type ?u.923972
inst✝ : Zero α
⊢ 0ᵀ = 0

tactic: rfl
state_before: case a.h
l : Type ?u.923940
m : Type u_1
n : Type u_2
o : Type ?u.923949
m' : o → Type ?u.923954
n' : o → Type ?u.923959
R : Type ?u.923962
S : Type ?u.923965
α : Type v
β : Type w
γ : Type ?u.923972
inst✝ : Zero α
i✝ : n
x✝ : m
⊢ 0ᵀ i✝ x✝ = OfNat.ofNat 0 i✝ x✝