tasksource/leandojo huggingface dataset:
Theorem: Basis.det_ne_zero
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: simpa [h] using e.det_self
state_before: R : Type u_1
inst✝⁷ : CommRing R
M : Type u_2
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type ?u.2545400
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι : Type u_3
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
e : Basis ι R M
inst✝ : Nontrivial R
h : det e = 0
⊢ False
Theorem: MeasureTheory.withDensity_absolutelyContinuous
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: refine' AbsolutelyContinuous.mk fun s hs₁ hs₂ => _
state_before: α : Type u_1
β : Type ?u.1763263
γ : Type ?u.1763266
δ : Type ?u.1763269
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
⊢ withDensity μ f ≪ μ

tactic: rw [withDensity_apply _ hs₁]
state_before: α : Type u_1
β : Type ?u.1763263
γ : Type ?u.1763266
δ : Type ?u.1763269
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hs₁ : MeasurableSet s
hs₂ : ↑↑μ s = 0
⊢ ↑↑(withDensity μ f) s = 0

tactic: exact set_lintegral_measure_zero _ _ hs₂
state_before: α : Type u_1
β : Type ?u.1763263
γ : Type ?u.1763266
δ : Type ?u.1763269
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hs₁ : MeasurableSet s
hs₂ : ↑↑μ s = 0
⊢ (∫⁻ (a : α) in s, f a ∂μ) = 0
Theorem: PrimeMultiset.prod_dvd_iff'
File: Mathlib/Data/PNat/Factors.lean

tactic: let h := @prod_dvd_iff u n.factorMultiset
state_before: u : PrimeMultiset
n : ℕ+
⊢ prod u ∣ n ↔ u ≤ PNat.factorMultiset n

tactic: rw [n.prod_factorMultiset] at h
state_before: u : PrimeMultiset
n : ℕ+
h : prod u ∣ prod (PNat.factorMultiset n) ↔ u ≤ PNat.factorMultiset n := prod_dvd_iff
⊢ prod u ∣ n ↔ u ≤ PNat.factorMultiset n

tactic: exact h
state_before: u : PrimeMultiset
n : ℕ+
h : prod u ∣ n ↔ u ≤ PNat.factorMultiset n
⊢ prod u ∣ n ↔ u ≤ PNat.factorMultiset n
Theorem: Polynomial.ext_iff
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ p q : R[X]
⊢ p = q ↔ ∀ (n : ℕ), coeff p n = coeff q n

tactic: rcases q with ⟨⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q✝ q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := toFinsupp✝ } = q ↔ ∀ (n : ℕ), coeff { toFinsupp := toFinsupp✝ } n = coeff q n

tactic: simp [coeff]
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := toFinsupp✝¹ } = { toFinsupp := toFinsupp✝ } ↔
    ∀ (n : ℕ), coeff { toFinsupp := toFinsupp✝¹ } n = coeff { toFinsupp := toFinsupp✝ } n

tactic: exact FunLike.ext_iff (F := ℕ →₀ R)
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ toFinsupp✝¹ = toFinsupp✝ ↔ ∀ (n : ℕ), ↑toFinsupp✝¹ n = ↑toFinsupp✝ n
Theorem: ProbabilityTheory.indepSet_iff_indepSets_singleton
File: Mathlib/Probability/Independence/Basic.lean

tactic: rwa [Set.mem_singleton_iff.mp hu]
state_before: Ω : Type u_1
ι : Type ?u.2709210
s t : Set Ω
S T : Set (Set Ω)
m0 : MeasurableSpace Ω
hs_meas : MeasurableSet s
ht_meas : MeasurableSet t
μ : autoParam (MeasureTheory.Measure Ω) _auto✝
inst✝ : IsProbabilityMeasure μ
h : IndepSets {s} {t}
u : Set Ω
hu : u ∈ {s}
⊢ MeasurableSet u

tactic: rwa [Set.mem_singleton_iff.mp hu]
state_before: Ω : Type u_1
ι : Type ?u.2709210
s t : Set Ω
S T : Set (Set Ω)
m0 : MeasurableSpace Ω
hs_meas : MeasurableSet s
ht_meas : MeasurableSet t
μ : autoParam (MeasureTheory.Measure Ω) _auto✝
inst✝ : IsProbabilityMeasure μ
h : IndepSets {s} {t}
u : Set Ω
hu : u ∈ {t}
⊢ MeasurableSet u
Theorem: Finset.erase_injOn'
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← insert_erase hs, ← insert_erase ht, h]
state_before: α : Type u_1
β : Type ?u.220219
γ : Type ?u.220222
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b a : α
s : Finset α
hs : s ∈ {s | a ∈ s}
t : Finset α
ht : t ∈ {s | a ∈ s}
h : erase s a = (fun s => erase s a) t
⊢ s = t
Theorem: Complex.sin_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [two_mul, sin_add]
state_before: ⊢ sin (2 * ↑π) = 0
Theorem: Real.rpow_sub_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simpa using rpow_sub_nat hx y 1
state_before: x✝ y✝ z x : ℝ
hx : x ≠ 0
y : ℝ
⊢ x ^ (y - 1) = x ^ y / x
Theorem: Multiset.bind_map_comm
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.42344
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : Multiset β
f : α → β → γ
⊢ (bind 0 fun a => map (fun b => f a b) n) = bind n fun b => map (fun a => f a b) 0

tactic: simp (config := { contextual := true })
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.42344
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : Multiset β
f : α → β → γ
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    ((bind s fun a => map (fun b => f a b) n) = bind n fun b => map (fun a => f a b) s) →
      (bind (a ::ₘ s) fun a => map (fun b => f a b) n) = bind n fun b => map (fun a => f a b) (a ::ₘ s)
Theorem: FreeProduct.empty_of_word_prod_eq_one
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: by_contra hnotempty
state_before: ι : Type u_1
M : ι → Type ?u.898798
inst✝⁴ : (i : ι) → Monoid (M i)
N : Type ?u.898809
inst✝³ : Monoid N
hnontriv : Nontrivial ι
G : Type u_3
inst✝² : Group G
H : ι → Type u_2
inst✝¹ : (i : ι) → Group (H i)
f : (i : ι) → H i →* G
hcard : 3 ≤ (#ι) ∨ ∃ i, 3 ≤ (#H i)
α : Type ?u.899590
inst✝ : MulAction G α
X : ι → Set α
hXnonempty : ∀ (i : ι), Set.Nonempty (X i)
hXdisj : Pairwise fun i j => Disjoint (X i) (X j)
hpp : Pairwise fun i j => ∀ (h : H i), h ≠ 1 → ↑(f i) h • X j ⊆ X i
w : Word H
h : ↑(↑lift f) (Word.prod w) = 1
⊢ w = Word.empty

tactic: obtain ⟨i, j, w, rfl⟩ := NeWord.of_word w hnotempty
state_before: ι : Type u_1
M : ι → Type ?u.898798
inst✝⁴ : (i : ι) → Monoid (M i)
N : Type ?u.898809
inst✝³ : Monoid N
hnontriv : Nontrivial ι
G : Type u_3
inst✝² : Group G
H : ι → Type u_2
inst✝¹ : (i : ι) → Group (H i)
f : (i : ι) → H i →* G
hcard : 3 ≤ (#ι) ∨ ∃ i, 3 ≤ (#H i)
α : Type ?u.899590
inst✝ : MulAction G α
X : ι → Set α
hXnonempty : ∀ (i : ι), Set.Nonempty (X i)
hXdisj : Pairwise fun i j => Disjoint (X i) (X j)
hpp : Pairwise fun i j => ∀ (h : H i), h ≠ 1 → ↑(f i) h • X j ⊆ X i
w : Word H
h : ↑(↑lift f) (Word.prod w) = 1
hnotempty : ¬w = Word.empty
⊢ False

tactic: exact lift_word_prod_nontrivial_of_not_empty f hcard X hXnonempty hXdisj hpp w h
state_before: case intro.intro.intro
ι : Type u_1
M : ι → Type ?u.898798
inst✝⁴ : (i : ι) → Monoid (M i)
N : Type ?u.898809
inst✝³ : Monoid N
hnontriv : Nontrivial ι
G : Type u_3
inst✝² : Group G
H : ι → Type u_2
inst✝¹ : (i : ι) → Group (H i)
f : (i : ι) → H i →* G
hcard : 3 ≤ (#ι) ∨ ∃ i, 3 ≤ (#H i)
α : Type ?u.899590
inst✝ : MulAction G α
X : ι → Set α
hXnonempty : ∀ (i : ι), Set.Nonempty (X i)
hXdisj : Pairwise fun i j => Disjoint (X i) (X j)
hpp : Pairwise fun i j => ∀ (h : H i), h ≠ 1 → ↑(f i) h • X j ⊆ X i
i j : ι
w : NeWord H i j
h : ↑(↑lift f) (Word.prod (NeWord.toWord w)) = 1
hnotempty : ¬NeWord.toWord w = Word.empty
⊢ False
Theorem: IsSquare.map
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨m, rfl⟩
state_before: F : Type u_3
α : Type u_1
β : Type u_2
R : Type ?u.2218
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
inst✝ : MonoidHomClass F α β
m : α
f : F
⊢ IsSquare m → IsSquare (↑f m)

tactic: exact ⟨f m, by simp⟩
state_before: case intro
F : Type u_3
α : Type u_1
β : Type u_2
R : Type ?u.2218
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
inst✝ : MonoidHomClass F α β
f : F
m : α
⊢ IsSquare (↑f (m * m))

tactic: simp
state_before: F : Type u_3
α : Type u_1
β : Type u_2
R : Type ?u.2218
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
inst✝ : MonoidHomClass F α β
f : F
m : α
⊢ ↑f (m * m) = ↑f m * ↑f m
Theorem: seq_eq_bind
File: src/lean/Init/Control/Lawful.lean

tactic: rw [bind_map]
state_before: m : Type u → Type u_1
α β : Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
mf : m (α → β)
x : m α
⊢ (Seq.seq mf fun x_1 => x) = do
    let f ← mf
    f <$> x
Theorem: Complex.eq_re_ofReal_le
File: Mathlib/Data/Complex/Basic.lean

tactic: ext
state_before: r : ℝ
z : ℂ
hz : ↑r ≤ z
⊢ z = ↑z.re

tactic: rfl
state_before: case a
r : ℝ
z : ℂ
hz : ↑r ≤ z
⊢ z.re = (↑z.re).re

case a
r : ℝ
z : ℂ
hz : ↑r ≤ z
⊢ z.im = (↑z.re).im

tactic: simp only [← (Complex.le_def.1 hz).2, Complex.zero_im, Complex.ofReal_im]
state_before: case a
r : ℝ
z : ℂ
hz : ↑r ≤ z
⊢ z.im = (↑z.re).im
Theorem: Polynomial.degree_map_le
File: Mathlib/Data/Polynomial/Eval.lean

tactic: refine (degree_le_iff_coeff_zero _ _).2 fun m hm => ?_
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]
inst✝ : Semiring S
f : R →+* S
p : R[X]
⊢ degree (map f p) ≤ degree p

tactic: rw [degree_lt_iff_coeff_zero] at hm
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]
inst✝ : Semiring S
f : R →+* S
p : R[X]
m : ℕ
hm : degree p < ↑m
⊢ coeff (map f p) m = 0

tactic: simp [hm m le_rfl]
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]
inst✝ : Semiring S
f : R →+* S
p : R[X]
m : ℕ
hm : ∀ (m_1 : ℕ), m ≤ m_1 → coeff p m_1 = 0
⊢ coeff (map f p) m = 0
Theorem: openEmbedding_of_continuous_injective_open
File: Mathlib/Topology/Maps.lean

tactic: simp only [openEmbedding_iff_embedding_open, embedding_iff, inducing_iff_nhds, *, and_true_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.257906
δ : Type ?u.257909
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
h₁ : Continuous f
h₂ : Injective f
h₃ : IsOpenMap f
⊢ OpenEmbedding f

tactic: exact fun a =>
  le_antisymm (h₁.tendsto _).le_comap (@comap_map _ _ (𝓝 a) _ h₂ ▸ comap_mono (h₃.nhds_le _))
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.257906
δ : Type ?u.257909
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
h₁ : Continuous f
h₂ : Injective f
h₃ : IsOpenMap f
⊢ ∀ (a : α), 𝓝 a = comap f (𝓝 (f a))
Theorem: Complex.I_mul
File: Mathlib/Data/Complex/Basic.lean

tactic: simp
state_before: z : ℂ
⊢ (I * z).re = { re := -z.im, im := z.re }.re ∧ (I * z).im = { re := -z.im, im := z.re }.im
Theorem: Monotone.ae_differentiableAt
File: Mathlib/Analysis/Calculus/Monotone.lean

tactic: filter_upwards [hf.ae_hasDerivAt] with x hx using hx.differentiableAt
state_before: f : ℝ → ℝ
hf : Monotone f
⊢ ∀ᵐ (x : ℝ), DifferentiableAt ℝ f x
Theorem: List.ofFn_mul
File: Mathlib/Data/List/OfFn.lean

tactic: induction' m with m IH
state_before: α : Type u
m n : ℕ
f : Fin (m * n) → α
⊢ ofFn f = join (ofFn fun i => ofFn fun j => f { val := ↑i * n + ↑j, isLt := (_ : ↑i * n + ↑j < m * n) })

tactic: simp [ofFn_zero, zero_mul, ofFn_zero, join]
state_before: case zero
α : Type u
m n : ℕ
f✝ : Fin (m * n) → α
f : Fin (zero * n) → α
⊢ ofFn f = join (ofFn fun i => ofFn fun j => f { val := ↑i * n + ↑j, isLt := (_ : ↑i * n + ↑j < zero * n) })

tactic: simp_rw [ofFn_succ', succ_mul, join_concat, ofFn_add, IH]
state_before: case succ
α : Type u
m✝ n : ℕ
f✝ : Fin (m✝ * n) → α
m : ℕ
IH :
  ∀ (f : Fin (m * n) → α),
    ofFn f = join (ofFn fun i => ofFn fun j => f { val := ↑i * n + ↑j, isLt := (_ : ↑i * n + ↑j < m * n) })
f : Fin (succ m * n) → α
⊢ ofFn f = join (ofFn fun i => ofFn fun j => f { val := ↑i * n + ↑j, isLt := (_ : ↑i * n + ↑j < succ m * n) })

tactic: rfl
state_before: case succ
α : Type u
m✝ n : ℕ
f✝ : Fin (m✝ * n) → α
m : ℕ
IH :
  ∀ (f : Fin (m * n) → α),
    ofFn f = join (ofFn fun i => ofFn fun j => f { val := ↑i * n + ↑j, isLt := (_ : ↑i * n + ↑j < m * n) })
f : Fin (succ m * n) → α
⊢ (join
        (ofFn fun i =>
          ofFn fun j =>
            f
              (↑(Fin.cast (_ : m * n + n = succ m * n))
                (↑(Fin.castAdd n) { val := ↑i * n + ↑j, isLt := (_ : ↑i * n + ↑j < m * n) }))) ++
      ofFn fun j => f (↑(Fin.cast (_ : m * n + n = succ m * n)) (↑(Fin.natAdd (m * n)) j))) =
    join
        (ofFn fun i =>
          ofFn fun j =>
            f { val := ↑(↑Fin.castSucc i) * n + ↑j, isLt := (_ : ↑(↑Fin.castSucc i) * n + ↑j < succ m * n) }) ++
      ofFn fun j => f { val := ↑(Fin.last m) * n + ↑j, isLt := (_ : ↑(Fin.last m) * n + ↑j < succ m * n) }
Theorem: List.chain_range_succ
File: Mathlib/Data/List/Range.lean

tactic: rw [range_succ_eq_map, chain_cons, and_congr_right_iff, ← chain'_range_succ, range_succ_eq_map]
state_before: α : Type u
r : ℕ → ℕ → Prop
n a : ℕ
⊢ Chain r a (range (succ n)) ↔ r a 0 ∧ ∀ (m : ℕ), m < n → r m (succ m)

tactic: exact fun _ => Iff.rfl
state_before: α : Type u
r : ℕ → ℕ → Prop
n a : ℕ
⊢ r a 0 → (Chain r 0 (map succ (range n)) ↔ Chain' (fun m => r m) (0 :: map succ (range n)))
Theorem: heq_of_eqRec_eq
File: src/lean/Init/Core.lean

tactic: subst h₁
state_before: α β : Sort u
a : α
b : β
h₁ : α = β
h₂ : Eq.rec a h₁ = b
⊢ HEq a b

tactic: apply heq_of_eq
state_before: α : Sort u
a b : α
h₂ : Eq.rec a (_ : α = α) = b
⊢ HEq a b

tactic: exact h₂
state_before: case h
α : Sort u
a b : α
h₂ : Eq.rec a (_ : α = α) = b
⊢ a = b
Theorem: Nat.card_eq_two_iff
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: rw [Nat.cast_two]
state_before: α : Type u_1
β : Type ?u.9840
⊢ (#α) = ↑2 ↔ (#α) = 2
Theorem: powers.mul_mem
File: Mathlib/Deprecated/Submonoid.lean

tactic: simp only [pow_add, *]
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type ?u.21578
inst✝ : AddMonoid A
t : Set A
x y z : M
x✝¹ : y ∈ powers x
x✝ : z ∈ powers x
n₁ : ℕ
h₁ : x ^ n₁ = y
n₂ : ℕ
h₂ : x ^ n₂ = z
⊢ x ^ (n₁ + n₂) = y * z
Theorem: RingHom.not_one_mem_ker
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [mem_ker, map_one]
state_before: R : Type u
S : Type v
T : Type w
F : Type u_1
G : Type ?u.1722384
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : Semiring T
rcf : RingHomClass F R S
rcg : RingHomClass G T S
f✝ : F
g : G
inst✝ : Nontrivial S
f : F
⊢ ¬1 ∈ ker f

tactic: exact one_ne_zero
state_before: R : Type u
S : Type v
T : Type w
F : Type u_1
G : Type ?u.1722384
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : Semiring T
rcf : RingHomClass F R S
rcg : RingHomClass G T S
f✝ : F
g : G
inst✝ : Nontrivial S
f : F
⊢ ¬1 = 0
Theorem: ChainComplex.mk'_d_1_0
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: change ite (1 = 0 + 1) (𝟙 X₁ ≫ d₀) 0 = d₀
state_before: ι : Type ?u.191407
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₁ ⟶ X₀
d₁ : X₂ ⟶ X₁
s : d₁ ≫ d₀ = 0
succ :
  (t : (X₀ : V) ×' (X₁ : V) ×' (X₂ : V) ×' (d₀ : X₁ ⟶ X₀) ×' (d₁ : X₂ ⟶ X₁) ×' d₁ ≫ d₀ = 0) →
    (X₃ : V) ×' (d₂ : X₃ ⟶ t.snd.snd.fst) ×' d₂ ≫ t.snd.snd.snd.snd.fst = 0
succ' : (t : (X₀ : V) × (X₁ : V) × (X₁ ⟶ X₀)) → (X₂ : V) ×' (d : X₂ ⟶ t.snd.fst) ×' d ≫ t.snd.snd = 0
⊢ HomologicalComplex.d (mk' X₀ X₁ d₀ succ') 1 0 = d₀

tactic: rw [if_pos rfl, Category.id_comp]
state_before: ι : Type ?u.191407
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₁ ⟶ X₀
d₁ : X₂ ⟶ X₁
s : d₁ ≫ d₀ = 0
succ :
  (t : (X₀ : V) ×' (X₁ : V) ×' (X₂ : V) ×' (d₀ : X₁ ⟶ X₀) ×' (d₁ : X₂ ⟶ X₁) ×' d₁ ≫ d₀ = 0) →
    (X₃ : V) ×' (d₂ : X₃ ⟶ t.snd.snd.fst) ×' d₂ ≫ t.snd.snd.snd.snd.fst = 0
succ' : (t : (X₀ : V) × (X₁ : V) × (X₁ ⟶ X₀)) → (X₂ : V) ×' (d : X₂ ⟶ t.snd.fst) ×' d ≫ t.snd.snd = 0
⊢ (if 1 = 0 + 1 then 𝟙 X₁ ≫ d₀ else 0) = d₀
Theorem: AffineMap.lineMap_vsub_right
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: rw [← lineMap_apply_one_sub, lineMap_vsub_left]
state_before: k : Type u_3
V1 : Type u_1
P1 : Type u_2
V2 : Type ?u.559793
P2 : Type ?u.559796
V3 : Type ?u.559799
P3 : Type ?u.559802
V4 : Type ?u.559805
P4 : Type ?u.559808
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
p₀ p₁ : P1
c : k
⊢ ↑(lineMap p₀ p₁) c -ᵥ p₁ = (1 - c) • (p₀ -ᵥ p₁)
Theorem: Cardinal.derivBFamily_lt_ord_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [mk_ordinal_out]
state_before: α : Type ?u.167152
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal → Ordinal
c : Cardinal
hc : IsRegular c
hι : lift (card o) < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal) (hi : i < o) (b : Ordinal), b < ord c → f i hi b < ord c
a : Ordinal
⊢ lift (#(Quotient.out o).α) < c
Theorem: AddMonoidAlgebra.mem_span_support'
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: delta of'
state_before: k : Type u₁
G : Type u₂
inst✝ : Semiring k
f : AddMonoidAlgebra k G
⊢ f ∈ Submodule.span k (of' k G '' ↑f.support)

tactic: rw [← Finsupp.supported_eq_span_single, Finsupp.mem_supported]
state_before: k : Type u₁
G : Type u₂
inst✝ : Semiring k
f : AddMonoidAlgebra k G
⊢ f ∈ Submodule.span k ((fun a => single a 1) '' ↑f.support)
Theorem: List.card_insert_of_mem
File: Mathlib/Data/List/Card.lean

tactic: simp [h]
state_before: α : Type u_1
β : Sort ?u.25215
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as : List α
h : a ∈ as
⊢ card (List.insert a as) = card as
Theorem: WithTop.add_lt_add_right
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: lift a to α using ha
state_before: α : Type u
β : Type v
inst✝² : Add α
a b c d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
ha : a ≠ ⊤
h : b < c
⊢ b + a < c + a

tactic: rcases lt_iff_exists_coe.1 h with ⟨b, rfl, h'⟩
state_before: case intro
α : Type u
β : Type v
inst✝² : Add α
b c d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
h : b < c
a : α
⊢ b + ↑a < c + ↑a

tactic: cases c
state_before: case intro.intro.intro
α : Type u
β : Type v
inst✝² : Add α
c d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
a b : α
h' h : ↑b < c
⊢ ↑b + ↑a < c + ↑a

tactic: exact coe_lt_top _
state_before: case intro.intro.intro.none
α : Type u
β : Type v
inst✝² : Add α
d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
a b : α
h' h : ↑b < none
⊢ ↑b + ↑a < none + ↑a

tactic: exact coe_lt_coe.2 (add_lt_add_right (coe_lt_coe.1 h) _)
state_before: case intro.intro.intro.some
α : Type u
β : Type v
inst✝² : Add α
d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
a b val✝ : α
h' h : ↑b < Option.some val✝
⊢ ↑b + ↑a < Option.some val✝ + ↑a
Theorem: contDiffWithinAt_insert
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp_rw [ContDiffWithinAt]
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
y : E
⊢ ContDiffWithinAt 𝕜 n f (insert y s) x ↔ ContDiffWithinAt 𝕜 n f s x

tactic: rcases eq_or_ne x y with (rfl | h)
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
y : E
⊢ (∀ (m : ℕ), ↑m ≤ n → ∃ u, u ∈ 𝓝[insert x (insert y s)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u) ↔
    ∀ (m : ℕ), ↑m ≤ n → ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u

tactic: simp_rw [insert_comm x y, nhdsWithin_insert_of_ne h]
state_before: case inr
𝕜 : 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
y : E
h : x ≠ y
⊢ (∀ (m : ℕ), ↑m ≤ n → ∃ u, u ∈ 𝓝[insert x (insert y s)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u) ↔
    ∀ (m : ℕ), ↑m ≤ n → ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u

tactic: simp_rw [insert_eq_of_mem (mem_insert _ _)]
state_before: case inl
𝕜 : 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
⊢ (∀ (m : ℕ), ↑m ≤ n → ∃ u, u ∈ 𝓝[insert x (insert x s)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u) ↔
    ∀ (m : ℕ), ↑m ≤ n → ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u
Theorem: Polynomial.eval_C_mul
File: Mathlib/Data/Polynomial/Eval.lean

tactic: induction p using Polynomial.induction_on' with
| h_add p q ph qh =>
  simp only [mul_add, eval_add, ph, qh]
| h_monomial n b =>
  simp only [mul_assoc, C_mul_monomial, eval_monomial]
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]
x : R
⊢ eval x (↑C a * p) = a * eval x p

tactic: simp only [mul_add, eval_add, ph, qh]
state_before: case h_add
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
x : R
p q : R[X]
ph : eval x (↑C a * p) = a * eval x p
qh : eval x (↑C a * q) = a * eval x q
⊢ eval x (↑C a * (p + q)) = a * eval x (p + q)

tactic: simp only [mul_assoc, C_mul_monomial, eval_monomial]
state_before: case h_monomial
R : Type u
S : Type v
T : Type w
ι : Type y
a b✝ : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
n : ℕ
b : R
⊢ eval x (↑C a * ↑(monomial n) b) = a * eval x (↑(monomial n) b)