tasksource/leandojo huggingface dataset:
Theorem: Nat.one_div_lt_one_div
File: Mathlib/Data/Nat/Cast/Field.lean

tactic: refine' one_div_lt_one_div_of_lt _ _
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n < m
⊢ 1 / (↑m + 1) < 1 / (↑n + 1)

tactic: exact Nat.cast_add_one_pos _
state_before: case refine'_1
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n < m
⊢ 0 < ↑n + 1

case refine'_2
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n < m
⊢ ↑n + 1 < ↑m + 1

tactic: simpa
state_before: case refine'_2
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n < m
⊢ ↑n + 1 < ↑m + 1
Theorem: UV.compress_of_disjoint_of_le'
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: rw [compress_of_disjoint_of_le disjoint_sdiff_self_right
    (le_sdiff.2 ⟨(le_sup_right : v ≤ a ⊔ v), hva.mono_right hua⟩),
  sdiff_sup_cancel (le_sup_of_le_left hua), hva.symm.sup_sdiff_cancel_right]
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
hva : Disjoint v a
hua : u ≤ a
⊢ compress u v ((a ⊔ v) \ u) = a
Theorem: ContinuousSMul.of_nhds_zero
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: refine continuous_of_continuousAt_zero₂ (AddMonoidHom.smul : R →+ M →+ M) ?_ ?_ ?_ <;>
  simpa [ContinuousAt, nhds_prod_eq]
state_before: R : Type u_1
M : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : TopologicalSpace R
inst✝⁴ : TopologicalSpace M
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : TopologicalRing R
inst✝ : TopologicalAddGroup M
hmul : Tendsto (fun p => p.fst • p.snd) (𝓝 0 ×ˢ 𝓝 0) (𝓝 0)
hmulleft : ∀ (m : M), Tendsto (fun a => a • m) (𝓝 0) (𝓝 0)
hmulright : ∀ (a : R), Tendsto (fun m => a • m) (𝓝 0) (𝓝 0)
⊢ Continuous fun p => p.fst • p.snd
Theorem: Orthonormal.inner_finsupp_eq_sum_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [l₂.total_apply _, Finsupp.inner_sum, hv.inner_left_finsupp, mul_comm, smul_eq_mul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2058385
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l₁ l₂ : ι →₀ 𝕜
⊢ inner (↑(Finsupp.total ι E 𝕜 v) l₁) (↑(Finsupp.total ι E 𝕜 v) l₂) =
    Finsupp.sum l₂ fun i y => ↑(starRingEnd ((fun x => 𝕜) i)) (↑l₁ i) * y
Theorem: Metric.tendstoLocallyUniformly_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [← tendstoLocallyUniformlyOn_univ, tendstoLocallyUniformlyOn_iff, nhdsWithin_univ,
  mem_univ, forall_const, exists_prop]
state_before: α : Type u
β : Type v
X : Type ?u.81094
ι✝ : Type ?u.81097
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
ι : Type u_1
inst✝ : TopologicalSpace β
F : ι → β → α
f : β → α
p : Filter ι
⊢ TendstoLocallyUniformly F f p ↔
    ∀ (ε : ℝ), ε > 0 → ∀ (x : β), ∃ t, t ∈ 𝓝 x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → dist (f y) (F n y) < ε
Theorem: archimedean_iff_int_lt
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: rw [archimedean_iff_nat_lt]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
⊢ (∀ (x : α), ∃ n, x < ↑n) → Archimedean α

tactic: intro h x
state_before: α : Type u_1
inst✝ : LinearOrderedField α
⊢ (∀ (x : α), ∃ n, x < ↑n) → ∀ (x : α), ∃ n, x < ↑n

tactic: obtain ⟨n, h⟩ := h x
state_before: α : Type u_1
inst✝ : LinearOrderedField α
h : ∀ (x : α), ∃ n, x < ↑n
x : α
⊢ ∃ n, x < ↑n

tactic: refine' ⟨n.toNat, h.trans_le _⟩
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
h✝ : ∀ (x : α), ∃ n, x < ↑n
x : α
n : ℤ
h : x < ↑n
⊢ ∃ n, x < ↑n

tactic: exact_mod_cast Int.self_le_toNat _
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
h✝ : ∀ (x : α), ∃ n, x < ↑n
x : α
n : ℤ
h : x < ↑n
⊢ ↑n ≤ ↑(toNat n)
Theorem: CategoryTheory.Limits.isIso_of_source_target_iso_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: rw [zero_of_source_iso_zero f i]
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
f : X ⟶ Y
i : X ≅ 0
j : Y ≅ 0
⊢ IsIso f

tactic: exact (isIsoZeroEquivIsoZero _ _).invFun ⟨i, j⟩
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
f : X ⟶ Y
i : X ≅ 0
j : Y ≅ 0
⊢ IsIso 0
Theorem: Module.End_algebraMap_isUnit_inv_apply_eq_iff'
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: apply_fun (↑h.unit : M → M) using ((Module.End_isUnit_iff _).mp h).injective
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : R
h : IsUnit (↑(algebraMap R (End R M)) x)
m m' : M
H : m = x • m'
⊢ m' = ↑↑(IsUnit.unit h)⁻¹ (x • m')

tactic: erw [End_isUnit_apply_inv_apply_of_isUnit]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : R
h : IsUnit (↑(algebraMap R (End R M)) x)
m m' : M
H : m = x • m'
⊢ ↑↑(IsUnit.unit h) m' = ↑↑(IsUnit.unit h) (↑↑(IsUnit.unit h)⁻¹ (x • m'))

tactic: rfl
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : R
h : IsUnit (↑(algebraMap R (End R M)) x)
m m' : M
H : m = x • m'
⊢ ↑↑(IsUnit.unit h) m' = x • m'
Theorem: Sum.elim_mulSingle_one
File: Mathlib/Data/Pi/Algebra.lean

tactic: simp only [Pi.mulSingle, Sum.elim_update_left, elim_one_one]
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f i
i✝ : I
a a' : α → γ
b b' : β → γ
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : One γ
i : α
c : γ
⊢ Sum.elim (Pi.mulSingle i c) 1 = Pi.mulSingle (inl i) c
Theorem: PGame.Subsequent.moveLeft_mk_right
File: Mathlib/SetTheory/Game/PGame.lean

tactic: pgame_wf_tac
state_before: xr : Type u_1
i : xr
xl : Type u_1
xL : xl → PGame
xR : xr → PGame
j : LeftMoves (xR i)
⊢ Subsequent (PGame.moveLeft (xR i) j) (mk xl xr xL xR)
Theorem: NormedAddGroupHom.mem_ker
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: erw [f.toAddMonoidHom.mem_ker, coe_toAddMonoidHom]
state_before: V : Type ?u.481267
W : Type ?u.481270
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.481279
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
v : V₁
⊢ v ∈ ker f ↔ ↑f v = 0
Theorem: isIrreducible_iff_singleton
File: Mathlib/Topology/Separation.lean

tactic: rw [IsIrreducible, isPreirreducible_iff_subsingleton,
  exists_eq_singleton_iff_nonempty_subsingleton]
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.143258
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
S : Set α
⊢ IsIrreducible S ↔ ∃ x, S = {x}
Theorem: Computable.option_map
File: Mathlib/Computability/Partrec.lean

tactic: convert option_bind hf (option_some.comp₂ hg)
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.185392
σ : Type u_3
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
g : α → β → σ
hf : Computable f
hg : Computable₂ g
⊢ Computable fun a => Option.map (g a) (f a)

tactic: apply Option.map_eq_bind
state_before: case h.e'_5.h
α : Type u_2
β : Type u_1
γ : Type ?u.185392
σ : Type u_3
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
g : α → β → σ
hf : Computable f
hg : Computable₂ g
x✝ : α
⊢ Option.map (g x✝) (f x✝) = Option.bind (f x✝) fun b => Option.some (g x✝ b)
Theorem: List.Nat.length_antidiagonal
File: Mathlib/Data/List/NatAntidiagonal.lean

tactic: rw [antidiagonal, length_map, length_range]
state_before: n : ℕ
⊢ length (antidiagonal n) = n + 1
Theorem: LinearMap.range_codRestrict
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simpa only [range_eq_map] using map_codRestrict _ _ _ _
state_before: R : Type u_2
R₁ : Type ?u.1236277
R₂ : Type u_1
R₃ : Type ?u.1236283
R₄ : Type ?u.1236286
S : Type ?u.1236289
K : Type ?u.1236292
K₂ : Type ?u.1236295
M : Type u_3
M' : Type ?u.1236301
M₁ : Type ?u.1236304
M₂ : Type u_4
M₃ : Type ?u.1236310
M₄ : Type ?u.1236313
N : Type ?u.1236316
N₂ : Type ?u.1236319
ι : Type ?u.1236322
V : Type ?u.1236325
V₂ : Type ?u.1236328
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type ?u.1236738
sc : SemilinearMapClass F τ₁₂ M M₂
τ₂₁ : R₂ →+* R
inst✝ : RingHomSurjective τ₂₁
p : Submodule R M
f : M₂ →ₛₗ[τ₂₁] M
hf : ∀ (c : M₂), ↑f c ∈ p
⊢ range (codRestrict p f hf) = comap (Submodule.subtype p) (range f)
Theorem: TendstoUniformly.tendstoLocallyUniformly
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simpa using h u hu
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 : TendstoUniformly F f p
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
⊢ ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ univ → (f y, F n y) ∈ u
Theorem: Equiv.Perm.SameCycle.conj
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [sameCycle_conj]
state_before: ι : Type ?u.39785
α : Type u_1
β : Type ?u.39791
f g : Perm α
p : α → Prop
x y z : α
⊢ SameCycle f x y → SameCycle (g * f * g⁻¹) (↑g x) (↑g y)
Theorem: bernoulli'_two
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: rw [bernoulli'_def, sum_range_succ, sum_range_succ, sum_range_zero]
state_before: A : Type ?u.185050
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli' 2 = 1 / 6

tactic: norm_num
state_before: A : Type ?u.185050
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ 1 - (0 + ↑(Nat.choose 2 0) / (↑2 - ↑0 + 1) * bernoulli' 0 + ↑(Nat.choose 2 1) / (↑2 - ↑1 + 1) * bernoulli' 1) = 1 / 6
Theorem: Polynomial.derivative_pow_succ
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
p : R[X]
n : ℕ
⊢ ↑derivative (p ^ (Nat.zero + 1)) = ↑C (↑Nat.zero + 1) * p ^ Nat.zero * ↑derivative p

tactic: rw [pow_succ', derivative_mul, ih, Nat.add_one, mul_right_comm, C_add,
  add_mul, add_mul, pow_succ', ← mul_assoc, C_1, one_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝¹ : ℕ
inst✝ : CommSemiring R
p : R[X]
n✝ n : ℕ
ih : ↑derivative (p ^ (n + 1)) = ↑C (↑n + 1) * p ^ n * ↑derivative p
⊢ ↑derivative (p ^ (Nat.succ n + 1)) = ↑C (↑(Nat.succ n) + 1) * p ^ Nat.succ n * ↑derivative p

tactic: simp [add_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝¹ : ℕ
inst✝ : CommSemiring R
p : R[X]
n✝ n : ℕ
ih : ↑derivative (p ^ (n + 1)) = ↑C (↑n + 1) * p ^ n * ↑derivative p
⊢ (↑C ↑n * p ^ n * p + p ^ n * p) * ↑derivative p + p ^ n * p * ↑derivative p =
    ↑C (↑(Nat.succ n) + 1) * p ^ n * p * ↑derivative p
Theorem: norm_iteratedFDerivWithin_zero
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [iteratedFDerivWithin_zero_eq_comp, comp_apply, LinearIsometryEquiv.norm_map]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ‖iteratedFDerivWithin 𝕜 0 f s x‖ = ‖f x‖
Theorem: IsROrC.normSq_neg
File: Mathlib/Data/IsROrC/Basic.lean

tactic: simp only [normSq_eq_def', norm_neg]
state_before: K : Type u_1
E : Type ?u.4480572
inst✝ : IsROrC K
z : K
⊢ ↑normSq (-z) = ↑normSq z
Theorem: List.not_lt_maximum_of_mem'
File: Mathlib/Data/List/MinMax.lean

tactic: cases h : l.maximum
state_before: α : Type u_1
β : Type ?u.91154
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
l : List α
a m : α
ha : a ∈ l
⊢ ¬maximum l < ↑a

tactic: simp_all
state_before: case none
α : Type u_1
β : Type ?u.91154
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
l : List α
a m : α
ha : a ∈ l
h : maximum l = none
⊢ ¬none < ↑a

tactic: simp [WithBot.some_eq_coe, WithBot.coe_lt_coe, not_lt_maximum_of_mem ha h, not_false_iff]
state_before: case some
α : Type u_1
β : Type ?u.91154
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
l : List α
a m : α
ha : a ∈ l
val✝ : α
h : maximum l = some val✝
⊢ ¬some val✝ < ↑a
Theorem: EuclideanDomain.eq_div_of_mul_eq_right
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [← h, mul_div_cancel_left _ ha]
state_before: R : Type u
inst✝ : EuclideanDomain R
a b c : R
ha : a ≠ 0
h : a * b = c
⊢ b = c / a
Theorem: ValuationRing.unique_irreducible
File: Mathlib/RingTheory/Valuation/ValuationRing.lean

tactic: have := dvd_total p q
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
K : Type ?u.528557
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : ValuationRing R
p q : R
hp : Irreducible p
hq : Irreducible q
⊢ Associated p q

tactic: rw [Irreducible.dvd_comm hp hq, or_self_iff] at this
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
K : Type ?u.528557
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : ValuationRing R
p q : R
hp : Irreducible p
hq : Irreducible q
this : p ∣ q ∨ q ∣ p
⊢ Associated p q

tactic: exact associated_of_dvd_dvd (Irreducible.dvd_symm hq hp this) this
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
K : Type ?u.528557
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : ValuationRing R
p q : R
hp : Irreducible p
hq : Irreducible q
this : q ∣ p
⊢ Associated p q
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_inv_snd_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIso
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).inv ≫ snd ≫ fst = fst

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (Iso.mk (lift (snd ≫ fst) (snd ≫ snd) (_ : (snd ≫ fst) ≫ i₁ = (snd ≫ snd) ≫ i₂))
          (lift (fst ≫ i₁ ≫ fst)
            (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
              (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd))
            (_ :
              (fst ≫ i₁ ≫ fst) ≫ diagonal f =
                map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
                    (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd) ≫
                  map (i₁ ≫ snd) (i₂ ≫ snd) f f (i₁ ≫ fst) (i₂ ≫ fst) i (_ : (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f)
                    (_ : (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f)))).inv ≫
      snd ≫ fst =
    fst
Theorem: PiNat.dist_self
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp [dist]
state_before: E : ℕ → Type u_1
x : (n : ℕ) → E n
⊢ dist x x = 0
Theorem: PiNat.firstDiff_comm
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp only [firstDiff_def, ne_comm]
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
⊢ firstDiff x y = firstDiff y x
Theorem: Nat.Primrec'.pred
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: v : Vector ℕ (Nat.succ 0)
⊢ Nat.rec 0 (fun y IH => Vector.head (y ::ᵥ IH ::ᵥ v)) (Vector.head v) = Nat.pred (Vector.head v)

tactic: cases v.head <;> rfl
state_before: v : Vector ℕ (Nat.succ 0)
⊢ Nat.rec 0 (fun y IH => y) (Vector.head v) = Nat.pred (Vector.head v)
Theorem: Finset.filter_card_add_filter_neg_card_eq_card
File: Mathlib/Data/Finset/Card.lean

tactic: classical rw [← card_union_eq (disjoint_filter_filter_neg _ _ _), filter_union_filter_neg_eq]
state_before: α : Type u_1
β : Type ?u.42409
s t : Finset α
f : α → β
n : ℕ
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : (x : α) → Decidable ¬p x
⊢ card (filter p s) + card (filter (fun a => ¬p a) s) = card s

tactic: rw [← card_union_eq (disjoint_filter_filter_neg _ _ _), filter_union_filter_neg_eq]
state_before: α : Type u_1
β : Type ?u.42409
s t : Finset α
f : α → β
n : ℕ
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : (x : α) → Decidable ¬p x
⊢ card (filter p s) + card (filter (fun a => ¬p a) s) = card s
Theorem: SeminormedGroup.tendstoUniformlyOn_one
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp_rw [tendstoUniformlyOn_iff, Pi.one_apply, dist_one_left]
state_before: 𝓕 : Type ?u.502213
𝕜 : Type ?u.502216
α : Type ?u.502219
ι : Type u_2
κ : Type u_1
E : Type ?u.502228
F : Type ?u.502231
G : Type u_3
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s✝ : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
f : ι → κ → G
s : Set κ
l : Filter ι
⊢ TendstoUniformlyOn f 1 l s ↔ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (i : ι) in l, ∀ (x : κ), x ∈ s → ‖f i x‖ < ε
Theorem: Set.zero_mem_center
File: Mathlib/GroupTheory/Subsemigroup/Center.lean

tactic: simp [mem_center_iff]
state_before: M : Type u_1
inst✝ : MulZeroClass M
⊢ 0 ∈ center M
Theorem: ContinuousLinearMap.map_neg
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: exact map_neg f x
state_before: R : Type u_1
inst✝¹³ : Ring R
R₂ : Type u_2
inst✝¹² : Ring R₂
R₃ : Type ?u.715179
inst✝¹¹ : Ring R₃
M : Type u_3
inst✝¹⁰ : TopologicalSpace M
inst✝⁹ : AddCommGroup M
M₂ : Type u_4
inst✝⁸ : TopologicalSpace M₂
inst✝⁷ : AddCommGroup M₂
M₃ : Type ?u.715203
inst✝⁶ : TopologicalSpace M₃
inst✝⁵ : AddCommGroup M₃
M₄ : Type ?u.715212
inst✝⁴ : TopologicalSpace M₄
inst✝³ : AddCommGroup M₄
inst✝² : Module R M
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
f : M →SL[σ₁₂] M₂
x : M
⊢ ↑f (-x) = -↑f x
Theorem: Metric.Sum.one_le_dist_inr_inl
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: rw [Sum.dist_comm]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝¹ : MetricSpace X
inst✝ : MetricSpace Y
x : X
y : Y
⊢ 1 ≤ Sum.dist (Sum.inr y) (Sum.inl x)

tactic: exact Sum.one_le_dist_inl_inr
state_before: X : Type u
Y : Type v
Z : Type w
inst✝¹ : MetricSpace X
inst✝ : MetricSpace Y
x : X
y : Y
⊢ 1 ≤ Sum.dist (Sum.inl x) (Sum.inr y)
Theorem: IsHomeomorphicTrivialFiberBundle.isOpenMap_proj
File: Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean

tactic: obtain ⟨e, rfl⟩ := h.proj_eq
state_before: B : Type u_1
F : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : TopologicalSpace Z
proj : Z → B
h : IsHomeomorphicTrivialFiberBundle F proj
⊢ IsOpenMap proj

tactic: exact isOpenMap_fst.comp e.isOpenMap
state_before: case intro
B : Type u_1
F : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : TopologicalSpace Z
e : Z ≃ₜ B × F
h : IsHomeomorphicTrivialFiberBundle F (Prod.fst ∘ ↑e)
⊢ IsOpenMap (Prod.fst ∘ ↑e)
Theorem: WittVector.mapFun.int_cast
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: cases n <;> simp [*, Int.castDef, add, one, neg, zero, nat_cast] <;> rfl
state_before: p : ℕ
R : Type u_2
S : Type u_1
T : Type ?u.559389
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.559404
β : Type ?u.559407
f : R →+* S
x y : 𝕎 R
n : ℤ
⊢ mapFun (↑f) (Int.castDef n) = ↑n
Theorem: ultrafilter_pure_injective
File: Mathlib/Topology/StoneCech.lean

tactic: intro x y h
state_before: α : Type u
⊢ Function.Injective pure

tactic: have : {x} ∈ (pure x : Ultrafilter α) := singleton_mem_pure
state_before: α : Type u
x y : α
h : pure x = pure y
⊢ x = y

tactic: rw [h] at this
state_before: α : Type u
x y : α
h : pure x = pure y
this : {x} ∈ pure x
⊢ x = y

tactic: exact (mem_singleton_iff.mp (mem_pure.mp this)).symm
state_before: α : Type u
x y : α
h : pure x = pure y
this : {x} ∈ pure y
⊢ x = y
Theorem: Real.sinh_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ sinh (x + y) = sinh x * cosh y + cosh x * sinh y

tactic: simp [sinh_add]
state_before: x y : ℝ
⊢ ↑(sinh (x + y)) = ↑(sinh x * cosh y + cosh x * sinh y)
Theorem: Fin.castAdd_castAdd
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n✝ m✝ m n p : ℕ
i : Fin m
⊢ ↑(castAdd p) (↑(castAdd n) i) = ↑(cast (_ : m + (n + p) = m + n + p)) (↑(castAdd (n + p)) i)

tactic: simp
state_before: case h
n✝ m✝ m n p : ℕ
i : Fin m
⊢ ↑(↑(castAdd p) (↑(castAdd n) i)) = ↑(↑(cast (_ : m + (n + p) = m + n + p)) (↑(castAdd (n + p)) i))
Theorem: Set.image_const_mul_Ioi_zero
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: erw [(Units.mk0 x hx.ne').mulLeft.image_eq_preimage, preimage_const_mul_Ioi 0 (inv_pos.mpr hx),
  zero_div]
state_before: α : Type ?u.462617
inst✝¹ : LinearOrderedField α
a : α
k : Type u_1
inst✝ : LinearOrderedField k
x : k
hx : 0 < x
⊢ (fun y => x * y) '' Ioi 0 = Ioi 0
Theorem: List.prod_eq_zero
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: induction' L with a L ihL
state_before: ι : Type ?u.107956
α : Type ?u.107959
M : Type ?u.107962
N : Type ?u.107965
P : Type ?u.107968
M₀ : Type u_1
G : Type ?u.107974
R : Type ?u.107977
inst✝ : MonoidWithZero M₀
L : List M₀
h : 0 ∈ L
⊢ prod L = 0

tactic: exact absurd h (not_mem_nil _)
state_before: case nil
ι : Type ?u.107956
α : Type ?u.107959
M : Type ?u.107962
N : Type ?u.107965
P : Type ?u.107968
M₀ : Type u_1
G : Type ?u.107974
R : Type ?u.107977
inst✝ : MonoidWithZero M₀
L : List M₀
h✝ : 0 ∈ L
h : 0 ∈ []
⊢ prod [] = 0

tactic: rw [prod_cons]
state_before: case cons
ι : Type ?u.107956
α : Type ?u.107959
M : Type ?u.107962
N : Type ?u.107965
P : Type ?u.107968
M₀ : Type u_1
G : Type ?u.107974
R : Type ?u.107977
inst✝ : MonoidWithZero M₀
L✝ : List M₀
h✝ : 0 ∈ L✝
a : M₀
L : List M₀
ihL : 0 ∈ L → prod L = 0
h : 0 ∈ a :: L
⊢ prod (a :: L) = 0

tactic: cases' mem_cons.1 h with ha hL
state_before: case cons
ι : Type ?u.107956
α : Type ?u.107959
M : Type ?u.107962
N : Type ?u.107965
P : Type ?u.107968
M₀ : Type u_1
G : Type ?u.107974
R : Type ?u.107977
inst✝ : MonoidWithZero M₀
L✝ : List M₀
h✝ : 0 ∈ L✝
a : M₀
L : List M₀
ihL : 0 ∈ L → prod L = 0
h : 0 ∈ a :: L
⊢ a * prod L = 0

tactic: exacts [mul_eq_zero_of_left ha.symm _, mul_eq_zero_of_right _ (ihL hL)]
state_before: case cons.inl
ι : Type ?u.107956
α : Type ?u.107959
M : Type ?u.107962
N : Type ?u.107965
P : Type ?u.107968
M₀ : Type u_1
G : Type ?u.107974
R : Type ?u.107977
inst✝ : MonoidWithZero M₀
L✝ : List M₀
h✝ : 0 ∈ L✝
a : M₀
L : List M₀
ihL : 0 ∈ L → prod L = 0
h : 0 ∈ a :: L
ha : 0 = a
⊢ a * prod L = 0

case cons.inr
ι : Type ?u.107956
α : Type ?u.107959
M : Type ?u.107962
N : Type ?u.107965
P : Type ?u.107968
M₀ : Type u_1
G : Type ?u.107974
R : Type ?u.107977
inst✝ : MonoidWithZero M₀
L✝ : List M₀
h✝ : 0 ∈ L✝
a : M₀
L : List M₀
ihL : 0 ∈ L → prod L = 0
h : 0 ∈ a :: L
hL : 0 ∈ L
⊢ a * prod L = 0
Theorem: Urysohns.CU.approx_nonneg
File: Mathlib/Topology/UrysohnsLemma.lean

tactic: induction' n with n ihn generalizing c
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c : CU X
n : ℕ
x : X
⊢ 0 ≤ approx n c x

tactic: exact indicator_nonneg (fun _ _ => zero_le_one) _
state_before: case zero
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
c : CU X
⊢ 0 ≤ approx Nat.zero c x

tactic: simp only [approx, midpoint_eq_smul_add, invOf_eq_inv]
state_before: case succ
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
n : ℕ
ihn : ∀ (c : CU X), 0 ≤ approx n c x
c : CU X
⊢ 0 ≤ approx (Nat.succ n) c x

tactic: refine' mul_nonneg (inv_nonneg.2 zero_le_two) (add_nonneg _ _) <;> apply ihn
state_before: case succ
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
n : ℕ
ihn : ∀ (c : CU X), 0 ≤ approx n c x
c : CU X
⊢ 0 ≤ 2⁻¹ • (approx n (left c) x + approx n (right c) x)