tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.GrothendieckTopology.plus_hom_ext
File: Mathlib/CategoryTheory/Sites/Plus.lean

tactic: have : γ = J.plusLift (J.toPlus P ≫ γ) hQ := by
  apply plusLift_unique
  rfl
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : plusObj J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toPlus J P ≫ η = toPlus J P ≫ γ
⊢ η = γ

tactic: rw [this]
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : plusObj J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toPlus J P ≫ η = toPlus J P ≫ γ
this : γ = plusLift J (toPlus J P ≫ γ) hQ
⊢ η = γ

tactic: apply plusLift_unique
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : plusObj J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toPlus J P ≫ η = toPlus J P ≫ γ
this : γ = plusLift J (toPlus J P ≫ γ) hQ
⊢ η = plusLift J (toPlus J P ≫ γ) hQ

tactic: exact h
state_before: case hγ
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : plusObj J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toPlus J P ≫ η = toPlus J P ≫ γ
this : γ = plusLift J (toPlus J P ≫ γ) hQ
⊢ toPlus J P ≫ η = toPlus J P ≫ γ

tactic: apply plusLift_unique
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : plusObj J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toPlus J P ≫ η = toPlus J P ≫ γ
⊢ γ = plusLift J (toPlus J P ≫ γ) hQ

tactic: rfl
state_before: case hγ
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : plusObj J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toPlus J P ≫ η = toPlus J P ≫ γ
⊢ toPlus J P ≫ γ = toPlus J P ≫ γ
Theorem: Ideal.sup_mul_eq_of_coprime_left
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [eq_top_iff_one] at h
state_before: R : Type u
ι : Type ?u.266258
inst✝ : CommSemiring R
I J K L : Ideal R
h : I ⊔ J = ⊤
i : R
hi : i ∈ I ⊔ K
⊢ i ∈ I ⊔ J * K

tactic: rw [Submodule.mem_sup] at h hi⊢
state_before: R : Type u
ι : Type ?u.266258
inst✝ : CommSemiring R
I J K L : Ideal R
h : 1 ∈ I ⊔ J
i : R
hi : i ∈ I ⊔ K
⊢ i ∈ I ⊔ J * K

tactic: obtain ⟨i1, hi1, j, hj, h⟩ := h
state_before: R : Type u
ι : Type ?u.266258
inst✝ : CommSemiring R
I J K L : Ideal R
h : ∃ y, y ∈ I ∧ ∃ z, z ∈ J ∧ y + z = 1
i : R
hi : ∃ y, y ∈ I ∧ ∃ z, z ∈ K ∧ y + z = i
⊢ ∃ y, y ∈ I ∧ ∃ z, z ∈ J * K ∧ y + z = i

tactic: obtain ⟨i', hi', k, hk, hi⟩ := hi
state_before: case intro.intro.intro.intro
R : Type u
ι : Type ?u.266258
inst✝ : CommSemiring R
I J K L : Ideal R
i : R
hi : ∃ y, y ∈ I ∧ ∃ z, z ∈ K ∧ y + z = i
i1 : R
hi1 : i1 ∈ I
j : R
hj : j ∈ J
h : i1 + j = 1
⊢ ∃ y, y ∈ I ∧ ∃ z, z ∈ J * K ∧ y + z = i

tactic: refine' ⟨_, add_mem hi' (mul_mem_right k _ hi1), _, mul_mem_mul hj hk, _⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
R : Type u
ι : Type ?u.266258
inst✝ : CommSemiring R
I J K L : Ideal R
i i1 : R
hi1 : i1 ∈ I
j : R
hj : j ∈ J
h : i1 + j = 1
i' : R
hi' : i' ∈ I
k : R
hk : k ∈ K
hi : i' + k = i
⊢ ∃ y, y ∈ I ∧ ∃ z, z ∈ J * K ∧ y + z = i

tactic: rw [add_assoc, ← add_mul, h, one_mul, hi]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
R : Type u
ι : Type ?u.266258
inst✝ : CommSemiring R
I J K L : Ideal R
i i1 : R
hi1 : i1 ∈ I
j : R
hj : j ∈ J
h : i1 + j = 1
i' : R
hi' : i' ∈ I
k : R
hk : k ∈ K
hi : i' + k = i
⊢ i' + i1 * k + j * k = i
Theorem: continuous_multiset_prod
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rcases s with ⟨l⟩
state_before: ι : Type u_1
α : Type ?u.421560
X : Type u_2
M : Type u_3
N : Type ?u.421569
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
s : Multiset ι
⊢ (∀ (i : ι), i ∈ s → Continuous (f i)) → Continuous fun a => Multiset.prod (Multiset.map (fun i => f i a) s)

tactic: simpa using continuous_list_prod l
state_before: case mk
ι : Type u_1
α : Type ?u.421560
X : Type u_2
M : Type u_3
N : Type ?u.421569
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
s : Multiset ι
l : List ι
⊢ (∀ (i : ι), i ∈ Quot.mk Setoid.r l → Continuous (f i)) →
    Continuous fun a => Multiset.prod (Multiset.map (fun i => f i a) (Quot.mk Setoid.r l))
Theorem: List.prod_mul_prod_eq_prod_zipWith_of_length_eq
File: Mathlib/Data/List/Zip.lean

tactic: apply (prod_mul_prod_eq_prod_zipWith_mul_prod_drop L L').trans
state_before: α : Type u
β : Type ?u.290919
γ : Type ?u.290922
δ : Type ?u.290925
ε : Type ?u.290928
inst✝ : CommMonoid α
L L' : List α
h : length L = length L'
⊢ prod L * prod L' = prod (zipWith (fun x x_1 => x * x_1) L L')

tactic: rw [← h, drop_length, h, drop_length, prod_nil, mul_one, mul_one]
state_before: α : Type u
β : Type ?u.290919
γ : Type ?u.290922
δ : Type ?u.290925
ε : Type ?u.290928
inst✝ : CommMonoid α
L L' : List α
h : length L = length L'
⊢ prod (zipWith (fun x x_1 => x * x_1) L L') * prod (drop (length L') L) * prod (drop (length L) L') =
    prod (zipWith (fun x x_1 => x * x_1) L L')
Theorem: exists_compact_subset
File: Mathlib/Topology/SubsetProperties.lean

tactic: rcases LocallyCompactSpace.local_compact_nhds x U (hU.mem_nhds hx) with ⟨K, h1K, h2K, h3K⟩
state_before: α : Type u
β : Type v
ι : Type ?u.147163
π : ι → Type ?u.147168
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : LocallyCompactSpace α
x : α
U : Set α
hU : IsOpen U
hx : x ∈ U
⊢ ∃ K, IsCompact K ∧ x ∈ interior K ∧ K ⊆ U

tactic: exact ⟨K, h3K, mem_interior_iff_mem_nhds.2 h1K, h2K⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
ι : Type ?u.147163
π : ι → Type ?u.147168
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : LocallyCompactSpace α
x : α
U : Set α
hU : IsOpen U
hx : x ∈ U
K : Set α
h1K : K ∈ 𝓝 x
h2K : K ⊆ U
h3K : IsCompact K
⊢ ∃ K, IsCompact K ∧ x ∈ interior K ∧ K ⊆ U
Theorem: LinearMap.dualMap_surjective_iff
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← LinearMap.range_eq_top, range_dualMap_eq_dualAnnihilator_ker, ←
  Submodule.dualAnnihilator_bot, Subspace.dualAnnihilator_inj, LinearMap.ker_eq_bot]
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
⊢ Function.Surjective ↑(dualMap f) ↔ Function.Injective ↑f
Theorem: mul_ball_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [thickening_eq_biUnion_ball]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ s * ball 1 δ = thickening δ s

tactic: convert iUnion₂_mul (fun x (_ : x ∈ s) => {x}) (ball (1 : E) δ)
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ s * ball 1 δ = ⋃ (x : E) (_ : x ∈ s), ball x δ

tactic: exact s.biUnion_of_singleton.symm
state_before: case h.e'_2.h.e'_5
E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ s = ⋃ (i : E) (_ : i ∈ s), {i}

case h.e'_3.h.e'_3.h.f
E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y x✝¹ : E
x✝ : x✝¹ ∈ s
⊢ ball x✝¹ δ = {x✝¹} * ball 1 δ

tactic: ext x
state_before: case h.e'_3.h.e'_3.h.f
E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y x✝¹ : E
x✝ : x✝¹ ∈ s
⊢ ball x✝¹ δ = {x✝¹} * ball 1 δ

tactic: simp_rw [singleton_mul_ball, mul_one]
state_before: case h.e'_3.h.e'_3.h.f.h
E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝² y x✝¹ : E
x✝ : x✝¹ ∈ s
x : E
⊢ x ∈ ball x✝¹ δ ↔ x ∈ {x✝¹} * ball 1 δ
Theorem: CategoryTheory.IsPullback.of_is_product
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: dsimp
state_before: case mk.right
C : Type u₁
inst✝ : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
c : BinaryFan X Y
h : IsLimit c
t : IsTerminal Z
⊢ c.π.app { as := WalkingPair.right } =
    (Iso.refl c.pt).hom ≫
      (BinaryFan.mk (c.π.1 { as := WalkingPair.left }) (c.π.1 { as := WalkingPair.right })).π.app
        { as := WalkingPair.right }

tactic: simp
state_before: case mk.right
C : Type u₁
inst✝ : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
c : BinaryFan X Y
h : IsLimit c
t : IsTerminal Z
⊢ BinaryFan.snd c = 𝟙 c.pt ≫ BinaryFan.snd c
Theorem: Equiv.swap_mul_eq_iff
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: have swap_id : swap i j = 1 := mul_right_cancel (_root_.trans h (one_mul σ).symm)
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
h : swap i j * σ = σ
⊢ i = j

tactic: rw [← swap_apply_right i j, swap_id]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
h : swap i j * σ = σ
swap_id : swap i j = 1
⊢ i = j

tactic: rfl
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
h : swap i j * σ = σ
swap_id : swap i j = 1
⊢ ↑1 j = j

tactic: erw [h, swap_self, one_mul]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
h : i = j
⊢ swap i j * σ = σ
Theorem: Stream'.interleave_tail_tail
File: Mathlib/Data/Stream/Init.lean

tactic: rw [interleave_eq s₁ s₂]
state_before: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
⊢ tail s₁ ⋈ tail s₂ = tail (tail (s₁ ⋈ s₂))

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
⊢ tail s₁ ⋈ tail s₂ = tail (tail (head s₁ :: head s₂ :: (tail s₁ ⋈ tail s₂)))
Theorem: vsub_left_cancel
File: Mathlib/Algebra/AddTorsor.lean

tactic: rwa [← sub_eq_zero, vsub_sub_vsub_cancel_right, vsub_eq_zero_iff_eq] at h
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p1 p2 p : P
h : p1 -ᵥ p = p2 -ᵥ p
⊢ p1 = p2
Theorem: RingHom.map_adjugate
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: ext (i k)
state_before: m : Type u
n : Type v
α : Type w
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : CommRing α
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M : Matrix n n R
⊢ ↑(RingHom.mapMatrix f) (adjugate M) = adjugate (↑(RingHom.mapMatrix f) M)

tactic: have : Pi.single i (1 : S) = f ∘ Pi.single i 1 := by
  rw [← f.map_one]
  exact Pi.single_op (fun _ => f) (fun _ => f.map_zero) i (1 : R)
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : CommRing α
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M : Matrix n n R
i k : n
⊢ ↑(RingHom.mapMatrix f) (adjugate M) i k = adjugate (↑(RingHom.mapMatrix f) M) i k

tactic: rw [adjugate_apply, RingHom.mapMatrix_apply, map_apply, RingHom.mapMatrix_apply, this, ←
  map_updateRow, ← RingHom.mapMatrix_apply, ← RingHom.map_det, ← adjugate_apply]
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : CommRing α
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M : Matrix n n R
i k : n
this : Pi.single i 1 = ↑f ∘ Pi.single i 1
⊢ ↑(RingHom.mapMatrix f) (adjugate M) i k = adjugate (↑(RingHom.mapMatrix f) M) i k

tactic: rw [← f.map_one]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : CommRing α
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M : Matrix n n R
i k : n
⊢ Pi.single i 1 = ↑f ∘ Pi.single i 1

tactic: exact Pi.single_op (fun _ => f) (fun _ => f.map_zero) i (1 : R)
state_before: m : Type u
n : Type v
α : Type w
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : CommRing α
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M : Matrix n n R
i k : n
⊢ Pi.single i (↑f 1) = ↑f ∘ Pi.single i 1
Theorem: exists_unique_eq
File: Mathlib/Logic/Basic.lean

tactic: simp only [eq_comm, ExistsUnique, and_self, forall_eq', exists_eq']
state_before: ι : Sort ?u.16326
α : Sort u_1
κ : ι → Sort ?u.16328
p q : α → Prop
a' : α
⊢ ∃! a, a = a'
Theorem: IsSquare.div
File: Mathlib/Algebra/Parity.lean

tactic: rw [div_eq_mul_inv]
state_before: F : Type ?u.49647
α : Type u_1
β : Type ?u.49653
R : Type ?u.49656
inst✝ : DivisionCommMonoid α
a b : α
ha : IsSquare a
hb : IsSquare b
⊢ IsSquare (a / b)

tactic: exact ha.mul hb.inv
state_before: F : Type ?u.49647
α : Type u_1
β : Type ?u.49653
R : Type ?u.49656
inst✝ : DivisionCommMonoid α
a b : α
ha : IsSquare a
hb : IsSquare b
⊢ IsSquare (a * b⁻¹)
Theorem: CategoryTheory.Functor.biproductComparison'_comp_biproductComparison
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

tactic: classical
  ext
  simp [biproduct.ι_π, ← Functor.map_comp, eqToHom_map]
state_before: C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
J : Type w₁
F : C ⥤ D
f : J → C
inst✝² : HasBiproduct f
inst✝¹ : HasBiproduct (F.obj ∘ f)
inst✝ : PreservesZeroMorphisms F
⊢ biproductComparison' F f ≫ biproductComparison F f = 𝟙 (⨁ F.obj ∘ f)

tactic: ext
state_before: C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
J : Type w₁
F : C ⥤ D
f : J → C
inst✝² : HasBiproduct f
inst✝¹ : HasBiproduct (F.obj ∘ f)
inst✝ : PreservesZeroMorphisms F
⊢ biproductComparison' F f ≫ biproductComparison F f = 𝟙 (⨁ F.obj ∘ f)

tactic: simp [biproduct.ι_π, ← Functor.map_comp, eqToHom_map]
state_before: case w.w
C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
J : Type w₁
F : C ⥤ D
f : J → C
inst✝² : HasBiproduct f
inst✝¹ : HasBiproduct (F.obj ∘ f)
inst✝ : PreservesZeroMorphisms F
j✝¹ j✝ : J
⊢ (biproduct.ι (F.obj ∘ f) j✝¹ ≫ biproductComparison' F f ≫ biproductComparison F f) ≫ biproduct.π (F.obj ∘ f) j✝ =
    (biproduct.ι (F.obj ∘ f) j✝¹ ≫ 𝟙 (⨁ F.obj ∘ f)) ≫ biproduct.π (F.obj ∘ f) j✝
Theorem: IntermediateField.sInf_toSubfield
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp [Set.sUnion_image]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set (IntermediateField F E)
⊢ ↑(toSubfield (sInf S)) = ↑(sInf (toSubfield '' S))
Theorem: AdjoinRoot.lift_root
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [root, lift_mk, eval₂_X]
state_before: R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
f : R[X]
inst✝ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f = 0
⊢ ↑(lift i a h) (root f) = a
Theorem: Cubic.ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: contrapose! h0
state_before: R : Type u_1
S : Type ?u.553084
F : Type ?u.553087
K : Type ?u.553090
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
h0 : P.a ≠ 0 ∨ P.b ≠ 0 ∨ P.c ≠ 0 ∨ P.d ≠ 0
⊢ toPoly P ≠ 0

tactic: rw [(toPoly_eq_zero_iff P).mp h0]
state_before: R : Type u_1
S : Type ?u.553084
F : Type ?u.553087
K : Type ?u.553090
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
h0 : toPoly P = 0
⊢ P.a = 0 ∧ P.b = 0 ∧ P.c = 0 ∧ P.d = 0

tactic: exact ⟨rfl, rfl, rfl, rfl⟩
state_before: R : Type u_1
S : Type ?u.553084
F : Type ?u.553087
K : Type ?u.553090
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
h0 : toPoly P = 0
⊢ 0.a = 0 ∧ 0.b = 0 ∧ 0.c = 0 ∧ 0.d = 0
Theorem: CategoryTheory.Limits.IsInitial.epi_to
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: haveI := t.isSplitEpi_to f
state_before: C : Type u₁
inst✝ : Category C
X Y : C
t : IsInitial X
f : Y ⟶ X
⊢ Epi f

tactic: infer_instance
state_before: C : Type u₁
inst✝ : Category C
X Y : C
t : IsInitial X
f : Y ⟶ X
this : IsSplitEpi f
⊢ Epi f
Theorem: tendsto_pow_div_pow_atTop_atTop
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

tactic: rw [tendsto_congr' pow_div_pow_eventuallyEq_atTop]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
hpq : q < p
⊢ Tendsto (fun x => x ^ p / x ^ q) atTop atTop

tactic: apply tendsto_zpow_atTop_atTop
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
hpq : q < p
⊢ Tendsto (fun x => x ^ (↑p - ↑q)) atTop atTop

tactic: linarith
state_before: case hn
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
hpq : q < p
⊢ 0 < ↑p - ↑q
Theorem: Nat.mono_cast
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: rw [Nat.cast_succ]
state_before: α : Type u_1
β : Type ?u.8929
inst✝ : OrderedSemiring α
n : ℕ
⊢ ↑n ≤ ↑(n + 1)

tactic: exact le_add_of_nonneg_right zero_le_one
state_before: α : Type u_1
β : Type ?u.8929
inst✝ : OrderedSemiring α
n : ℕ
⊢ ↑n ≤ ↑n + 1
Theorem: Real.dist_0_eq_abs
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp [Real.dist_eq]
state_before: α : Type u
β : Type v
X : Type ?u.194421
ι : Type ?u.194424
inst✝ : PseudoMetricSpace α
x : ℝ
⊢ dist x 0 = abs x
Theorem: Set.inv_singleton
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_inv, image_singleton]
state_before: F : Type ?u.6817
α : Type u_1
β : Type ?u.6823
γ : Type ?u.6826
inst✝ : InvolutiveInv α
s t : Set α
a✝ a : α
⊢ {a}⁻¹ = {a⁻¹}
Theorem: Vector.toList_take
File: Mathlib/Data/Vector.lean

tactic: cases v
state_before: α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
v : Vector α m
⊢ toList (take n v) = List.take n (toList v)

tactic: rfl
state_before: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝ : List α
property✝ : List.length val✝ = m
⊢ toList (take n { val := val✝, property := property✝ }) = List.take n (toList { val := val✝, property := property✝ })
Theorem: StrictMono.strictMono_iterate_of_lt_map
File: Mathlib/Order/Iterate.lean

tactic: rw [iterate_succ_apply]
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : StrictMono f
hx : x < f x
n : ℕ
⊢ (f^[n]) x < (f^[n + 1]) x

tactic: exact hf.iterate n hx
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : StrictMono f
hx : x < f x
n : ℕ
⊢ (f^[n]) x < (f^[n]) (f x)
Theorem: Function.Surjective.denseRange
File: Mathlib/Topology/Basic.lean

tactic: simp [hf.range_eq]
state_before: α : Type ?u.174230
β : Type u_2
γ : Type ?u.174236
δ : Type ?u.174239
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
κ : Type u_1
ι : Type ?u.174254
f : κ → β
g : β → γ
hf : Surjective f
x : β
⊢ x ∈ closure (range f)
Theorem: Nat.pair_unpair'
File: Mathlib/Data/Nat/Pairing.lean

tactic: simpa [H] using pair_unpair n
state_before: n a b : ℕ
H : unpair n = (a, b)
⊢ pair a b = n
Theorem: Nat.find_eq_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: constructor
state_before: m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
⊢ Nat.find h = m ↔ p m ∧ ∀ (n : ℕ), n < m → ¬p n

tactic: rintro rfl
state_before: case mp
m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
⊢ Nat.find h = m → p m ∧ ∀ (n : ℕ), n < m → ¬p n

tactic: exact ⟨Nat.find_spec h, fun _ => Nat.find_min h⟩
state_before: case mp
n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
⊢ p (Nat.find h) ∧ ∀ (n : ℕ), n < Nat.find h → ¬p n

tactic: rintro ⟨hm, hlt⟩
state_before: case mpr
m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
⊢ (p m ∧ ∀ (n : ℕ), n < m → ¬p n) → Nat.find h = m

tactic: exact le_antisymm (Nat.find_min' h hm) (not_lt.1 <| imp_not_comm.1 (hlt _) <| Nat.find_spec h)
state_before: case mpr.intro
m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
hm : p m
hlt : ∀ (n : ℕ), n < m → ¬p n
⊢ Nat.find h = m
Theorem: Rack.self_invAct_act_eq
File: Mathlib/Algebra/Quandle.lean

tactic: have h := @self_act_invAct_eq _ _ (op x) (op y)
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃⁻¹ x) ◃ y = x ◃ y

tactic: simpa using h
state_before: R : Type u_1
inst✝ : Rack R
x y : R
h : (op x ◃ op x) ◃⁻¹ op y = op x ◃⁻¹ op y
⊢ (x ◃⁻¹ x) ◃ y = x ◃ y
Theorem: HasStrictDerivAt.smul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simpa using (hc.smul hf).hasStrictDerivAt
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasStrictDerivAt c c' x
hf : HasStrictDerivAt f f' x
⊢ HasStrictDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x
Theorem: Real.tan_div_sqrt_one_add_tan_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← tan_mul_cos hx.ne', ← inv_sqrt_one_add_tan_sq hx, div_eq_mul_inv]
state_before: x✝ y x : ℝ
hx : 0 < cos x
⊢ tan x / sqrt (1 + tan x ^ 2) = sin x
Theorem: Finset.card_biUnion_le
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp
state_before: ι : Type ?u.862077
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq β
s : Finset α
t : α → Finset β
this : DecidableEq α
⊢ card (Finset.biUnion ∅ t) ≤ ∑ a in ∅, card (t a)

tactic: rw [sum_insert has]
state_before: ι : Type ?u.862077
β : Type u
α : Type v
γ : Type w
s✝¹ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : DecidableEq β
s✝ : Finset α
t : α → Finset β
this : DecidableEq α
a : α
s : Finset α
has : ¬a ∈ s
ih : card (Finset.biUnion s t) ≤ ∑ a in s, card (t a)
⊢ card (t a) + card (Finset.biUnion s t) ≤ ∑ a in insert a s, card (t a)

tactic: exact add_le_add_left ih _
state_before: ι : Type ?u.862077
β : Type u
α : Type v
γ : Type w
s✝¹ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : DecidableEq β
s✝ : Finset α
t : α → Finset β
this : DecidableEq α
a : α
s : Finset α
has : ¬a ∈ s
ih : card (Finset.biUnion s t) ≤ ∑ a in s, card (t a)
⊢ card (t a) + card (Finset.biUnion s t) ≤ card (t a) + ∑ x in s, card (t x)
Theorem: Submodule.closedComplemented_bot
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: simp only [zero_apply, eq_zero_of_bot_submodule x]
state_before: R : Type u_1
inst✝⁶ : Ring R
M : Type u_2
inst✝⁵ : TopologicalSpace M
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M₂ : Type ?u.2064642
inst✝² : TopologicalSpace M₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
x : { x // x ∈ ⊥ }
⊢ ↑0 ↑x = x
Theorem: Irrational.sub_rat
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa only [sub_eq_add_neg, cast_neg] using h.add_rat (-q)
state_before: q : ℚ
x y : ℝ
h : Irrational x
⊢ Irrational (x - ↑q)
Theorem: SimpleGraph.Subgraph.edgeSet_iSup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [iSup]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
f : ι → Subgraph G
⊢ edgeSet (⨆ (i : ι), f i) = ⋃ (i : ι), edgeSet (f i)
Theorem: Set.image2_empty_right
File: Mathlib/Data/Set/NAry.lean

tactic: simp
state_before: α : Type u_2
α' : Type ?u.18102
β : Type u_3
β' : Type ?u.18108
γ : Type u_1
γ' : Type ?u.18114
δ : Type ?u.18117
δ' : Type ?u.18120
ε : Type ?u.18123
ε' : Type ?u.18126
ζ : Type ?u.18129
ζ' : Type ?u.18132
ν : Type ?u.18135
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ ∀ (x : γ), x ∈ image2 f s ∅ ↔ x ∈ ∅
Theorem: Nat.sub_self
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.sub_zero]
state_before: ⊢ 0 - 0 = 0

tactic: rw [succ_sub_succ, Nat.sub_self n]
state_before: n : Nat
⊢ succ n - succ n = 0