tasksource/leandojo huggingface dataset:
Theorem: List.Ico.filter_lt_of_le_bot
File: Mathlib/Data/List/Intervals.lean

tactic: simp only [decide_eq_true_eq, not_lt]
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ ¬decide (k < l) = true

tactic: apply le_trans hln
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ l ≤ k

tactic: exact (mem.1 hk).1
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ n ≤ k
Theorem: cauchySeq_finset_iff_vanishing_norm
File: Mathlib/Analysis/Normed/Group/InfiniteSum.lean

tactic: rw [cauchySeq_finset_iff_vanishing, nhds_basis_ball.forall_iff]
state_before: ι : Type u_2
α : Type ?u.23
E : Type u_1
F : Type ?u.29
inst✝¹ : SeminormedAddCommGroup E
inst✝ : SeminormedAddCommGroup F
f : ι → E
⊢ (CauchySeq fun s => ∑ i in s, f i) ↔ ∀ (ε : ℝ), ε > 0 → ∃ s, ∀ (t : Finset ι), Disjoint t s → ‖∑ i in t, f i‖ < ε

tactic: simp only [ball_zero_eq, Set.mem_setOf_eq]
state_before: ι : Type u_2
α : Type ?u.23
E : Type u_1
F : Type ?u.29
inst✝¹ : SeminormedAddCommGroup E
inst✝ : SeminormedAddCommGroup F
f : ι → E
⊢ (∀ (i : ℝ), 0 < i → ∃ s, ∀ (t : Finset ι), Disjoint t s → ∑ b in t, f b ∈ ball 0 i) ↔
    ∀ (ε : ℝ), ε > 0 → ∃ s, ∀ (t : Finset ι), Disjoint t s → ‖∑ i in t, f i‖ < ε

tactic: rintro s t hst ⟨s', hs'⟩
state_before: ι : Type u_2
α : Type ?u.23
E : Type u_1
F : Type ?u.29
inst✝¹ : SeminormedAddCommGroup E
inst✝ : SeminormedAddCommGroup F
f : ι → E
⊢ ∀ ⦃s t : Set E⦄,
    s ⊆ t →
      (∃ s_1, ∀ (t : Finset ι), Disjoint t s_1 → ∑ b in t, f b ∈ s) →
        ∃ s, ∀ (t_1 : Finset ι), Disjoint t_1 s → ∑ b in t_1, f b ∈ t

tactic: exact ⟨s', fun t' ht' => hst <| hs' _ ht'⟩
state_before: case intro
ι : Type u_2
α : Type ?u.23
E : Type u_1
F : Type ?u.29
inst✝¹ : SeminormedAddCommGroup E
inst✝ : SeminormedAddCommGroup F
f : ι → E
s t : Set E
hst : s ⊆ t
s' : Finset ι
hs' : ∀ (t : Finset ι), Disjoint t s' → ∑ b in t, f b ∈ s
⊢ ∃ s, ∀ (t_1 : Finset ι), Disjoint t_1 s → ∑ b in t_1, f b ∈ t
Theorem: homology.lift_ι
File: Mathlib/CategoryTheory/Abelian/Homology.lean

tactic: dsimp [ι, lift]
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
W : A
e : W ⟶ cokernel f
he : e ≫ cokernel.desc f g w = 0
⊢ lift f g w e he ≫ ι f g w = e

tactic: simp
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
W : A
e : W ⟶ cokernel f
he : e ≫ cokernel.desc f g w = 0
⊢ (kernel.lift (cokernel.desc f g w) e he ≫ (homologyIsoKernelDesc f g w).inv) ≫
      (homologyIsoKernelDesc f g w).hom ≫ kernel.ι (cokernel.desc f g w) =
    e
Theorem: FirstOrder.Language.Structure.cg_iff_countable
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [cg_def, Substructure.cg_iff_countable, topEquiv.toEquiv.countable_iff]
state_before: L : Language
M : Type u_3
inst✝¹ : Structure L M
inst✝ : Countable ((l : ℕ) × Functions L l)
⊢ CG L M ↔ Countable M
Theorem: Polynomial.coe_normUnit
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp [normUnit]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizationMonoid R
p : R[X]
⊢ ↑(normUnit p) = ↑C ↑(normUnit (leadingCoeff p))
Theorem: WithBot.image_coe_Icc
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← preimage_coe_Icc, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left
    (Subset.trans Icc_subset_Ici_self <| Ici_subset_Ioi.2 <| bot_lt_coe a)]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some '' Icc a b = Icc ↑a ↑b
Theorem: Finset.mem_image₂_iff
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [← mem_coe, coe_image₂, mem_image2_iff hf, mem_coe, mem_coe]
state_before: α : Type u_1
α' : Type ?u.11378
β : Type u_2
β' : Type ?u.11384
γ : Type u_3
γ' : Type ?u.11390
δ : Type ?u.11393
δ' : Type ?u.11396
ε : Type ?u.11399
ε' : Type ?u.11402
ζ : Type ?u.11405
ζ' : Type ?u.11408
ν : Type ?u.11411
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
hf : Injective2 f
⊢ f a b ∈ image₂ f s t ↔ a ∈ s ∧ b ∈ t
Theorem: Complex.arg_coe_angle_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simp_rw [← Real.Angle.toReal_inj, arg_coe_angle_toReal_eq_arg]
state_before: x y : ℂ
⊢ ↑(arg x) = ↑(arg y) ↔ arg x = arg y
Theorem: Ordnode.any_singleton
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rintro (⟨⟨⟩⟩ | h | ⟨⟨⟩⟩)
state_before: α : Type u_1
P : α → Prop
x : α
⊢ Any P {x} → P x

tactic: exact h
state_before: case inr.inl
α : Type u_1
P : α → Prop
x : α
h : P x
⊢ P x
Theorem: Finset.exists_cycleOn
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: refine'
  ⟨s.toList.formPerm, _, fun x hx => by
    simpa using List.mem_of_formPerm_apply_ne _ _ (Perm.mem_support.1 hx)⟩
state_before: ι : Type ?u.3070884
α : Type u_1
β : Type ?u.3070890
inst✝² inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Finset α
⊢ ∃ f, IsCycleOn f ↑s ∧ support f ⊆ s

tactic: convert s.nodup_toList.isCycleOn_formPerm
state_before: ι : Type ?u.3070884
α : Type u_1
β : Type ?u.3070890
inst✝² inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Finset α
⊢ IsCycleOn (List.formPerm (toList s)) ↑s

tactic: simp
state_before: case h.e'_3
ι : Type ?u.3070884
α : Type u_1
β : Type ?u.3070890
inst✝² inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Finset α
⊢ ↑s = {a | a ∈ toList s}

tactic: simpa using List.mem_of_formPerm_apply_ne _ _ (Perm.mem_support.1 hx)
state_before: ι : Type ?u.3070884
α : Type u_1
β : Type ?u.3070890
inst✝² inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Finset α
x : α
hx : x ∈ support (List.formPerm (toList s))
⊢ x ∈ s
Theorem: Equiv.Perm.card_support_le_one
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [le_iff_lt_or_eq, Nat.lt_succ_iff, le_zero_iff, card_support_eq_zero, or_iff_not_imp_right,
  imp_iff_right f.card_support_ne_one]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
⊢ card (support f) ≤ 1 ↔ f = 1
Theorem: Real.arcsin_neg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: cases' le_total x (-1) with hx₁ hx₁
state_before: x : ℝ
⊢ arcsin (-x) = -arcsin x

tactic: cases' le_total 1 x with hx₂ hx₂
state_before: case inr
x : ℝ
hx₁ : -1 ≤ x
⊢ arcsin (-x) = -arcsin x

tactic: refine' arcsin_eq_of_sin_eq _ _
state_before: case inr.inr
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ arcsin (-x) = -arcsin x

tactic: rw [arcsin_of_le_neg_one hx₁, neg_neg, arcsin_of_one_le (le_neg.2 hx₁)]
state_before: case inl
x : ℝ
hx₁ : x ≤ -1
⊢ arcsin (-x) = -arcsin x

tactic: rw [arcsin_of_one_le hx₂, arcsin_of_le_neg_one (neg_le_neg hx₂)]
state_before: case inr.inl
x : ℝ
hx₁ : -1 ≤ x
hx₂ : 1 ≤ x
⊢ arcsin (-x) = -arcsin x

tactic: rw [sin_neg, sin_arcsin hx₁ hx₂]
state_before: case inr.inr.refine'_1
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ sin (-arcsin x) = -x

tactic: exact ⟨neg_le_neg (arcsin_le_pi_div_two _), neg_le.2 (neg_pi_div_two_le_arcsin _)⟩
state_before: case inr.inr.refine'_2
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ -arcsin x ∈ Icc (-(π / 2)) (π / 2)
Theorem: Polynomial.frange_ofSubring
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: intro i hi
state_before: R : Type u
S : Type ?u.109024
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : { x // x ∈ T }[X]
⊢ ↑(frange (ofSubring T p)) ⊆ ↑T

tactic: simp only [frange, Set.mem_image, mem_support_iff, Ne.def, Finset.mem_coe, Finset.coe_image] at hi
state_before: R : Type u
S : Type ?u.109024
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : { x // x ∈ T }[X]
i : R
hi : i ∈ ↑(frange (ofSubring T p))
⊢ i ∈ ↑T

tactic: rcases hi with ⟨n, _, h'n⟩
state_before: R : Type u
S : Type ?u.109024
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : { x // x ∈ T }[X]
i : R
hi : ∃ x, ¬coeff (ofSubring T p) x = 0 ∧ coeff (ofSubring T p) x = i
⊢ i ∈ ↑T

tactic: rw [← h'n, coeff_ofSubring]
state_before: case intro.intro
R : Type u
S : Type ?u.109024
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : { x // x ∈ T }[X]
i : R
n : ℕ
left✝ : ¬coeff (ofSubring T p) n = 0
h'n : coeff (ofSubring T p) n = i
⊢ i ∈ ↑T

tactic: exact Subtype.mem (coeff p n : T)
state_before: case intro.intro
R : Type u
S : Type ?u.109024
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : { x // x ∈ T }[X]
i : R
n : ℕ
left✝ : ¬coeff (ofSubring T p) n = 0
h'n : coeff (ofSubring T p) n = i
⊢ ↑(coeff p n) ∈ ↑T
Theorem: LinearMap.bot_lt_ker_of_det_eq_zero
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: have : FiniteDimensional 𝕜 M := by simp [f.finiteDimensional_of_det_ne_one, hf]
state_before: R : Type ?u.1194769
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.1195360
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type ?u.1195902
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A : Type ?u.1196380
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.1196878
inst✝² : Fintype κ
𝕜 : Type u_1
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M →ₗ[𝕜] M
hf : ↑LinearMap.det f = 0
⊢ ⊥ < ker f

tactic: contrapose hf
state_before: R : Type ?u.1194769
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.1195360
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type ?u.1195902
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A : Type ?u.1196380
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.1196878
inst✝² : Fintype κ
𝕜 : Type u_1
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M →ₗ[𝕜] M
hf : ↑LinearMap.det f = 0
this : FiniteDimensional 𝕜 M
⊢ ⊥ < ker f

tactic: simp only [bot_lt_iff_ne_bot, Classical.not_not, ← isUnit_iff_ker_eq_bot] at hf
state_before: R : Type ?u.1194769
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.1195360
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type ?u.1195902
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A : Type ?u.1196380
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.1196878
inst✝² : Fintype κ
𝕜 : Type u_1
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M →ₗ[𝕜] M
this : FiniteDimensional 𝕜 M
hf : ¬⊥ < ker f
⊢ ¬↑LinearMap.det f = 0

tactic: exact isUnit_iff_ne_zero.1 (f.isUnit_det hf)
state_before: R : Type ?u.1194769
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.1195360
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type ?u.1195902
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A : Type ?u.1196380
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.1196878
inst✝² : Fintype κ
𝕜 : Type u_1
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M →ₗ[𝕜] M
this : FiniteDimensional 𝕜 M
hf : IsUnit f
⊢ ¬↑LinearMap.det f = 0

tactic: simp [f.finiteDimensional_of_det_ne_one, hf]
state_before: R : Type ?u.1194769
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.1195360
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type ?u.1195902
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A : Type ?u.1196380
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.1196878
inst✝² : Fintype κ
𝕜 : Type u_1
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M →ₗ[𝕜] M
hf : ↑LinearMap.det f = 0
⊢ FiniteDimensional 𝕜 M
Theorem: NNReal.rpow_left_injective
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simpa only [rpow_inv_rpow_self hx] using congr_arg (fun y => y ^ (1 / x)) hyz
state_before: x : ℝ
hx : x ≠ 0
y z : ℝ≥0
hyz : (fun y => y ^ x) y = (fun y => y ^ x) z
⊢ y = z
Theorem: CommGroupCat.epi_iff_surjective
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: rw [epi_iff_range_eq_top, MonoidHom.range_top_iff_surjective]
state_before: A B : CommGroupCat
f : A ⟶ B
⊢ Epi f ↔ Function.Surjective ↑f
Theorem: Submodule.finrank_sup_add_finrank_inf_eq
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: have key : Module.rank K ↑(s ⊔ t) + Module.rank K ↑(s ⊓ t) = Module.rank K s + Module.rank K t :=
  rank_sup_add_rank_inf_eq s t
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }

tactic: repeat' rw [← finrank_eq_rank] at key
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  Module.rank K { x // x ∈ s ⊔ t } + Module.rank K { x // x ∈ s ⊓ t } =
    Module.rank K { x // x ∈ s } + Module.rank K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }

tactic: norm_cast at key
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  ↑(finrank K { x // x ∈ s ⊔ t }) + ↑(finrank K { x // x ∈ s ⊓ t }) =
    ↑(finrank K { x // x ∈ s }) + ↑(finrank K { x // x ∈ t })
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }

tactic: rw [← finrank_eq_rank] at key
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  ↑(finrank K { x // x ∈ s ⊔ t }) + ↑(finrank K { x // x ∈ s ⊓ t }) =
    ↑(finrank K { x // x ∈ s }) + ↑(finrank K { x // x ∈ t })
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
Theorem: Nat.div_le_div_right
File: Mathlib/Data/Nat/Basic.lean

tactic: simp [k0]
state_before: m✝ n✝ k✝ n m : ℕ
h : n ≤ m
k : ℕ
k0 : k = 0
⊢ n / k ≤ m / k
Theorem: IsLocalizedModule.mk'_eq_iff
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [← smul_inj f s, Submonoid.smul_def, ← mk'_smul, ← Submonoid.smul_def, mk'_cancel]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.900764
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
s : { x // x ∈ S }
m' : M'
⊢ mk' f m s = m' ↔ ↑f m = s • m'
Theorem: Multiset.rel_zero_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [Rel_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.442937
δ : Type ?u.442940
r : α → β → Prop
p : γ → δ → Prop
a : Multiset α
⊢ Rel r a 0 ↔ a = 0

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.442937
δ : Type ?u.442940
r : α → β → Prop
p : γ → δ → Prop
a : Multiset α
⊢ (a = 0 ∧ 0 = 0 ∨
      Exists fun {a_1} =>
        Exists fun {b} => Exists fun {as} => Exists fun {bs} => r a_1 b ∧ Rel r as bs ∧ a = a_1 ::ₘ as ∧ 0 = b ::ₘ bs) ↔
    a = 0
Theorem: divp_eq_iff_mul_eq
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [divp_mul_cancel]
state_before: α : Type u
inst✝ : Monoid α
a b c x : α
u : αˣ
y : α
⊢ x /ₚ u * ↑u = y * ↑u ↔ y * ↑u = x

tactic: exact ⟨Eq.symm, Eq.symm⟩
state_before: α : Type u
inst✝ : Monoid α
a b c x : α
u : αˣ
y : α
⊢ x = y * ↑u ↔ y * ↑u = x
Theorem: AddMonoidAlgebra.gradeBy_id
File: Mathlib/Algebra/MonoidAlgebra/Grading.lean

tactic: rfl
state_before: M : Type u_1
ι : Type ?u.5622
R : Type u_2
inst✝¹ : DecidableEq M
inst✝ : CommSemiring R
⊢ gradeBy R id = grade R
Theorem: Complex.cosh_ofReal_im
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_cosh_ofReal_re, ofReal_im]
state_before: x✝ y : ℂ
x : ℝ
⊢ (cosh ↑x).im = 0
Theorem: Quaternion.mul_imJ
File: Mathlib/Algebra/Quaternion.lean

tactic: simp only [one_mul, neg_mul, sub_eq_add_neg, neg_neg]
state_before: S : Type ?u.421024
T : Type ?u.421027
R : Type u_1
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ a.re * b.imJ + -1 * a.imI * b.imK + a.imJ * b.re - -1 * a.imK * b.imI =
    a.re * b.imJ - a.imI * b.imK + a.imJ * b.re + a.imK * b.imI
Theorem: CategoryTheory.Equivalence.counitInv_app_functor
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: symm
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
X : C
⊢ (counitInv e).app (e.functor.obj X) = e.functor.map ((unit e).app X)

tactic: erw [← Iso.comp_hom_eq_id (e.counitIso.app _), functor_unit_comp]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
X : C
⊢ e.functor.map ((unit e).app X) = (counitInv e).app (e.functor.obj X)

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
X : C
⊢ 𝟙 (e.functor.obj X) = 𝟙 ((𝟭 D).obj (e.functor.toPrefunctor.1 ((𝟭 C).obj X)))
Theorem: EMetric.cauchy_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: rw [← neBot_iff]
state_before: α : Type u
β : Type v
X : Type ?u.28215
inst✝ : PseudoEMetricSpace α
f : Filter α
⊢ Cauchy f ↔ f ≠ ⊥ ∧ ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, t ∈ f ∧ ∀ (x : α), x ∈ t → ∀ (y : α), y ∈ t → edist x y < ε

tactic: exact uniformity_basis_edist.cauchy_iff
state_before: α : Type u
β : Type v
X : Type ?u.28215
inst✝ : PseudoEMetricSpace α
f : Filter α
⊢ Cauchy f ↔ NeBot f ∧ ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, t ∈ f ∧ ∀ (x : α), x ∈ t → ∀ (y : α), y ∈ t → edist x y < ε
Theorem: Polynomial.separable_C
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [separable_def, derivative_C, isCoprime_zero_right, isUnit_C]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
r : R
⊢ Separable (↑C r) ↔ IsUnit r
Theorem: Nat.add_eq_three_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: cases n <;>
simp [(succ_ne_zero 1).symm, succ_eq_add_one, (show 3 = Nat.succ 2 from rfl),
  ← add_assoc, succ_inj', add_eq_two_iff]
state_before: m n k l : ℕ
⊢ m + n = 3 ↔ m = 0 ∧ n = 3 ∨ m = 1 ∧ n = 2 ∨ m = 2 ∧ n = 1 ∨ m = 3 ∧ n = 0
Theorem: ContinuousAt.comp_of_eq
File: Mathlib/Topology/Basic.lean

tactic: subst hy
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.168296
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : β → γ
f : α → β
x : α
y : β
hg : ContinuousAt g y
hf : ContinuousAt f x
hy : f x = y
⊢ ContinuousAt (g ∘ f) x

tactic: exact hg.comp hf
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.168296
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : β → γ
f : α → β
x : α
hf : ContinuousAt f x
hg : ContinuousAt g (f x)
⊢ ContinuousAt (g ∘ f) x
Theorem: tendstoUniformlyOn_univ
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp [TendstoUniformlyOn, TendstoUniformly]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ TendstoUniformlyOn F f p univ ↔ TendstoUniformly F f p
Theorem: Finset.Ico_subset_Iio_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simpa [← coe_subset] using Set.Ico_subset_Iio_self
state_before: ι : Type ?u.55946
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderBot α
⊢ Ico a b ⊆ Iio b
Theorem: Set.image2_singleton
File: Mathlib/Data/Set/NAry.lean

tactic: simp
state_before: α : Type u_2
α' : Type ?u.27806
β : Type u_3
β' : Type ?u.27812
γ : Type u_1
γ' : Type ?u.27818
δ : Type ?u.27821
δ' : Type ?u.27824
ε : Type ?u.27827
ε' : Type ?u.27830
ζ : Type ?u.27833
ζ' : Type ?u.27836
ν : Type ?u.27839
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f {a} {b} = {f a b}
Theorem: Finset.disjoint_insert_left
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [disjoint_left, mem_insert, or_imp, forall_and, forall_eq]
state_before: α : Type u_1
β : Type ?u.121015
γ : Type ?u.121018
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ _root_.Disjoint (insert a s) t ↔ ¬a ∈ t ∧ _root_.Disjoint s t
Theorem: CstarRing.norm_coe_unitary
File: Mathlib/Analysis/NormedSpace/Star/Basic.lean

tactic: rw [← sq_eq_sq (norm_nonneg _) zero_le_one, one_pow 2, sq, ← CstarRing.norm_star_mul_self,
  unitary.coe_star_mul_self, CstarRing.norm_one]
state_before: 𝕜 : Type ?u.74050
E : Type u_1
α : Type ?u.74056
inst✝³ : NormedRing E
inst✝² : StarRing E
inst✝¹ : CstarRing E
inst✝ : Nontrivial E
U : { x // x ∈ unitary E }
⊢ ‖↑U‖ = 1
Theorem: SimpleGraph.Subgraph.edgeSet_inf
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp
state_before: ι : Sort ?u.104778
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
H₁ H₂ : Subgraph G
⊢ ∀ (x y : V),
    Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet (H₁ ⊓ H₂) ↔
      Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet H₁ ∩ edgeSet H₂
Theorem: List.mapIdxGo_length
File: Mathlib/Data/List/Indexes.lean

tactic: intro f l
state_before: α : Type u
β : Type v
⊢ ∀ (f : ℕ → α → β) (l : List α) (arr : Array β), length (mapIdx.go f l arr) = length l + Array.size arr

tactic: induction' l with head tail ih
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
⊢ ∀ (arr : Array β), length (mapIdx.go f l arr) = length l + Array.size arr

tactic: intro
state_before: case nil
α : Type u
β : Type v
f : ℕ → α → β
⊢ ∀ (arr : Array β), length (mapIdx.go f [] arr) = length [] + Array.size arr

tactic: simp only [mapIdx.go, Array.toList_eq, length_nil, zero_add]
state_before: case nil
α : Type u
β : Type v
f : ℕ → α → β
arr✝ : Array β
⊢ length (mapIdx.go f [] arr✝) = length [] + Array.size arr✝

tactic: intro
state_before: case cons
α : Type u
β : Type v
f : ℕ → α → β
head : α
tail : List α
ih : ∀ (arr : Array β), length (mapIdx.go f tail arr) = length tail + Array.size arr
⊢ ∀ (arr : Array β), length (mapIdx.go f (head :: tail) arr) = length (head :: tail) + Array.size arr

tactic: simp only [mapIdx.go]
state_before: case cons
α : Type u
β : Type v
f : ℕ → α → β
head : α
tail : List α
ih : ∀ (arr : Array β), length (mapIdx.go f tail arr) = length tail + Array.size arr
arr✝ : Array β
⊢ length (mapIdx.go f (head :: tail) arr✝) = length (head :: tail) + Array.size arr✝

tactic: rw [ih]
state_before: case cons
α : Type u
β : Type v
f : ℕ → α → β
head : α
tail : List α
ih : ∀ (arr : Array β), length (mapIdx.go f tail arr) = length tail + Array.size arr
arr✝ : Array β
⊢ length (mapIdx.go f tail (Array.push arr✝ (f (Array.size arr✝) head))) = length (head :: tail) + Array.size arr✝

tactic: simp only [Array.size_push, length_cons]
state_before: case cons
α : Type u
β : Type v
f : ℕ → α → β
head : α
tail : List α
ih : ∀ (arr : Array β), length (mapIdx.go f tail arr) = length tail + Array.size arr
arr✝ : Array β
⊢ length tail + Array.size (Array.push arr✝ (f (Array.size arr✝) head)) = length (head :: tail) + Array.size arr✝

tactic: simp only [Nat.add_succ, add_zero, Nat.add_comm]
state_before: case cons
α : Type u
β : Type v
f : ℕ → α → β
head : α
tail : List α
ih : ∀ (arr : Array β), length (mapIdx.go f tail arr) = length tail + Array.size arr
arr✝ : Array β
⊢ length tail + (Array.size arr✝ + 1) = Nat.succ (length tail) + Array.size arr✝