tasksource/leandojo huggingface dataset:
Theorem: Primrec₂.nat_iff
File: Mathlib/Computability/Primrec.lean

tactic: have :
  ∀ (a : Option α) (b : Option β),
    Option.map (fun p : α × β => f p.1 p.2)
        (Option.bind a fun a : α => Option.map (Prod.mk a) b) =
      Option.bind a fun a => Option.map (f a) b := fun a b => by
        cases a <;> cases b <;> rfl
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
⊢ Primrec₂ f ↔
    Nat.Primrec (Nat.unpaired fun m n => encode (Option.bind (decode m) fun a => Option.map (f a) (decode n)))

tactic: simp [Primrec₂, Primrec, this]
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
this :
  ∀ (a : Option α) (b : Option β),
    Option.map (fun p => f p.fst p.snd) (Option.bind a fun a => Option.map (Prod.mk a) b) =
      Option.bind a fun a => Option.map (f a) b
⊢ Primrec₂ f ↔
    Nat.Primrec (Nat.unpaired fun m n => encode (Option.bind (decode m) fun a => Option.map (f a) (decode n)))

tactic: cases a <;> cases b <;> rfl
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
a : Option α
b : Option β
⊢ Option.map (fun p => f p.fst p.snd) (Option.bind a fun a => Option.map (Prod.mk a) b) =
    Option.bind a fun a => Option.map (f a) b
Theorem: ProbabilityTheory.iIndepSet.indep_generateFrom_le
File: Mathlib/Probability/Independence/Basic.lean

tactic: convert iIndepSet.indep_generateFrom_of_disjoint hsm hs {k} { j | j ≤ i }
    (Set.disjoint_singleton_left.mpr hk.not_le)
state_before: Ω : Type u_2
ι : Type u_1
m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝¹ : LinearOrder ι
inst✝ : IsProbabilityMeasure μ
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s
i k : ι
hk : i < k
⊢ Indep (generateFrom {s k}) (generateFrom {t | ∃ j, j ≤ i ∧ s j = t})

tactic: simp only [Set.mem_singleton_iff, exists_prop, exists_eq_left, Set.setOf_eq_eq_singleton']
state_before: case h.e'_2.h.e'_2
Ω : Type u_2
ι : Type u_1
m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝¹ : LinearOrder ι
inst✝ : IsProbabilityMeasure μ
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s
i k : ι
hk : i < k
⊢ {s k} = {t | ∃ n, n ∈ {k} ∧ s n = t}
Theorem: UniformCauchySeqOn.mono
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [uniformCauchySeqOn_iff_uniformCauchySeqOnFilter] at hf⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s'✝ : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
s' : Set α
hf : UniformCauchySeqOn F p s
hss' : s' ⊆ s
⊢ UniformCauchySeqOn F p s'

tactic: exact hf.mono_right (le_principal_iff.mpr <| mem_principal.mpr hss')
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s'✝ : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
s' : Set α
hf : UniformCauchySeqOnFilter F p (𝓟 s)
hss' : s' ⊆ s
⊢ UniformCauchySeqOnFilter F p (𝓟 s')
Theorem: lebesgue_number_lemma_sUnion
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [sUnion_eq_iUnion] at hc₂
state_before: α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.183504
α : Type u
inst✝ : UniformSpace α
s : Set α
c : Set (Set α)
hs : IsCompact s
hc₁ : ∀ (t : Set α), t ∈ c → IsOpen t
hc₂ : s ⊆ ⋃₀ c
⊢ ∃ n, n ∈ 𝓤 α ∧ ∀ (x : α), x ∈ s → ∃ t, t ∈ c ∧ ∀ (y : α), (x, y) ∈ n → y ∈ t

tactic: simpa using lebesgue_number_lemma hs (by simpa) hc₂
state_before: α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.183504
α : Type u
inst✝ : UniformSpace α
s : Set α
c : Set (Set α)
hs : IsCompact s
hc₁ : ∀ (t : Set α), t ∈ c → IsOpen t
hc₂ : s ⊆ ⋃ (i : ↑c), ↑i
⊢ ∃ n, n ∈ 𝓤 α ∧ ∀ (x : α), x ∈ s → ∃ t, t ∈ c ∧ ∀ (y : α), (x, y) ∈ n → y ∈ t

tactic: simpa
state_before: α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.183504
α : Type u
inst✝ : UniformSpace α
s : Set α
c : Set (Set α)
hs : IsCompact s
hc₁ : ∀ (t : Set α), t ∈ c → IsOpen t
hc₂ : s ⊆ ⋃ (i : ↑c), ↑i
⊢ ∀ (i : ↑c), IsOpen ↑i
Theorem: LocalizedModule.mul_smul'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: induction' x using Localization.induction_on with data
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : Localization S
m : LocalizedModule S M
⊢ (x * y) • m = x • y • m

tactic: induction' y using Localization.induction_on with data'
state_before: case H
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
y : Localization S
m : LocalizedModule S M
data : R × { x // x ∈ S }
⊢ (Localization.mk data.fst data.snd * y) • m = Localization.mk data.fst data.snd • y • m

tactic: rcases data, data' with ⟨⟨r, s⟩, ⟨r', s'⟩⟩
state_before: case H.H
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : LocalizedModule S M
data data' : R × { x // x ∈ S }
⊢ (Localization.mk data.fst data.snd * Localization.mk data'.fst data'.snd) • m =
    Localization.mk data.fst data.snd • Localization.mk data'.fst data'.snd • m

tactic: induction' m using LocalizedModule.induction_on with m t
state_before: case H.H.mk.mk
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : LocalizedModule S M
r : R
s : { x // x ∈ S }
r' : R
s' : { x // x ∈ S }
⊢ (Localization.mk (r, s).fst (r, s).snd * Localization.mk (r', s').fst (r', s').snd) • m =
    Localization.mk (r, s).fst (r, s).snd • Localization.mk (r', s').fst (r', s').snd • m

tactic: rw [Localization.mk_mul, mk_smul_mk, mk_smul_mk, mk_smul_mk, mul_smul, mul_assoc]
state_before: case H.H.mk.mk.h
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r : R
s : { x // x ∈ S }
r' : R
s' : { x // x ∈ S }
m : M
t : { x // x ∈ S }
⊢ (Localization.mk (r, s).fst (r, s).snd * Localization.mk (r', s').fst (r', s').snd) • mk m t =
    Localization.mk (r, s).fst (r, s).snd • Localization.mk (r', s').fst (r', s').snd • mk m t
Theorem: Monoid.not_isTorsion_iff
File: Mathlib/GroupTheory/Torsion.lean

tactic: rw [IsTorsion, not_forall]
state_before: G : Type u_1
H : Type ?u.104
inst✝ : Monoid G
⊢ ¬IsTorsion G ↔ ∃ g, ¬IsOfFinOrder g
Theorem: NNReal.coe_eq_one
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [← NNReal.coe_one, NNReal.coe_eq]
state_before: r : ℝ≥0
⊢ ↑r = 1 ↔ r = 1
Theorem: FixedPoints.minpoly.monic
File: Mathlib/FieldTheory/Fixed.lean

tactic: simp only [minpoly, Polynomial.monic_toSubring]
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
⊢ Polynomial.Monic (minpoly G F x)

tactic: exact prodXSubSmul.monic G F x
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
⊢ Polynomial.Monic (prodXSubSmul G F x)
Theorem: IsOpen.analyticSet_image
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: rw [image_eq_range]
state_before: α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.1515
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
s : Set β
hs : IsOpen s
f : β → α
f_cont : Continuous f
⊢ AnalyticSet (f '' s)

tactic: haveI : PolishSpace s := hs.polishSpace
state_before: α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.1515
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
s : Set β
hs : IsOpen s
f : β → α
f_cont : Continuous f
⊢ AnalyticSet (range fun x => f ↑x)

tactic: exact analyticSet_range_of_polishSpace (f_cont.comp continuous_subtype_val)
state_before: α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.1515
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
s : Set β
hs : IsOpen s
f : β → α
f_cont : Continuous f
this : PolishSpace ↑s
⊢ AnalyticSet (range fun x => f ↑x)
Theorem: Matrix.IsDiag.sub
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

tactic: intro i j h
state_before: α : Type u_1
β : Type ?u.6998
R : Type ?u.7001
n : Type u_2
m : Type ?u.7007
inst✝ : AddGroup α
A B : Matrix n n α
ha : IsDiag A
hb : IsDiag B
⊢ IsDiag (A - B)

tactic: simp [ha h, hb h]
state_before: α : Type u_1
β : Type ?u.6998
R : Type ?u.7001
n : Type u_2
m : Type ?u.7007
inst✝ : AddGroup α
A B : Matrix n n α
ha : IsDiag A
hb : IsDiag B
i j : n
h : i ≠ j
⊢ (A - B) i j = 0
Theorem: CauSeq.inf_limZero
File: Mathlib/Data/Real/CauSeq.lean

tactic: let ⟨H₁, H₂⟩ := H _ ij
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g : CauSeq α abs
hf : LimZero f
hg : LimZero g
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abs (↑f j) < ε ∧ abs (↑g j) < ε
j : ℕ
ij : j ≥ i
⊢ abs (↑(f ⊓ g) j) < ε

tactic: rw [abs_lt] at H₁ H₂⊢
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g : CauSeq α abs
hf : LimZero f
hg : LimZero g
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abs (↑f j) < ε ∧ abs (↑g j) < ε
j : ℕ
ij : j ≥ i
H₁ : abs (↑f j) < ε
H₂ : abs (↑g j) < ε
⊢ abs (↑(f ⊓ g) j) < ε

tactic: exact ⟨lt_inf_iff.mpr ⟨H₁.1, H₂.1⟩, inf_lt_iff.mpr (Or.inl H₁.2)⟩
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g : CauSeq α abs
hf : LimZero f
hg : LimZero g
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abs (↑f j) < ε ∧ abs (↑g j) < ε
j : ℕ
ij : j ≥ i
H₁ : -ε < ↑f j ∧ ↑f j < ε
H₂ : -ε < ↑g j ∧ ↑g j < ε
⊢ -ε < ↑(f ⊓ g) j ∧ ↑(f ⊓ g) j < ε
Theorem: Complex.cpow_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp [cpow_def]
state_before: x : ℂ
⊢ x ^ 0 = 1
Theorem: Real.Angle.ne_neg_self_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← not_or, ← eq_neg_self_iff.not]
state_before: θ : Angle
⊢ θ ≠ -θ ↔ θ ≠ 0 ∧ θ ≠ ↑π
Theorem: Primrec.list_tail
File: Mathlib/Computability/Primrec.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
β : Type ?u.250075
γ : Type ?u.250078
σ : Type ?u.250081
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List α
⊢ (List.casesOn (id l) [] fun b l_1 => (l, b, l_1).snd.snd) = List.tail l
Theorem: Int.neg_of_neg_pos
File: Std/Data/Int/Lemmas.lean

tactic: rwa [Int.neg_zero]
state_before: a : Int
h : 0 < -a
⊢ -0 < -a
Theorem: MvPolynomial.bind₂_comp_bind₂
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: ext : 2 <;> simp
state_before: σ : Type u_3
τ : Type ?u.435135
R : Type u_1
S : Type u_2
T : Type u_4
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* MvPolynomial σ T
⊢ RingHom.comp (bind₂ g) (bind₂ f) = bind₂ (RingHom.comp (bind₂ g) f)
Theorem: affineCombination_eq_centerMass
File: Mathlib/Analysis/Convex/Combination.lean

tactic: rw [affineCombination_eq_weightedVSubOfPoint_vadd_of_sum_eq_one _ w _ hw₂ (0 : E),
  Finset.weightedVSubOfPoint_apply, vadd_eq_add, add_zero, t.centerMass_eq_of_sum_1 _ hw₂]
state_before: R : Type u_2
E : Type u_3
F : Type ?u.126038
ι✝ : Type ?u.126041
ι' : Type ?u.126044
α : Type ?u.126047
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι✝
c : R
t✝ : Finset ι✝
w✝ : ι✝ → R
z : ι✝ → E
ι : Type u_1
t : Finset ι
p : ι → E
w : ι → R
hw₂ : ∑ i in t, w i = 1
⊢ ↑(affineCombination R t p) w = centerMass t w p

tactic: simp_rw [vsub_eq_sub, sub_zero]
state_before: R : Type u_2
E : Type u_3
F : Type ?u.126038
ι✝ : Type ?u.126041
ι' : Type ?u.126044
α : Type ?u.126047
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι✝
c : R
t✝ : Finset ι✝
w✝ : ι✝ → R
z : ι✝ → E
ι : Type u_1
t : Finset ι
p : ι → E
w : ι → R
hw₂ : ∑ i in t, w i = 1
⊢ ∑ i in t, w i • (p i -ᵥ 0) = ∑ i in t, w i • p i
Theorem: Computable.cond
File: Mathlib/Computability/Partrec.lean

tactic: cases c a <;> rfl
state_before: α : Type u_1
β : Type ?u.182461
γ : Type ?u.182464
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
c : α → Bool
f g : α → σ
hc : Computable c
hf : Computable f
hg : Computable g
a : α
⊢ (Nat.casesOn (encode (c a)) (g a) fun b => f (a, b).fst) = bif c a then f a else g a
Theorem: Stream'.nth_interleave_left
File: Mathlib/Data/Stream/Init.lean

tactic: change nth (s₁ ⋈ s₂) (succ (succ (2 * n))) = nth s₁ (succ n)
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s₁ s₂ : Stream' α
⊢ nth (s₁ ⋈ s₂) (2 * (n + 1)) = nth s₁ (n + 1)

tactic: rw [nth_succ, nth_succ, interleave_eq, tail_cons, tail_cons]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s₁ s₂ : Stream' α
⊢ nth (s₁ ⋈ s₂) (succ (succ (2 * n))) = nth s₁ (succ n)

tactic: have : n < succ n := Nat.lt_succ_self n
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s₁ s₂ : Stream' α
⊢ nth (tail s₁ ⋈ tail s₂) (2 * n) = nth s₁ (succ n)

tactic: rw [nth_interleave_left n (tail s₁) (tail s₂)]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s₁ s₂ : Stream' α
this : n < succ n
⊢ nth (tail s₁ ⋈ tail s₂) (2 * n) = nth s₁ (succ n)

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s₁ s₂ : Stream' α
this : n < succ n
⊢ nth (tail s₁) n = nth s₁ (succ n)
Theorem: Std.TransCmp.gt_trans
File: Std/Classes/Order.lean

tactic: rw [cmp_eq_gt] at h₁ h₂ ⊢
state_before: cmp✝ : ?m.2531 → ?m.2531 → Ordering
inst✝¹ : TransCmp cmp✝
x✝ : Sort ?u.2529
cmp : x✝ → x✝ → Ordering
inst✝ : TransCmp cmp
x y z : x✝
h₁ : cmp x y = Ordering.gt
h₂ : cmp y z = Ordering.gt
⊢ cmp x z = Ordering.gt

tactic: exact lt_trans h₂ h₁
state_before: cmp✝ : ?m.2531 → ?m.2531 → Ordering
inst✝¹ : TransCmp cmp✝
x✝ : Sort ?u.2529
cmp : x✝ → x✝ → Ordering
inst✝ : TransCmp cmp
x y z : x✝
h₁ : cmp y x = Ordering.lt
h₂ : cmp z y = Ordering.lt
⊢ cmp z x = Ordering.lt
Theorem: Cardinal.toNat_lt_iff_lt_of_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← natCast_lt, cast_toNat_of_lt_aleph0 hc, cast_toNat_of_lt_aleph0 hd]
state_before: α β : Type u
c d : Cardinal
hc : c < ℵ₀
hd : d < ℵ₀
⊢ ↑toNat c < ↑toNat d ↔ c < d
Theorem: Associates.mk_le_mk_of_dvd
File: Mathlib/Algebra/Associated.lean

tactic: simp [hc]
state_before: α : Type u_1
β : Type ?u.307911
γ : Type ?u.307914
δ : Type ?u.307917
inst✝ : CommMonoid α
a b : α
x✝ : a ∣ b
c : α
hc : b = a * c
⊢ Associates.mk b = Associates.mk a * Associates.mk c

tactic: rfl
state_before: α : Type u_1
β : Type ?u.307911
γ : Type ?u.307914
δ : Type ?u.307917
inst✝ : CommMonoid α
a b : α
x✝ : a ∣ b
c : α
hc : b = a * c
⊢ Associates.mk (a * c) = Associates.mk a * Associates.mk c
Theorem: List.Perm.insert
File: Mathlib/Data/List/Perm.lean

tactic: simpa [h, p.subset h] using p
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h : a ∈ l₁
⊢ List.insert a l₁ ~ List.insert a l₂

tactic: simpa [h, mt p.mem_iff.2 h] using p.cons a
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h : ¬a ∈ l₁
⊢ List.insert a l₁ ~ List.insert a l₂
Theorem: PGame.neg_fuzzy_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [Fuzzy, Fuzzy, neg_lf_neg_iff, neg_lf_neg_iff, and_comm]
state_before: x y : PGame
⊢ -x ‖ -y ↔ x ‖ y
Theorem: Irrational.of_rat_sub
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa only [sub_eq_add_neg] using h
state_before: q : ℚ
x y : ℝ
h : Irrational (↑q - x)
⊢ Irrational (↑q + -x)
Theorem: Matrix.Represents.smul
File: Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean

tactic: delta Matrix.Represents at h ⊢
state_before: ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_3
inst✝³ : AddCommGroup M
R : Type u_2
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
b : ι → M
hb : Submodule.span R (Set.range b) = ⊤
inst✝ : DecidableEq ι
A : Matrix ι ι R
f : Module.End R M
h : Represents b A f
r : R
⊢ Represents b (r • A) (r • f)

tactic: rw [SMulHomClass.map_smul, SMulHomClass.map_smul, h]
state_before: ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_3
inst✝³ : AddCommGroup M
R : Type u_2
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
b : ι → M
hb : Submodule.span R (Set.range b) = ⊤
inst✝ : DecidableEq ι
A : Matrix ι ι R
f : Module.End R M
h : ↑(PiToModule.fromMatrix R b) A = ↑(PiToModule.fromEnd R b) f
r : R
⊢ ↑(PiToModule.fromMatrix R b) (r • A) = ↑(PiToModule.fromEnd R b) (r • f)
Theorem: taylor_within_apply
File: Mathlib/Analysis/Calculus/Taylor.lean

tactic: induction' n with k hk
state_before: 𝕜 : Type ?u.230356
E : Type u_1
F : Type ?u.230362
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ x : ℝ
⊢ taylorWithinEval f n s x₀ x = ∑ k in Finset.range (n + 1), ((↑k !)⁻¹ * (x - x₀) ^ k) • iteratedDerivWithin k f s x₀

tactic: rw [taylorWithinEval_succ, Finset.sum_range_succ, hk]
state_before: case succ
𝕜 : Type ?u.230356
E : Type u_1
F : Type ?u.230362
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
k : ℕ
hk : taylorWithinEval f k s x₀ x = ∑ k in Finset.range (k + 1), ((↑k !)⁻¹ * (x - x₀) ^ k) • iteratedDerivWithin k f s x₀
⊢ taylorWithinEval f (Nat.succ k) s x₀ x =
    ∑ k in Finset.range (Nat.succ k + 1), ((↑k !)⁻¹ * (x - x₀) ^ k) • iteratedDerivWithin k f s x₀

tactic: simp
state_before: case succ
𝕜 : Type ?u.230356
E : Type u_1
F : Type ?u.230362
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
k : ℕ
hk : taylorWithinEval f k s x₀ x = ∑ k in Finset.range (k + 1), ((↑k !)⁻¹ * (x - x₀) ^ k) • iteratedDerivWithin k f s x₀
⊢ ∑ k in Finset.range (k + 1), ((↑k !)⁻¹ * (x - x₀) ^ k) • iteratedDerivWithin k f s x₀ +
      (((↑k + 1) * ↑k !)⁻¹ * (x - x₀) ^ (k + 1)) • iteratedDerivWithin (k + 1) f s x₀ =
    ∑ x_1 in Finset.range (k + 1), ((↑x_1 !)⁻¹ * (x - x₀) ^ x_1) • iteratedDerivWithin x_1 f s x₀ +
      ((↑(k + 1)!)⁻¹ * (x - x₀) ^ (k + 1)) • iteratedDerivWithin (k + 1) f s x₀

tactic: simp
state_before: case zero
𝕜 : Type ?u.230356
E : Type u_1
F : Type ?u.230362
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ taylorWithinEval f Nat.zero s x₀ x =
    ∑ k in Finset.range (Nat.zero + 1), ((↑k !)⁻¹ * (x - x₀) ^ k) • iteratedDerivWithin k f s x₀
Theorem: Nat.lt_add_of_pos_left
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.add_comm]
state_before: n k : Nat
h : 0 < k
⊢ n < k + n

tactic: exact Nat.lt_add_of_pos_right h
state_before: n k : Nat
h : 0 < k
⊢ n < n + k
Theorem: IsUnit.mul_liftRight_inv
File: Mathlib/Algebra/Hom/Units.lean

tactic: intro
state_before: F : Type ?u.42331
G : Type ?u.42334
α : Type ?u.42337
M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (↑f x)
x : M
⊢ ∀ (x : M), ↑(IsUnit.unit (_ : IsUnit (↑f x))) = ↑f x

tactic: rfl
state_before: F : Type ?u.42331
G : Type ?u.42334
α : Type ?u.42337
M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (↑f x)
x x✝ : M
⊢ ↑(IsUnit.unit (_ : IsUnit (↑f x✝))) = ↑f x✝
Theorem: zpow_one
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: convert pow_one a using 1
state_before: α : Type ?u.54010
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivInvMonoid G
a : G
⊢ a ^ 1 = a

tactic: exact zpow_ofNat a 1
state_before: case h.e'_2
α : Type ?u.54010
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivInvMonoid G
a : G
⊢ a ^ 1 = a ^ 1
Theorem: Multiset.coe_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: rw [List.bind, ← coe_join, List.map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9950
δ : Type ?u.9953
a : α
s t : Multiset α
f✝ g : α → Multiset β
l : List α
f : α → List β
⊢ (bind ↑l fun a => ↑(f a)) = ↑(List.bind l f)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9950
δ : Type ?u.9953
a : α
s t : Multiset α
f✝ g : α → Multiset β
l : List α
f : α → List β
⊢ (bind ↑l fun a => ↑(f a)) = join ↑(List.map (ofList ∘ f) l)
Theorem: LinearMap.mulRight_one
File: Mathlib/Algebra/Algebra/Bilinear.lean

tactic: ext
state_before: R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
⊢ mulRight R 1 = id

tactic: simp only [LinearMap.id_coe, mul_one, id.def, mulRight_apply]
state_before: case h
R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x✝ : A
⊢ ↑(mulRight R 1) x✝ = ↑id x✝
Theorem: WithTop.top_mul'
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: induction a using recTopCoe <;> simp [mul_def] <;> rfl
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Zero α
inst✝ : Mul α
a : WithTop α
⊢ ⊤ * a = if a = 0 then 0 else ⊤
Theorem: commutatorElement_inv
File: Mathlib/GroupTheory/Commutator.lean

tactic: simp_rw [commutatorElement_def, mul_inv_rev, inv_inv, mul_assoc]
state_before: G : Type u_1
G' : Type ?u.10728
F : Type ?u.10731
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f : F
g₁ g₂ g₃ g : G
⊢ ⁅g₁, g₂⁆⁻¹ = ⁅g₂, g₁⁆
Theorem: LocalHomeomorph.map_extend_nhdsWithin_eq_image
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: set e := f.extend I
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.150056
M' : Type ?u.150059
H' : Type ?u.150062
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
y : M
hy : y ∈ f.source
⊢ map (↑(extend f I)) (𝓝[s] y) = 𝓝[↑(extend f I) '' ((extend f I).source ∩ s)] ↑(extend f I) y

tactic: calc
  map e (𝓝[s] y) = map e (𝓝[e.source ∩ s] y) :=
    congr_arg (map e) (nhdsWithin_inter_of_mem (extend_source_mem_nhdsWithin f I hy)).symm
  _ = 𝓝[e '' (e.source ∩ s)] e y :=
    ((f.extend I).leftInvOn.mono <| inter_subset_left _ _).map_nhdsWithin_eq
      ((f.extend I).left_inv <| by rwa [f.extend_source])
      (continuousAt_extend_symm f I hy).continuousWithinAt
      (continuousAt_extend f I hy).continuousWithinAt
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.150056
M' : Type ?u.150059
H' : Type ?u.150062
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
y : M
hy : y ∈ f.source
e : LocalEquiv M E := extend f I
⊢ map (↑e) (𝓝[s] y) = 𝓝[↑e '' (e.source ∩ s)] ↑e y

tactic: rwa [f.extend_source]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.150056
M' : Type ?u.150059
H' : Type ?u.150062
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
y : M
hy : y ∈ f.source
e : LocalEquiv M E := extend f I
⊢ y ∈ (extend f I).source