tasksource/leandojo huggingface dataset:
Theorem: ContDiffOn.continuousOn_iteratedDerivWithin
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: simpa only [iteratedDerivWithin_eq_equiv_comp, LinearIsometryEquiv.comp_continuousOn_iff] using
  h.continuousOn_iteratedFDerivWithin hmn hs
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.47222
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
n : ℕ∞
m : ℕ
h : ContDiffOn 𝕜 n f s
hmn : ↑m ≤ n
hs : UniqueDiffOn 𝕜 s
⊢ ContinuousOn (iteratedDerivWithin m f s) s
Theorem: Order.isSuccLimit_toDual_iff
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp [IsSuccLimit, IsPredLimit]
state_before: α : Type u_1
inst✝ : LT α
a : α
⊢ IsSuccLimit (↑toDual a) ↔ IsPredLimit a
Theorem: Finsupp.sum_ite_self_eq
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: classical
  convert f.sum_ite_eq a fun _ => id
  simp [ite_eq_right_iff.2 Eq.symm]
state_before: α : Type u_1
ι : Type ?u.48396
γ : Type ?u.48399
A : Type ?u.48402
B : Type ?u.48405
C : Type ?u.48408
inst✝⁷ : AddCommMonoid A
inst✝⁶ : AddCommMonoid B
inst✝⁵ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.51538
M : Type ?u.51541
M' : Type ?u.51544
N✝ : Type ?u.51547
P : Type ?u.51550
G : Type ?u.51553
H : Type ?u.51556
R : Type ?u.51559
S : Type ?u.51562
inst✝⁴ : Zero M
inst✝³ : Zero M'
inst✝² : CommMonoid N✝
inst✝¹ : DecidableEq α
N : Type u_2
inst✝ : AddCommMonoid N
f : α →₀ N
a : α
⊢ (sum f fun x v => if a = x then v else 0) = ↑f a

tactic: convert f.sum_ite_eq a fun _ => id
state_before: α : Type u_1
ι : Type ?u.48396
γ : Type ?u.48399
A : Type ?u.48402
B : Type ?u.48405
C : Type ?u.48408
inst✝⁷ : AddCommMonoid A
inst✝⁶ : AddCommMonoid B
inst✝⁵ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.51538
M : Type ?u.51541
M' : Type ?u.51544
N✝ : Type ?u.51547
P : Type ?u.51550
G : Type ?u.51553
H : Type ?u.51556
R : Type ?u.51559
S : Type ?u.51562
inst✝⁴ : Zero M
inst✝³ : Zero M'
inst✝² : CommMonoid N✝
inst✝¹ : DecidableEq α
N : Type u_2
inst✝ : AddCommMonoid N
f : α →₀ N
a : α
⊢ (sum f fun x v => if a = x then v else 0) = ↑f a

tactic: simp [ite_eq_right_iff.2 Eq.symm]
state_before: case h.e'_3
α : Type u_1
ι : Type ?u.48396
γ : Type ?u.48399
A : Type ?u.48402
B : Type ?u.48405
C : Type ?u.48408
inst✝⁷ : AddCommMonoid A
inst✝⁶ : AddCommMonoid B
inst✝⁵ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.51538
M : Type ?u.51541
M' : Type ?u.51544
N✝ : Type ?u.51547
P : Type ?u.51550
G : Type ?u.51553
H : Type ?u.51556
R : Type ?u.51559
S : Type ?u.51562
inst✝⁴ : Zero M
inst✝³ : Zero M'
inst✝² : CommMonoid N✝
inst✝¹ : DecidableEq α
N : Type u_2
inst✝ : AddCommMonoid N
f : α →₀ N
a : α
⊢ ↑f a = if a ∈ f.support then id (↑f a) else 0
Theorem: NNReal.continuousAt_rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: simp only [rpow_zero, continuousAt_const]
state_before: x : ℝ≥0
y : ℝ
h✝¹ : x ≠ 0 ∨ 0 ≤ y
h✝ : 0 ≤ y
h : 0 = y
⊢ ContinuousAt (fun z => z ^ 0) x
Theorem: Int.subNatNat_add
File: Std/Data/Int/Lemmas.lean

tactic: cases n.lt_or_ge k with
| inl h' =>
  simp [subNatNat_of_lt h', succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')]
  conv => lhs; rw [← Nat.sub_add_cancel (Nat.le_of_lt h')]
  apply subNatNat_add_add
| inr h' => simp [subNatNat_of_le h',
    subNatNat_of_le (Nat.le_trans h' (le_add_left ..)), Nat.add_sub_assoc h']
state_before: m n k : Nat
⊢ subNatNat (m + n) k = ↑m + subNatNat n k

tactic: simp [subNatNat_of_lt h', succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')]
state_before: case inl
m n k : Nat
h' : n < k
⊢ subNatNat (m + n) k = ↑m + subNatNat n k

tactic: conv => lhs; rw [← Nat.sub_add_cancel (Nat.le_of_lt h')]
state_before: case inl
m n k : Nat
h' : n < k
⊢ subNatNat (m + n) k = subNatNat m (k - n)

tactic: apply subNatNat_add_add
state_before: case inl
m n k : Nat
h' : n < k
⊢ subNatNat (m + n) (k - n + n) = subNatNat m (k - n)

tactic: simp [subNatNat_of_le h',
subNatNat_of_le (Nat.le_trans h' (le_add_left ..)), Nat.add_sub_assoc h']
state_before: case inr
m n k : Nat
h' : n ≥ k
⊢ subNatNat (m + n) k = ↑m + subNatNat n k
Theorem: Real.rpow_nonneg_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_def_of_nonneg hx]
state_before: x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ 0 ≤ x ^ y

tactic: split_ifs <;>
simp only [zero_le_one, le_refl, le_of_lt (exp_pos _)]
state_before: x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ 0 ≤ if x = 0 then if y = 0 then 1 else 0 else exp (log x * y)
Theorem: HilbertBasis.hasSum_inner_mul_inner
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: convert (b.hasSum_repr y).mapL (innerSL _ x) using 1
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.851438
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x y : E
⊢ HasSum
    (fun i =>
      inner x ((fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i) *
        inner ((fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i) y)
    (inner x y)

tactic: ext i
state_before: case h.e'_5
ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.851438
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x y : E
⊢ (fun i =>
      inner x ((fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i) *
        inner ((fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i) y) =
    fun b_1 =>
    ↑(↑(innerSL 𝕜) x) (↑(↑b.repr y) b_1 • (fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) b_1)

tactic: rw [innerSL_apply, b.repr_apply_apply, inner_smul_right, mul_comm]
state_before: case h.e'_5.h
ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.851438
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x y : E
i : ι
⊢ inner x ((fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i) *
      inner ((fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i) y =
    ↑(↑(innerSL 𝕜) x) (↑(↑b.repr y) i • (fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i)
Theorem: MeasureTheory.SimpleFunc.lintegral_restrict
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [lintegral, Measure.restrict_apply, f.measurableSet_preimage]
state_before: α : Type u_1
β : Type ?u.888288
γ : Type ?u.888291
δ : Type ?u.888294
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α →ₛ ℝ≥0∞
s : Set α
μ : Measure α
⊢ lintegral f (Measure.restrict μ s) = ∑ y in SimpleFunc.range f, y * ↑↑μ (↑f ⁻¹' {y} ∩ s)
Theorem: IsIntegralClosure.mk'_mul
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: simp only [algebraMap_mk', RingHom.map_mul]
state_before: R : Type u_1
A : Type u_3
B : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsIntegralClosure A R B
x y : B
hx : IsIntegral R x
hy : IsIntegral R y
⊢ ↑(algebraMap A B) (mk' A (x * y) (_ : IsIntegral R (x * y))) = ↑(algebraMap A B) (mk' A x hx * mk' A y hy)
Theorem: CategoryTheory.Arrow.inv_left
File: Mathlib/CategoryTheory/Arrow.lean

tactic: rw [← Comma.comp_left, IsIso.hom_inv_id, id_left]
state_before: T : Type u
inst✝¹ : Category T
f g : Arrow T
sq : f ⟶ g
inst✝ : IsIso sq
⊢ sq.left ≫ (inv sq).left = 𝟙 f.left
Theorem: Pell.eq_of_xn_modEq_lem2
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [xn_succ, mul_comm] at h
state_before: a : ℕ
a1 : 1 < a
n : ℕ
h : 2 * xn a1 n = xn a1 (n + 1)
⊢ a = 2 ∧ n = 0

tactic: have : n = 0 :=
  n.eq_zero_or_pos.resolve_right fun np =>
    _root_.ne_of_lt
      (lt_of_le_of_lt (Nat.mul_le_mul_left _ a1)
        (Nat.lt_add_of_pos_right <| mul_pos (d_pos a1) (strictMono_y a1 np)))
      h
state_before: a : ℕ
a1 : 1 < a
n : ℕ
h : xn a1 n * 2 = xn a1 n * a + Pell.d a1 * yn a1 n
⊢ a = 2 ∧ n = 0

tactic: cases this
state_before: a : ℕ
a1 : 1 < a
n : ℕ
h : xn a1 n * 2 = xn a1 n * a + Pell.d a1 * yn a1 n
this : n = 0
⊢ a = 2 ∧ n = 0

tactic: simp at h
state_before: case refl
a : ℕ
a1 : 1 < a
h : xn a1 0 * 2 = xn a1 0 * a + Pell.d a1 * yn a1 0
⊢ a = 2 ∧ 0 = 0

tactic: exact ⟨h.symm, rfl⟩
state_before: case refl
a : ℕ
a1 : 1 < a
h : 2 = a
⊢ a = 2 ∧ 0 = 0
Theorem: IsAlgClosed.FractionRing.isAlgebraic
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

tactic: letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
state_before: k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
⊢ Algebra.IsAlgebraic (FractionRing R) (FractionRing S)

tactic: intro
state_before: k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
this : IsDomain R := Function.Injective.isDomain (algebraMap R S) (NoZeroSMulDivisors.algebraMap_injective R S)
⊢ Algebra.IsAlgebraic (FractionRing R) (FractionRing S)

tactic: exact
  (IsFractionRing.isAlgebraic_iff R (FractionRing R) (FractionRing S)).1
    ((IsFractionRing.isAlgebraic_iff' R S (FractionRing S)).1 hS _)
state_before: k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
this : IsDomain R := Function.Injective.isDomain (algebraMap R S) (NoZeroSMulDivisors.algebraMap_injective R S)
x✝ : FractionRing S
⊢ IsAlgebraic (FractionRing R) x✝
Theorem: finprod_eq_zero
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: nontriviality
state_before: α : Type u_2
β : Type ?u.383113
ι : Type ?u.383116
G : Type ?u.383119
M : Type ?u.383122
N : Type ?u.383125
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
M₀ : Type u_1
inst✝ : CommMonoidWithZero M₀
f : α → M₀
x : α
hx : f x = 0
hf : Set.Finite (mulSupport f)
⊢ (∏ᶠ (x : α), f x) = 0

tactic: rw [finprod_eq_prod f hf]
state_before: α : Type u_2
β : Type ?u.383113
ι : Type ?u.383116
G : Type ?u.383119
M : Type ?u.383122
N : Type ?u.383125
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
M₀ : Type u_1
inst✝ : CommMonoidWithZero M₀
f : α → M₀
x : α
hx : f x = 0
hf : Set.Finite (mulSupport f)
✝ : Nontrivial M₀
⊢ (∏ᶠ (x : α), f x) = 0

tactic: refine' Finset.prod_eq_zero (hf.mem_toFinset.2 _) hx
state_before: α : Type u_2
β : Type ?u.383113
ι : Type ?u.383116
G : Type ?u.383119
M : Type ?u.383122
N : Type ?u.383125
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
M₀ : Type u_1
inst✝ : CommMonoidWithZero M₀
f : α → M₀
x : α
hx : f x = 0
hf : Set.Finite (mulSupport f)
✝ : Nontrivial M₀
⊢ ∏ i in Finite.toFinset hf, f i = 0

tactic: simp [hx]
state_before: α : Type u_2
β : Type ?u.383113
ι : Type ?u.383116
G : Type ?u.383119
M : Type ?u.383122
N : Type ?u.383125
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
M₀ : Type u_1
inst✝ : CommMonoidWithZero M₀
f : α → M₀
x : α
hx : f x = 0
hf : Set.Finite (mulSupport f)
✝ : Nontrivial M₀
⊢ x ∈ mulSupport f
Theorem: Set.image_mul_right_Icc'
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [h, division_def]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ ↑(Units.mulRight (Units.mk0 c (_ : c ≠ 0))).symm ⁻¹' Icc a b = Icc (a * c) (b * c)
Theorem: Ideal.eq_top_of_unit_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: simp [h]
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hx : x ∈ I
h : y * x = 1
z : α
x✝ : z ∈ ⊤
⊢ z = z * (y * x)
Theorem: Filter.Germ.const_abs
File: Mathlib/Order/Filter/FilterProduct.lean

tactic: rw [abs_def, map_const]
state_before: α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : LinearOrderedAddCommGroup β
x : β
⊢ ↑(abs x) = abs ↑x
Theorem: Set.pairwise_disjoint_Ico_int_cast
File: Mathlib/Data/Set/Intervals/Group.lean

tactic: simpa only [zero_add] using pairwise_disjoint_Ico_add_int_cast (0 : α)
state_before: α : Type u_1
inst✝ : OrderedRing α
a : α
⊢ Pairwise (Disjoint on fun n => Ico (↑n) (↑n + 1))
Theorem: Lagrange.basis_ne_zero
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [Lagrange.basis, prod_ne_zero_iff, Ne.def, mem_erase]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ Lagrange.basis s v i ≠ 0

tactic: rintro j ⟨hij, hj⟩
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ ∀ (a : ι), a ≠ i ∧ a ∈ s → ¬basisDivisor (v i) (v a) = 0

tactic: rw [basisDivisor_eq_zero_iff, hvs.eq_iff hi hj]
state_before: case intro
F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j✝ : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
j : ι
hij : j ≠ i
hj : j ∈ s
⊢ ¬basisDivisor (v i) (v j) = 0

tactic: exact hij.symm
state_before: case intro
F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j✝ : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
j : ι
hij : j ≠ i
hj : j ∈ s
⊢ ¬i = j
Theorem: List.insertNth_injective
File: Mathlib/Data/List/Basic.lean

tactic: induction' n with n IH
state_before: ι : Type ?u.128977
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
x : α
⊢ Injective (insertNth n x)

tactic: have : insertNth 0 x = cons x := funext fun _ => rfl
state_before: case zero
ι : Type ?u.128977
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a x : α
⊢ Injective (insertNth zero x)

tactic: simp [this]
state_before: case zero
ι : Type ?u.128977
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a x : α
this : insertNth 0 x = cons x
⊢ Injective (insertNth zero x)

tactic: rintro (_ | ⟨a, as⟩) (_ | ⟨b, bs⟩) h <;> simpa [IH.eq_iff] using h
state_before: case succ
ι : Type ?u.128977
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a x : α
n : ℕ
IH : Injective (insertNth n x)
⊢ Injective (insertNth (succ n) x)
Theorem: PowerSeries.order_X_pow
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [X_pow_eq, order_monomial_of_ne_zero]
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
n : ℕ
⊢ order (X ^ n) = ↑n

tactic: exact one_ne_zero
state_before: case h
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
n : ℕ
⊢ 1 ≠ 0
Theorem: Ordinal.one_add_nat_cast
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← Nat.cast_one, ← Nat.cast_add, add_comm]
state_before: m : ℕ
⊢ 1 + ↑m = ↑(succ m)

tactic: rfl
state_before: m : ℕ
⊢ ↑(m + 1) = ↑(succ m)
Theorem: AlgebraicIndependent.to_subtype_range
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: nontriviality R
state_before: ι✝ : Type ?u.537278
ι' : Type ?u.537281
R : Type u_2
K : Type ?u.537287
A : Type u_3
A' : Type ?u.537293
A'' : Type ?u.537296
V : Type u
V' : Type ?u.537301
x : ι✝ → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
ι : Type u_1
f : ι → A
hf : AlgebraicIndependent R f
⊢ AlgebraicIndependent R Subtype.val

tactic: rwa [algebraicIndependent_subtype_range hf.injective]
state_before: ι✝ : Type ?u.537278
ι' : Type ?u.537281
R : Type u_2
K : Type ?u.537287
A : Type u_3
A' : Type ?u.537293
A'' : Type ?u.537296
V : Type u
V' : Type ?u.537301
x : ι✝ → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
ι : Type u_1
f : ι → A
hf : AlgebraicIndependent R f
✝ : Nontrivial R
⊢ AlgebraicIndependent R Subtype.val
Theorem: LinearMap.baseChange_add
File: Mathlib/RingTheory/TensorProduct.lean

tactic: ext
state_before: R : Type u_4
A : Type u_1
B : Type ?u.408400
M : Type u_2
N : Type u_3
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
r : R
f g : M →ₗ[R] N
⊢ baseChange A (f + g) = baseChange A f + baseChange A g

tactic: simp [baseChange_eq_ltensor, -baseChange_tmul]
state_before: case a.h.h
R : Type u_4
A : Type u_1
B : Type ?u.408400
M : Type u_2
N : Type u_3
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
r : R
f g : M →ₗ[R] N
x✝ : M
⊢ ↑(↑(AlgebraTensorModule.curry (baseChange A (f + g))) 1) x✝ =
    ↑(↑(AlgebraTensorModule.curry (baseChange A f + baseChange A g)) 1) x✝
Theorem: Filter.tendsto_mul_const_atTop_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [mul_comm] using tendsto_const_mul_atTop_of_neg hr
state_before: ι : Type ?u.229995
ι' : Type ?u.229998
α : Type u_1
β : Type u_2
γ : Type ?u.230007
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atBot
Theorem: measurable_coe_nnreal_real_iff
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simpa only [Real.toNNReal_coe] using h.real_toNNReal
state_before: α : Type u_1
β : Type ?u.2693810
γ : Type ?u.2693813
γ₂ : Type ?u.2693816
δ : Type ?u.2693819
ι : Sort y
s t u : Set α
inst✝ : MeasurableSpace α
f : α → ℝ≥0
h : Measurable fun x => ↑(f x)
⊢ Measurable f
Theorem: Nat.Primrec'.prim_iff₁
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: f : ℕ → ℕ
h : Primrec fun v => f (Vector.head v)
v : ℕ
⊢ f (Vector.head (ofFn fun i => id v)) = f v
Theorem: norm_mk_lt'
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: obtain ⟨n : M, hn : mk' S n = mk' S m, hn' : ‖n‖ < ‖mk' S m‖ + ε⟩ :=
  norm_mk_lt (QuotientAddGroup.mk' S m) hε
state_before: M : Type u_1
N : Type ?u.220188
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
⊢ ∃ s, s ∈ S ∧ ‖m + s‖ < ‖↑(mk' S) m‖ + ε

tactic: erw [eq_comm, QuotientAddGroup.eq] at hn
state_before: case intro.intro
M : Type u_1
N : Type ?u.220188
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : ↑(mk' S) n = ↑(mk' S) m
hn' : ‖n‖ < ‖↑(mk' S) m‖ + ε
⊢ ∃ s, s ∈ S ∧ ‖m + s‖ < ‖↑(mk' S) m‖ + ε

tactic: use -m + n, hn
state_before: case intro.intro
M : Type u_1
N : Type ?u.220188
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖↑(mk' S) m‖ + ε
⊢ ∃ s, s ∈ S ∧ ‖m + s‖ < ‖↑(mk' S) m‖ + ε

tactic: rwa [add_neg_cancel_left]
state_before: case intro.intro
M : Type u_1
N : Type ?u.220188
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖↑(mk' S) m‖ + ε
⊢ ‖m + (-m + n)‖ < ‖↑(mk' S) m‖ + ε
Theorem: Vector.get_mem
File: Mathlib/Data/Vector/Mem.lean

tactic: rw [get_eq_get]
state_before: α : Type u_1
β : Type ?u.17
n : ℕ
a a' : α
i : Fin n
v : Vector α n
⊢ get v i ∈ toList v

tactic: exact List.get_mem _ _ _
state_before: α : Type u_1
β : Type ?u.17
n : ℕ
a a' : α
i : Fin n
v : Vector α n
⊢ List.get (toList v) (↑(Fin.cast (_ : n = List.length (toList v))) i) ∈ toList v
Theorem: EuclideanGeometry.eq_of_dist_eq_of_dist_eq_of_finrank_eq_two
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: rw [direction_top, finrank_top]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ V = 2
c₁ c₂ p₁ p₂ p : P
r₁ r₂ : ℝ
hc : c₁ ≠ c₂
hp : p₁ ≠ p₂
hp₁c₁ : dist p₁ c₁ = r₁
hp₂c₁ : dist p₂ c₁ = r₁
hpc₁ : dist p c₁ = r₁
hp₁c₂ : dist p₁ c₂ = r₂
hp₂c₂ : dist p₂ c₂ = r₂
hpc₂ : dist p c₂ = r₂
⊢ finrank ℝ { x // x ∈ direction ⊤ } = 2

tactic: exact hd
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ V = 2
c₁ c₂ p₁ p₂ p : P
r₁ r₂ : ℝ
hc : c₁ ≠ c₂
hp : p₁ ≠ p₂
hp₁c₁ : dist p₁ c₁ = r₁
hp₂c₁ : dist p₂ c₁ = r₁
hpc₁ : dist p c₁ = r₁
hp₁c₂ : dist p₁ c₂ = r₂
hp₂c₂ : dist p₂ c₂ = r₂
hpc₂ : dist p c₂ = r₂
⊢ finrank ℝ V = 2
Theorem: Nat.eq_zero_of_gcd_eq_zero_right
File: Std/Data/Nat/Gcd.lean

tactic: rw [gcd_comm] at H
state_before: m n : Nat
H : gcd m n = 0
⊢ n = 0

tactic: exact eq_zero_of_gcd_eq_zero_left H
state_before: m n : Nat
H : gcd n m = 0
⊢ n = 0
Theorem: Complex.arg_lt_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [(arg_le_pi z).lt_iff_ne, not_iff_comm, not_or, not_le, Classical.not_not, arg_eq_pi_iff]
state_before: z : ℂ
⊢ arg z < π ↔ 0 ≤ z.re ∨ z.im ≠ 0
Theorem: AlgEquiv.toLinearEquiv_ofLinearEquiv
File: Mathlib/Algebra/Algebra/Equiv.lean

tactic: ext
state_before: R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_mul : ∀ (x y : A₁), ↑l (x * y) = ↑l x * ↑l y
commutes : ∀ (r : R), ↑l (↑(algebraMap R A₁) r) = ↑(algebraMap R A₂) r
⊢ toLinearEquiv (ofLinearEquiv l map_mul commutes) = l

tactic: rfl
state_before: case h
R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_mul : ∀ (x y : A₁), ↑l (x * y) = ↑l x * ↑l y
commutes : ∀ (r : R), ↑l (↑(algebraMap R A₁) r) = ↑(algebraMap R A₂) r
x✝ : A₁
⊢ ↑(toLinearEquiv (ofLinearEquiv l map_mul commutes)) x✝ = ↑l x✝
Theorem: Polynomial.nat_cast_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [← C_eq_nat_cast, C_comp]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ comp (↑n) p = ↑n
Theorem: Rat.mul_den
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [mul_def, normalize_eq]
state_before: q₁ q₂ : ℚ
⊢ (q₁ * q₂).den = q₁.den * q₂.den / Nat.gcd (Int.natAbs (q₁.num * q₂.num)) (q₁.den * q₂.den)