tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Equivalence.cancel_counitInv_right
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: simp only [cancel_mono]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
e : C ≌ D
X Y : D
f f' : X ⟶ Y
⊢ f ≫ (counitInv e).app Y = f' ≫ (counitInv e).app Y ↔ f = f'
Theorem: DirectSum.coeAlgHom_of
File: Mathlib/Algebra/DirectSum/Internal.lean

tactic: rfl
state_before: ι : Type u_1
σ : Type ?u.561128
S : Type u_2
R : Type u_3
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddMonoid ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : SetLike.GradedMonoid A
i : ι
x : { x // x ∈ A i }
⊢ ↑((fun i => LinearMap.toAddMonoidHom ((fun i => Submodule.subtype (A i)) i)) 0) GradedMonoid.GOne.one = 1

tactic: rfl
state_before: ι : Type u_1
σ : Type ?u.561128
S : Type u_2
R : Type u_3
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddMonoid ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : SetLike.GradedMonoid A
i : ι
x : { x // x ∈ A i }
i✝ j✝ : ι
x✝¹ : { x // x ∈ A i✝ }
x✝ : { x // x ∈ A j✝ }
⊢ ↑((fun i => LinearMap.toAddMonoidHom ((fun i => Submodule.subtype (A i)) i)) (i✝ + j✝))
      (GradedMonoid.GMul.mul x✝¹ x✝) =
    ↑((fun i => LinearMap.toAddMonoidHom ((fun i => Submodule.subtype (A i)) i)) i✝) x✝¹ *
      ↑((fun i => LinearMap.toAddMonoidHom ((fun i => Submodule.subtype (A i)) i)) j✝) x✝
Theorem: affineIndependent_iff_le_finrank_vectorSpan
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [affineIndependent_iff_finrank_vectorSpan_eq k p hc]
state_before: k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
n : ℕ
hc : Fintype.card ι = n + 1
⊢ AffineIndependent k p ↔ n ≤ finrank k { x // x ∈ vectorSpan k (Set.range p) }

tactic: constructor
state_before: k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
n : ℕ
hc : Fintype.card ι = n + 1
⊢ finrank k { x // x ∈ vectorSpan k (Set.range p) } = n ↔ n ≤ finrank k { x // x ∈ vectorSpan k (Set.range p) }

tactic: rintro rfl
state_before: case mp
k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
n : ℕ
hc : Fintype.card ι = n + 1
⊢ finrank k { x // x ∈ vectorSpan k (Set.range p) } = n → n ≤ finrank k { x // x ∈ vectorSpan k (Set.range p) }

tactic: rfl
state_before: case mp
k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
hc : Fintype.card ι = finrank k { x // x ∈ vectorSpan k (Set.range p) } + 1
⊢ finrank k { x // x ∈ vectorSpan k (Set.range p) } ≤ finrank k { x // x ∈ vectorSpan k (Set.range p) }

tactic: exact fun hle => le_antisymm (finrank_vectorSpan_range_le k p hc) hle
state_before: case mpr
k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
n : ℕ
hc : Fintype.card ι = n + 1
⊢ n ≤ finrank k { x // x ∈ vectorSpan k (Set.range p) } → finrank k { x // x ∈ vectorSpan k (Set.range p) } = n
Theorem: Relation.reflTransGen_eq_self
File: Mathlib/Logic/Relation.lean

tactic: induction' h with b c _ h₂ IH
state_before: α : Type u_1
β : Type ?u.25222
γ : Type ?u.25225
δ : Type ?u.25228
r : α → α → Prop
a✝ b✝ c d : α
refl : Reflexive r
trans : Transitive r
a b : α
h : ReflTransGen r a b
⊢ r a b

tactic: apply refl
state_before: case refl
α : Type u_1
β : Type ?u.25222
γ : Type ?u.25225
δ : Type ?u.25228
r : α → α → Prop
a✝ b✝ c d : α
refl : Reflexive r
trans : Transitive r
a b : α
⊢ r a a

tactic: exact trans IH h₂
state_before: case tail
α : Type u_1
β : Type ?u.25222
γ : Type ?u.25225
δ : Type ?u.25228
r : α → α → Prop
a✝¹ b✝¹ c✝ d : α
refl : Reflexive r
trans : Transitive r
a b✝ b c : α
a✝ : ReflTransGen r a b
h₂ : r b c
IH : r a b
⊢ r a c
Theorem: WfDvdMonoid.exists_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [s.prod_cons i]
state_before: α : Type u_1
inst✝¹ : CommMonoidWithZero α
inst✝ : WfDvdMonoid α
a✝ a i : α
ha0 : a ≠ 0
hi : Irreducible i
ih : a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Irreducible b) ∧ Multiset.prod f ~ᵤ a
x✝ : i * a ≠ 0
s : Multiset α
hs : (∀ (b : α), b ∈ s → Irreducible b) ∧ Multiset.prod s ~ᵤ a
⊢ Multiset.prod (i ::ₘ s) ~ᵤ i * a

tactic: exact hs.2.mul_left i
state_before: α : Type u_1
inst✝¹ : CommMonoidWithZero α
inst✝ : WfDvdMonoid α
a✝ a i : α
ha0 : a ≠ 0
hi : Irreducible i
ih : a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Irreducible b) ∧ Multiset.prod f ~ᵤ a
x✝ : i * a ≠ 0
s : Multiset α
hs : (∀ (b : α), b ∈ s → Irreducible b) ∧ Multiset.prod s ~ᵤ a
⊢ i * Multiset.prod s ~ᵤ i * a
Theorem: Cardinal.lift_succ
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rcases lt_lift_iff.1 h with ⟨b, e, h⟩
state_before: α β : Type u
a : Cardinal
h : lift (succ a) > succ (lift a)
⊢ False

tactic: rw [lt_succ_iff, ← lift_le, e] at h
state_before: case intro.intro
α β : Type u
a : Cardinal
h✝ : lift (succ a) > succ (lift a)
b : Cardinal
e : lift b = succ (lift a)
h : b < succ a
⊢ False

tactic: exact h.not_lt (lt_succ _)
state_before: case intro.intro
α β : Type u
a : Cardinal
h✝ : lift (succ a) > succ (lift a)
b : Cardinal
e : lift b = succ (lift a)
h : succ (lift a) ≤ lift a
⊢ False
Theorem: isOpen_setOf_eventually_nhdsWithin
File: Mathlib/Topology/Separation.lean

tactic: refine' isOpen_iff_mem_nhds.mpr fun a ha => _
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
p : α → Prop
⊢ IsOpen {x | ∀ᶠ (y : α) in 𝓝[{x}ᶜ] x, p y}

tactic: filter_upwards [eventually_nhds_nhdsWithin.mpr ha] with b hb
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
p : α → Prop
a : α
ha : a ∈ {x | ∀ᶠ (y : α) in 𝓝[{x}ᶜ] x, p y}
⊢ {x | ∀ᶠ (y : α) in 𝓝[{x}ᶜ] x, p y} ∈ 𝓝 a

tactic: rcases eq_or_ne a b with rfl | h
state_before: case h
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
p : α → Prop
a : α
ha : a ∈ {x | ∀ᶠ (y : α) in 𝓝[{x}ᶜ] x, p y}
b : α
hb : ∀ᶠ (x : α) in 𝓝[{a}ᶜ] b, p x
⊢ ∀ᶠ (y : α) in 𝓝[{b}ᶜ] b, p y

tactic: exact hb
state_before: case h.inl
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
p : α → Prop
a : α
ha : a ∈ {x | ∀ᶠ (y : α) in 𝓝[{x}ᶜ] x, p y}
hb : ∀ᶠ (x : α) in 𝓝[{a}ᶜ] a, p x
⊢ ∀ᶠ (y : α) in 𝓝[{a}ᶜ] a, p y

tactic: rw [h.symm.nhdsWithin_compl_singleton] at hb
state_before: case h.inr
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
p : α → Prop
a : α
ha : a ∈ {x | ∀ᶠ (y : α) in 𝓝[{x}ᶜ] x, p y}
b : α
hb : ∀ᶠ (x : α) in 𝓝[{a}ᶜ] b, p x
h : a ≠ b
⊢ ∀ᶠ (y : α) in 𝓝[{b}ᶜ] b, p y

tactic: exact hb.filter_mono nhdsWithin_le_nhds
state_before: case h.inr
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
p : α → Prop
a : α
ha : a ∈ {x | ∀ᶠ (y : α) in 𝓝[{x}ᶜ] x, p y}
b : α
hb : ∀ᶠ (x : α) in 𝓝 b, p x
h : a ≠ b
⊢ ∀ᶠ (y : α) in 𝓝[{b}ᶜ] b, p y
Theorem: SymAlg.mul_comm
File: Mathlib/Algebra/Symmetrized.lean

tactic: rw [mul_def, mul_def, add_comm]
state_before: α : Type u_1
inst✝⁴ : Mul α
inst✝³ : AddCommSemigroup α
inst✝² : One α
inst✝¹ : OfNat α 2
inst✝ : Invertible 2
a b : αˢʸᵐ
⊢ a * b = b * a
Theorem: one_div_le_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa using inv_le_of_neg ha hb
state_before: ι : Type ?u.156032
α : Type u_1
β : Type ?u.156038
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : a < 0
hb : b < 0
⊢ 1 / a ≤ b ↔ 1 / b ≤ a
Theorem: CategoryTheory.Limits.image.compIso_hom_comp_image_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: ext
state_before: C : Type u
inst✝³ : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝² : HasEqualizers C
inst✝¹ : HasImage f
inst✝ : IsIso g
⊢ (compIso f g).hom ≫ ι (f ≫ g) = ι f ≫ g

tactic: simp [image.compIso]
state_before: case w
C : Type u
inst✝³ : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝² : HasEqualizers C
inst✝¹ : HasImage f
inst✝ : IsIso g
⊢ factorThruImage f ≫ (compIso f g).hom ≫ ι (f ≫ g) = factorThruImage f ≫ ι f ≫ g
Theorem: Complex.log_ofReal_re
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp [log_re]
state_before: x : ℝ
⊢ (log ↑x).re = Real.log x
Theorem: Convex.linear_image
File: Mathlib/Analysis/Convex/Basic.lean

tactic: intro x hx y hy a b ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.32542
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
hs : Convex 𝕜 s
f : E →ₗ[𝕜] F
⊢ Convex 𝕜 (↑f '' s)

tactic: obtain ⟨x', hx', rfl⟩ := mem_image_iff_bex.1 hx
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.32542
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x✝ : E
hs : Convex 𝕜 s
f : E →ₗ[𝕜] F
x : F
hx : x ∈ ↑f '' s
y : F
hy : y ∈ ↑f '' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ ↑f '' s

tactic: obtain ⟨y', hy', rfl⟩ := mem_image_iff_bex.1 hy
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.32542
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
hs : Convex 𝕜 s
f : E →ₗ[𝕜] F
y : F
hy : y ∈ ↑f '' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
x' : E
hx' : x' ∈ s
hx : ↑f x' ∈ ↑f '' s
⊢ a • ↑f x' + b • y ∈ ↑f '' s

tactic: exact ⟨a • x' + b • y', hs hx' hy' ha hb hab, by rw [f.map_add, f.map_smul, f.map_smul]⟩
state_before: case intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.32542
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
hs : Convex 𝕜 s
f : E →ₗ[𝕜] F
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
x' : E
hx' : x' ∈ s
hx : ↑f x' ∈ ↑f '' s
y' : E
hy' : y' ∈ s
hy : ↑f y' ∈ ↑f '' s
⊢ a • ↑f x' + b • ↑f y' ∈ ↑f '' s

tactic: rw [f.map_add, f.map_smul, f.map_smul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.32542
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
hs : Convex 𝕜 s
f : E →ₗ[𝕜] F
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
x' : E
hx' : x' ∈ s
hx : ↑f x' ∈ ↑f '' s
y' : E
hy' : y' ∈ s
hy : ↑f y' ∈ ↑f '' s
⊢ ↑f (a • x' + b • y') = a • ↑f x' + b • ↑f y'
Theorem: Infinite.natEmbeddingAux_injective_aux
File: Mathlib/Data/Fintype/Card.lean

tactic: letI := Classical.decEq α
state_before: α✝ : Type ?u.79982
β : Type ?u.79985
γ : Type ?u.79988
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
hmn : m < n
⊢ m = n

tactic: exfalso
state_before: α✝ : Type ?u.79982
β : Type ?u.79985
γ : Type ?u.79988
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
hmn : m < n
this : DecidableEq α := Classical.decEq α
⊢ m = n

tactic: refine'
  (Classical.choose_spec
      (exists_not_mem_finset
        ((Multiset.range n).pmap (fun m (_hm : m < n) => natEmbeddingAux α m) fun _ =>
            Multiset.mem_range.1).toFinset))
    _
state_before: case h
α✝ : Type ?u.79982
β : Type ?u.79985
γ : Type ?u.79988
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
hmn : m < n
this : DecidableEq α := Classical.decEq α
⊢ False

tactic: refine' Multiset.mem_toFinset.2 (Multiset.mem_pmap.2 ⟨m, Multiset.mem_range.2 hmn, _⟩)
state_before: case h
α✝ : Type ?u.79982
β : Type ?u.79985
γ : Type ?u.79988
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
hmn : m < n
this : DecidableEq α := Classical.decEq α
⊢ Classical.choose
      (_ :
        ∃ x,
          ¬x ∈
              Multiset.toFinset
                (Multiset.pmap (fun m _hm => Infinite.natEmbeddingAux α m) (Multiset.range n)
                  (_ : ∀ (x : ℕ), x ∈ Multiset.range n → x < n))) ∈
    Multiset.toFinset
      (Multiset.pmap (fun m _hm => Infinite.natEmbeddingAux α m) (Multiset.range n)
        (_ : ∀ (x : ℕ), x ∈ Multiset.range n → x < n))

tactic: rw [h, natEmbeddingAux]
state_before: case h
α✝ : Type ?u.79982
β : Type ?u.79985
γ : Type ?u.79988
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
hmn : m < n
this : DecidableEq α := Classical.decEq α
⊢ Infinite.natEmbeddingAux α m =
    Classical.choose
      (_ :
        ∃ x,
          ¬x ∈
              Multiset.toFinset
                (Multiset.pmap (fun m _hm => Infinite.natEmbeddingAux α m) (Multiset.range n)
                  (_ : ∀ (x : ℕ), x ∈ Multiset.range n → x < n)))
Theorem: CategoryTheory.imageUnopOp_hom_comp_image_ι
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

tactic: simp only [← cancel_epi (image.ι g.unop).op, ← Category.assoc, image_ι_op_comp_imageUnopOp_hom,
  ← op_comp, image.fac, Quiver.Hom.op_unop]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (imageUnopOp g).hom ≫ image.ι g = (factorThruImage g.unop).op
Theorem: DifferentiableAt.dist
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: simp only [dist_eq_norm]
state_before: 𝕜 : Type ?u.376288
E : Type u_2
F : Type ?u.376294
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableAt ℝ f x
hg : DifferentiableAt ℝ g x
hne : f x ≠ g x
⊢ DifferentiableAt ℝ (fun y => Dist.dist (f y) (g y)) x

tactic: exact (hf.sub hg).norm 𝕜 (sub_ne_zero.2 hne)
state_before: 𝕜 : Type ?u.376288
E : Type u_2
F : Type ?u.376294
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableAt ℝ f x
hg : DifferentiableAt ℝ g x
hne : f x ≠ g x
⊢ DifferentiableAt ℝ (fun y => ‖f y - g y‖) x
Theorem: MeasureTheory.withDensity_congr_ae
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: refine Measure.ext fun s hs => ?_
state_before: α : Type u_1
β : Type ?u.1755336
γ : Type ?u.1755339
δ : Type ?u.1755342
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
h : f =ᶠ[ae μ] g
⊢ withDensity μ f = withDensity μ g

tactic: rw [withDensity_apply _ hs, withDensity_apply _ hs]
state_before: α : Type u_1
β : Type ?u.1755336
γ : Type ?u.1755339
δ : Type ?u.1755342
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
h : f =ᶠ[ae μ] g
s : Set α
hs : MeasurableSet s
⊢ ↑↑(withDensity μ f) s = ↑↑(withDensity μ g) s

tactic: exact lintegral_congr_ae (ae_restrict_of_ae h)
state_before: α : Type u_1
β : Type ?u.1755336
γ : Type ?u.1755339
δ : Type ?u.1755342
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
h : f =ᶠ[ae μ] g
s : Set α
hs : MeasurableSet s
⊢ (∫⁻ (a : α) in s, f a ∂μ) = ∫⁻ (a : α) in s, g a ∂μ
Theorem: LinearEquiv.det_symm_mul_det
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: simp [← LinearMap.det_comp]
state_before: R : Type ?u.1634353
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.1634944
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type ?u.1635486
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Module A M
f : M ≃ₗ[A] M
⊢ ↑LinearMap.det ↑(symm f) * ↑LinearMap.det ↑f = 1
Theorem: Continuous.div
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul (hg.inv₀ h₀)
state_before: α : Type u_1
β : Type ?u.33213
G₀ : Type u_2
inst✝⁵ : GroupWithZero G₀
inst✝⁴ : TopologicalSpace G₀
inst✝³ : HasContinuousInv₀ G₀
inst✝² : ContinuousMul G₀
f g : α → G₀
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : Set α
a : α
hf : Continuous f
hg : Continuous g
h₀ : ∀ (x : α), g x ≠ 0
⊢ Continuous (f / g)
Theorem: Complex.hasFPowerSeriesOnBall_of_differentiable_off_countable
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: have hw' : c + w ∈ ball c R := by
  simpa only [add_mem_ball_iff_norm, ← coe_nnnorm, mem_emetric_ball_zero_iff,
    NNReal.coe_lt_coe, ENNReal.coe_lt_coe] using hw
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ≥0
c : ℂ
f : ℂ → E
s : Set ℂ
hs : Set.Countable s
hc : ContinuousOn f (closedBall c ↑R)
hd : ∀ (z : ℂ), z ∈ ball c ↑R \ s → DifferentiableAt ℂ f z
hR : 0 < R
w : ℂ
hw : w ∈ EMetric.ball 0 ↑R
⊢ HasSum (fun n => ↑(cauchyPowerSeries f c (↑R) n) fun x => w) (f (c + w))

tactic: rw [← two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable
  hs hw' hc hd]
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ≥0
c : ℂ
f : ℂ → E
s : Set ℂ
hs : Set.Countable s
hc : ContinuousOn f (closedBall c ↑R)
hd : ∀ (z : ℂ), z ∈ ball c ↑R \ s → DifferentiableAt ℂ f z
hR : 0 < R
w : ℂ
hw : w ∈ EMetric.ball 0 ↑R
hw' : c + w ∈ ball c ↑R
⊢ HasSum (fun n => ↑(cauchyPowerSeries f c (↑R) n) fun x => w) (f (c + w))

tactic: exact (hasFPowerSeriesOn_cauchy_integral
  ((hc.mono sphere_subset_closedBall).circleIntegrable R.2) hR).hasSum hw
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ≥0
c : ℂ
f : ℂ → E
s : Set ℂ
hs : Set.Countable s
hc : ContinuousOn f (closedBall c ↑R)
hd : ∀ (z : ℂ), z ∈ ball c ↑R \ s → DifferentiableAt ℂ f z
hR : 0 < R
w : ℂ
hw : w ∈ EMetric.ball 0 ↑R
hw' : c + w ∈ ball c ↑R
⊢ HasSum (fun n => ↑(cauchyPowerSeries f c (↑R) n) fun x => w)
    ((2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, ↑R), (z - (c + w))⁻¹ • f z)

tactic: simpa only [add_mem_ball_iff_norm, ← coe_nnnorm, mem_emetric_ball_zero_iff,
  NNReal.coe_lt_coe, ENNReal.coe_lt_coe] using hw
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ≥0
c : ℂ
f : ℂ → E
s : Set ℂ
hs : Set.Countable s
hc : ContinuousOn f (closedBall c ↑R)
hd : ∀ (z : ℂ), z ∈ ball c ↑R \ s → DifferentiableAt ℂ f z
hR : 0 < R
w : ℂ
hw : w ∈ EMetric.ball 0 ↑R
⊢ c + w ∈ ball c ↑R
Theorem: Filter.compl_diagonal_mem_prod
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [mem_prod_iff, Filter.disjoint_iff, prod_subset_compl_diagonal_iff_disjoint]
state_before: α : Type u_1
β : Type ?u.57921
γ : Type ?u.57924
ι : Sort ?u.57927
ι' : Sort ?u.57930
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
l₁ l₂ : Filter α
⊢ diagonal αᶜ ∈ l₁ ×ˢ l₂ ↔ Disjoint l₁ l₂
Theorem: Matrix.zero_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.846509
m : Type u_2
n : Type u_1
o : Type ?u.846518
m' : o → Type ?u.846523
n' : o → Type ?u.846528
R : Type ?u.846531
S : Type ?u.846534
α : Type v
β : Type w
γ : Type ?u.846541
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
v : n → α
⊢ mulVec 0 v = 0

tactic: simp [mulVec]
state_before: case h
l : Type ?u.846509
m : Type u_2
n : Type u_1
o : Type ?u.846518
m' : o → Type ?u.846523
n' : o → Type ?u.846528
R : Type ?u.846531
S : Type ?u.846534
α : Type v
β : Type w
γ : Type ?u.846541
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
v : n → α
x✝ : m
⊢ mulVec 0 v x✝ = OfNat.ofNat 0 x✝
Theorem: Filter.tendsto_mul_const_atTop_iff_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [mul_comm _ r, tendsto_const_mul_atTop_iff_neg h]
state_before: ι : Type ?u.241523
ι' : Type ?u.241526
α : Type u_2
β : Type u_1
γ : Type ?u.241535
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : NeBot l
h : Tendsto f l atBot
⊢ Tendsto (fun x => f x * r) l atTop ↔ r < 0
Theorem: EuclideanGeometry.collinear_of_sin_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: revert h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : sin (∠ p₁ p₂ p₃) = 0
⊢ Collinear ℝ {p₁, p₂, p₃}

tactic: contrapose
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
⊢ sin (∠ p₁ p₂ p₃) = 0 → Collinear ℝ {p₁, p₂, p₃}

tactic: exact sin_ne_zero_of_not_collinear
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
⊢ ¬Collinear ℝ {p₁, p₂, p₃} → ¬sin (∠ p₁ p₂ p₃) = 0
Theorem: Equiv.Perm.toList_ne_singleton
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: intro H
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x y : α
⊢ toList p x ≠ [y]

tactic: simpa [card_support_ne_one] using congr_arg length H
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x y : α
H : toList p x = [y]
⊢ False
Theorem: Real.cos_sq_add_sin_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [add_comm, sin_sq_add_cos_sq]
state_before: x y : ℝ
⊢ cos x ^ 2 + sin x ^ 2 = 1
Theorem: SimpleGraph.Walk.support_concat
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*, concat_nil]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
h : Adj G v w
⊢ support (concat p h) = List.concat (support p) w
Theorem: Ideal.sum_pow_mem_span_pow
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: simpa only [Multiset.card_map, Multiset.map_map, comp_apply, Multiset.toFinset_map,
  Finset.coe_image, Finset.val_toFinset] using pow_multiset_sum_mem_span_pow (s.1.map f) n
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
ι : Type u_1
s : Finset ι
f : ι → α
n : ℕ
⊢ (∑ i in s, f i) ^ (Finset.card s * n + 1) ∈ span ((fun i => f i ^ (n + 1)) '' ↑s)
Theorem: Set.toFinset_ofFinset
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [@mem_toFinset _ _ (id _), H]
state_before: α : Type u_1
β : Type ?u.80831
γ : Type ?u.80834
s✝ t p : Set α
s : Finset α
H : ∀ (x : α), x ∈ s ↔ x ∈ p
x : α
⊢ x ∈ toFinset p ↔ x ∈ s
Theorem: Ordinal.div_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [div_def a b0]
state_before: α : Type ?u.230945
β : Type ?u.230948
γ : Type ?u.230951
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
b0 : b ≠ 0
h : a < b * succ c
⊢ a / b ≤ c

tactic: exact csInf_le' h
state_before: α : Type ?u.230945
β : Type ?u.230948
γ : Type ?u.230951
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
b0 : b ≠ 0
h : a < b * succ c
⊢ sInf {o | a < b * succ o} ≤ c
Theorem: TendstoLocallyUniformlyOn.mono
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: intro u hu x hx
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoLocallyUniformlyOn F f p s
h' : s' ⊆ s
⊢ TendstoLocallyUniformlyOn F f p s'

tactic: rcases h u hu x (h' hx) with ⟨t, ht, H⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoLocallyUniformlyOn F f p s
h' : s' ⊆ s
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
hx : x ∈ s'
⊢ ∃ t, t ∈ 𝓝[s'] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ t → (f y, F n y) ∈ u

tactic: exact ⟨t, nhdsWithin_mono x h' ht, H.mono fun n => id⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoLocallyUniformlyOn F f p s
h' : s' ⊆ s
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
hx : x ∈ s'
t : Set α
ht : t ∈ 𝓝[s] x
H : ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ t → (f y, F n y) ∈ u
⊢ ∃ t, t ∈ 𝓝[s'] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ t → (f y, F n y) ∈ u