tasksource/leandojo huggingface dataset:
Theorem: Finsupp.toFinset_toMultiset
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: refine' f.induction _ _
state_before: α : Type u_1
β : Type ?u.51824
ι : Type ?u.51827
inst✝ : DecidableEq α
f : α →₀ ℕ
⊢ Multiset.toFinset (↑toMultiset f) = f.support

tactic: rw [toMultiset_zero, Multiset.toFinset_zero, support_zero]
state_before: case refine'_1
α : Type u_1
β : Type ?u.51824
ι : Type ?u.51827
inst✝ : DecidableEq α
f : α →₀ ℕ
⊢ Multiset.toFinset (↑toMultiset 0) = 0.support

tactic: intro a n f ha hn ih
state_before: case refine'_2
α : Type u_1
β : Type ?u.51824
ι : Type ?u.51827
inst✝ : DecidableEq α
f : α →₀ ℕ
⊢ ∀ (a : α) (b : ℕ) (f : α →₀ ℕ),
    ¬a ∈ f.support →
      b ≠ 0 →
        Multiset.toFinset (↑toMultiset f) = f.support →
          Multiset.toFinset (↑toMultiset (single a b + f)) = (single a b + f).support

tactic: rw [toMultiset_add, Multiset.toFinset_add, ih, toMultiset_single, support_add_eq,
  support_single_ne_zero _ hn, Multiset.toFinset_nsmul _ _ hn, Multiset.toFinset_singleton]
state_before: case refine'_2
α : Type u_1
β : Type ?u.51824
ι : Type ?u.51827
inst✝ : DecidableEq α
f✝ : α →₀ ℕ
a : α
n : ℕ
f : α →₀ ℕ
ha : ¬a ∈ f.support
hn : n ≠ 0
ih : Multiset.toFinset (↑toMultiset f) = f.support
⊢ Multiset.toFinset (↑toMultiset (single a n + f)) = (single a n + f).support

tactic: refine' Disjoint.mono_left support_single_subset _
state_before: case refine'_2
α : Type u_1
β : Type ?u.51824
ι : Type ?u.51827
inst✝ : DecidableEq α
f✝ : α →₀ ℕ
a : α
n : ℕ
f : α →₀ ℕ
ha : ¬a ∈ f.support
hn : n ≠ 0
ih : Multiset.toFinset (↑toMultiset f) = f.support
⊢ Disjoint (single a n).support f.support

tactic: rwa [Finset.disjoint_singleton_left]
state_before: case refine'_2
α : Type u_1
β : Type ?u.51824
ι : Type ?u.51827
inst✝ : DecidableEq α
f✝ : α →₀ ℕ
a : α
n : ℕ
f : α →₀ ℕ
ha : ¬a ∈ f.support
hn : n ≠ 0
ih : Multiset.toFinset (↑toMultiset f) = f.support
⊢ Disjoint {a} f.support
Theorem: WithBot.unbot'_bot_le_iff
File: Mathlib/Order/WithBot.lean

tactic: cases a <;> simp [none_eq_bot, some_eq_coe]
state_before: α : Type u_1
β : Type ?u.39753
γ : Type ?u.39756
δ : Type ?u.39759
a✝ b✝ : α
inst✝¹ : LE α
inst✝ : OrderBot α
a : WithBot α
b : α
⊢ unbot' ⊥ a ≤ b ↔ a ≤ ↑b
Theorem: MeasureTheory.ae_restrict_biUnion_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: haveI := ht.to_subtype
state_before: α : Type u_1
β : Type ?u.558165
γ : Type ?u.558168
δ : Type ?u.558171
ι : Type u_2
R : Type ?u.558177
R' : Type ?u.558180
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s : ι → Set α
t : Set ι
ht : Set.Countable t
⊢ ae (Measure.restrict μ (⋃ (i : ι) (_ : i ∈ t), s i)) = ⨆ (i : ι) (_ : i ∈ t), ae (Measure.restrict μ (s i))

tactic: rw [biUnion_eq_iUnion, ae_restrict_iUnion_eq, ← iSup_subtype'']
state_before: α : Type u_1
β : Type ?u.558165
γ : Type ?u.558168
δ : Type ?u.558171
ι : Type u_2
R : Type ?u.558177
R' : Type ?u.558180
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s : ι → Set α
t : Set ι
ht : Set.Countable t
this : Countable ↑t
⊢ ae (Measure.restrict μ (⋃ (i : ι) (_ : i ∈ t), s i)) = ⨆ (i : ι) (_ : i ∈ t), ae (Measure.restrict μ (s i))
Theorem: finprod_eq_prod
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: classical rw [finprod_def, dif_pos hf]
state_before: α : Type u_1
β : Type ?u.186829
ι : Type ?u.186832
G : Type ?u.186835
M : Type u_2
N : Type ?u.186841
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : Set.Finite (mulSupport f)
⊢ (∏ᶠ (i : α), f i) = ∏ i in Finite.toFinset hf, f i

tactic: rw [finprod_def, dif_pos hf]
state_before: α : Type u_1
β : Type ?u.186829
ι : Type ?u.186832
G : Type ?u.186835
M : Type u_2
N : Type ?u.186841
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : Set.Finite (mulSupport f)
⊢ (∏ᶠ (i : α), f i) = ∏ i in Finite.toFinset hf, f i
Theorem: Complex.ofReal_add
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [ofReal']
state_before: r s : ℝ
⊢ (↑(r + s)).re = (↑r + ↑s).re ∧ (↑(r + s)).im = (↑r + ↑s).im
Theorem: CategoryTheory.IsKernelPair.isIso_of_mono
File: Mathlib/CategoryTheory/Limits/Shapes/KernelPair.lean

tactic: rw [←
  show _ = a from
    (Category.comp_id _).symm.trans
      ((IsKernelPair.id_of_mono f).isLimit.conePointUniqueUpToIso_inv_comp h.isLimit
        WalkingCospan.left)]
state_before: C : Type u
inst✝¹ : Category C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
h : IsKernelPair f a b
inst✝ : Mono f
⊢ IsIso a

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
h : IsKernelPair f a b
inst✝ : Mono f
⊢ IsIso
    (IsLimit.conePointUniqueUpToIso (IsPullback.isLimit (_ : IsKernelPair f (𝟙 X) (𝟙 X))) (IsPullback.isLimit h)).inv
Theorem: Subsemigroup.iSup_eq_closure
File: Mathlib/GroupTheory/Subsemigroup/Basic.lean

tactic: simp_rw [Subsemigroup.closure_iUnion, Subsemigroup.closure_eq]
state_before: M : Type u_2
N : Type ?u.22167
A : Type ?u.22170
inst✝¹ : Mul M
s : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
ι : Sort u_1
p : ι → Subsemigroup M
⊢ (⨆ (i : ι), p i) = closure (⋃ (i : ι), ↑(p i))
Theorem: String.offsetOfPos_of_valid
File: Std/Data/String/Lemmas.lean

tactic: simpa using offsetOfPosAux_of_valid [] l r 0
state_before: l r : List Char
⊢ offsetOfPos { data := l ++ r } { byteIdx := utf8Len l } = List.length l
Theorem: RingEquiv.symm_toNonUnitalRingHom_comp_toNonUnitalRingHom
File: Mathlib/Algebra/Ring/Equiv.lean

tactic: ext
state_before: F : Type ?u.86962
α : Type ?u.86965
β : Type ?u.86968
R : Type u_1
S : Type u_2
S' : Type ?u.86977
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring S'
e : R ≃+* S
⊢ NonUnitalRingHom.comp (toNonUnitalRingHom (RingEquiv.symm e)) (toNonUnitalRingHom e) = NonUnitalRingHom.id R

tactic: simp
state_before: case a
F : Type ?u.86962
α : Type ?u.86965
β : Type ?u.86968
R : Type u_1
S : Type u_2
S' : Type ?u.86977
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring S'
e : R ≃+* S
x✝ : R
⊢ ↑(NonUnitalRingHom.comp (toNonUnitalRingHom (RingEquiv.symm e)) (toNonUnitalRingHom e)) x✝ =
    ↑(NonUnitalRingHom.id R) x✝
Theorem: Projectivization.independent_iff_not_dependent
File: Mathlib/LinearAlgebra/ProjectiveSpace/Independence.lean

tactic: rw [dependent_iff_not_independent, Classical.not_not]
state_before: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
⊢ Independent f ↔ ¬Dependent f
Theorem: MeasureTheory.IsFundamentalDomain.image_of_equiv
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: rw [f.image_eq_preimage]
state_before: G : Type u_2
H : Type u_4
α : Type u_3
β : Type u_1
E : Type ?u.74797
inst✝⁶ : Group G
inst✝⁵ : Group H
inst✝⁴ : MulAction G α
inst✝³ : MeasurableSpace α
inst✝² : MulAction H β
inst✝¹ : MeasurableSpace β
inst✝ : NormedAddCommGroup E
s t : Set α
μ : Measure α
ν : Measure β
h : IsFundamentalDomain G s
f : α ≃ β
hf : QuasiMeasurePreserving ↑f.symm
e : H ≃ G
hef : ∀ (g : H), Semiconj (↑f) (fun x => ↑e g • x) fun x => g • x
⊢ IsFundamentalDomain H (↑f '' s)

tactic: refine' h.preimage_of_equiv hf e.symm.bijective fun g x => _
state_before: G : Type u_2
H : Type u_4
α : Type u_3
β : Type u_1
E : Type ?u.74797
inst✝⁶ : Group G
inst✝⁵ : Group H
inst✝⁴ : MulAction G α
inst✝³ : MeasurableSpace α
inst✝² : MulAction H β
inst✝¹ : MeasurableSpace β
inst✝ : NormedAddCommGroup E
s t : Set α
μ : Measure α
ν : Measure β
h : IsFundamentalDomain G s
f : α ≃ β
hf : QuasiMeasurePreserving ↑f.symm
e : H ≃ G
hef : ∀ (g : H), Semiconj (↑f) (fun x => ↑e g • x) fun x => g • x
⊢ IsFundamentalDomain H (↑f.symm ⁻¹' s)

tactic: rcases f.surjective x with ⟨x, rfl⟩
state_before: G : Type u_2
H : Type u_4
α : Type u_3
β : Type u_1
E : Type ?u.74797
inst✝⁶ : Group G
inst✝⁵ : Group H
inst✝⁴ : MulAction G α
inst✝³ : MeasurableSpace α
inst✝² : MulAction H β
inst✝¹ : MeasurableSpace β
inst✝ : NormedAddCommGroup E
s t : Set α
μ : Measure α
ν : Measure β
h : IsFundamentalDomain G s
f : α ≃ β
hf : QuasiMeasurePreserving ↑f.symm
e : H ≃ G
hef : ∀ (g : H), Semiconj (↑f) (fun x => ↑e g • x) fun x => g • x
g : G
x : β
⊢ ↑f.symm ((fun x => ↑e.symm g • x) x) = (fun x => g • x) (↑f.symm x)

tactic: rw [← hef _ _, f.symm_apply_apply, f.symm_apply_apply, e.apply_symm_apply]
state_before: case intro
G : Type u_2
H : Type u_4
α : Type u_3
β : Type u_1
E : Type ?u.74797
inst✝⁶ : Group G
inst✝⁵ : Group H
inst✝⁴ : MulAction G α
inst✝³ : MeasurableSpace α
inst✝² : MulAction H β
inst✝¹ : MeasurableSpace β
inst✝ : NormedAddCommGroup E
s t : Set α
μ : Measure α
ν : Measure β
h : IsFundamentalDomain G s
f : α ≃ β
hf : QuasiMeasurePreserving ↑f.symm
e : H ≃ G
hef : ∀ (g : H), Semiconj (↑f) (fun x => ↑e g • x) fun x => g • x
g : G
x : α
⊢ ↑f.symm ((fun x => ↑e.symm g • x) (↑f x)) = (fun x => g • x) (↑f.symm (↑f x))
Theorem: IsROrC.hasSum_iff
File: Mathlib/Analysis/Complex/Basic.lean

tactic: refine' ⟨fun h => ⟨hasSum_re _ h, hasSum_im _ h⟩, _⟩
state_before: α : Type u_2
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
c : 𝕜
⊢ HasSum f c ↔ HasSum (fun x => ↑re (f x)) (↑re c) ∧ HasSum (fun x => ↑im (f x)) (↑im c)

tactic: rintro ⟨h₁, h₂⟩
state_before: α : Type u_2
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
c : 𝕜
⊢ HasSum (fun x => ↑re (f x)) (↑re c) ∧ HasSum (fun x => ↑im (f x)) (↑im c) → HasSum f c

tactic: simpa only [re_add_im] using
  ((hasSum_ofReal 𝕜).mpr h₁).add (((hasSum_ofReal 𝕜).mpr h₂).mul_right I)
state_before: case intro
α : Type u_2
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
c : 𝕜
h₁ : HasSum (fun x => ↑re (f x)) (↑re c)
h₂ : HasSum (fun x => ↑im (f x)) (↑im c)
⊢ HasSum f c
Theorem: PGame.rightMoves_add_cases
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← toRightMovesAdd.apply_symm_apply k]
state_before: x y : PGame
k : RightMoves (x + y)
P : RightMoves (x + y) → Prop
hl : ∀ (j : RightMoves x), P (↑toRightMovesAdd (Sum.inl j))
hr : ∀ (j : RightMoves y), P (↑toRightMovesAdd (Sum.inr j))
⊢ P k

tactic: cases' toRightMovesAdd.symm k with i i
state_before: x y : PGame
k : RightMoves (x + y)
P : RightMoves (x + y) → Prop
hl : ∀ (j : RightMoves x), P (↑toRightMovesAdd (Sum.inl j))
hr : ∀ (j : RightMoves y), P (↑toRightMovesAdd (Sum.inr j))
⊢ P (↑toRightMovesAdd (↑toRightMovesAdd.symm k))

tactic: exact hl i
state_before: case inl
x y : PGame
k : RightMoves (x + y)
P : RightMoves (x + y) → Prop
hl : ∀ (j : RightMoves x), P (↑toRightMovesAdd (Sum.inl j))
hr : ∀ (j : RightMoves y), P (↑toRightMovesAdd (Sum.inr j))
i : RightMoves x
⊢ P (↑toRightMovesAdd (Sum.inl i))

tactic: exact hr i
state_before: case inr
x y : PGame
k : RightMoves (x + y)
P : RightMoves (x + y) → Prop
hl : ∀ (j : RightMoves x), P (↑toRightMovesAdd (Sum.inl j))
hr : ∀ (j : RightMoves y), P (↑toRightMovesAdd (Sum.inr j))
i : RightMoves y
⊢ P (↑toRightMovesAdd (Sum.inr i))
Theorem: Complex.orderedSMul
File: Mathlib/Data/Complex/Module.lean

tactic: simp [hr, hab.1.le]
state_before: R : Type ?u.89486
S : Type ?u.89489
a b : ℂ
r : ℝ
hab : a < b
hr : 0 < r
⊢ (r • a).re ≤ (r • b).re

tactic: simp [hab.2]
state_before: R : Type ?u.89486
S : Type ?u.89489
a b : ℂ
r : ℝ
hab : a < b
hr : 0 < r
⊢ (r • a).im = (r • b).im
Theorem: LiouvilleWith.mul_nat_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rw [← Rat.cast_coe_nat, mul_rat_iff (Nat.cast_ne_zero.2 hn)]
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
hn : n ≠ 0
⊢ LiouvilleWith p (x * ↑n) ↔ LiouvilleWith p x
Theorem: Set.iInter_setOf
File: Mathlib/Data/Set/Lattice.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.65383
γ : Type ?u.65386
ι : Sort u_2
ι' : Sort ?u.65392
ι₂ : Sort ?u.65395
κ : ι → Sort ?u.65400
κ₁ : ι → Sort ?u.65405
κ₂ : ι → Sort ?u.65410
κ' : ι' → Sort ?u.65415
P : ι → α → Prop
⊢ (⋂ (i : ι), {x | P i x}) = {x | ∀ (i : ι), P i x}

tactic: exact mem_iInter
state_before: case h
α : Type u_1
β : Type ?u.65383
γ : Type ?u.65386
ι : Sort u_2
ι' : Sort ?u.65392
ι₂ : Sort ?u.65395
κ : ι → Sort ?u.65400
κ₁ : ι → Sort ?u.65405
κ₂ : ι → Sort ?u.65410
κ' : ι' → Sort ?u.65415
P : ι → α → Prop
x✝ : α
⊢ (x✝ ∈ ⋂ (i : ι), {x | P i x}) ↔ x✝ ∈ {x | ∀ (i : ι), P i x}
Theorem: Class.ofSet.inj
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: change (x : Class.{u}) z ↔ (y : Class.{u}) z
state_before: x y : ZFSet
h : ↑x = ↑y
z : ZFSet
⊢ z ∈ x ↔ z ∈ y

tactic: rw [h]
state_before: x y : ZFSet
h : ↑x = ↑y
z : ZFSet
⊢ ↑x z ↔ ↑y z
Theorem: MeasureTheory.integral_comp_mul_left_Ioi
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: have : ∀ c : ℝ, MeasurableSet (Ioi c) := fun c => measurableSet_Ioi
state_before: E : Type u_1
f : ℝ → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
g : ℝ → E
a b : ℝ
hb : 0 < b
⊢ (∫ (x : ℝ) in Ioi a, g (b * x)) = abs b⁻¹ • ∫ (x : ℝ) in Ioi (b * a), g x

tactic: rw [← integral_indicator (this a), ← integral_indicator (this (b * a)),
  ← Measure.integral_comp_mul_left]
state_before: E : Type u_1
f : ℝ → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
g : ℝ → E
a b : ℝ
hb : 0 < b
this : ∀ (c : ℝ), MeasurableSet (Ioi c)
⊢ (∫ (x : ℝ) in Ioi a, g (b * x)) = abs b⁻¹ • ∫ (x : ℝ) in Ioi (b * a), g x

tactic: congr
state_before: E : Type u_1
f : ℝ → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
g : ℝ → E
a b : ℝ
hb : 0 < b
this : ∀ (c : ℝ), MeasurableSet (Ioi c)
⊢ (∫ (x : ℝ), indicator (Ioi a) (fun x => g (b * x)) x) = ∫ (x : ℝ), indicator (Ioi (b * a)) (fun x => g x) (b * x)

tactic: ext1 x
state_before: case e_f
E : Type u_1
f : ℝ → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
g : ℝ → E
a b : ℝ
hb : 0 < b
this : ∀ (c : ℝ), MeasurableSet (Ioi c)
⊢ (fun x => indicator (Ioi a) (fun x => g (b * x)) x) = fun x => indicator (Ioi (b * a)) (fun x => g x) (b * x)

tactic: rw [← indicator_comp_right, preimage_const_mul_Ioi _ hb, mul_div_cancel_left _ hb.ne']
state_before: case e_f.h
E : Type u_1
f : ℝ → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
g : ℝ → E
a b : ℝ
hb : 0 < b
this : ∀ (c : ℝ), MeasurableSet (Ioi c)
x : ℝ
⊢ indicator (Ioi a) (fun x => g (b * x)) x = indicator (Ioi (b * a)) (fun x => g x) (b * x)

tactic: rfl
state_before: case e_f.h
E : Type u_1
f : ℝ → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
g : ℝ → E
a b : ℝ
hb : 0 < b
this : ∀ (c : ℝ), MeasurableSet (Ioi c)
x : ℝ
⊢ indicator (Ioi a) (fun x => g (b * x)) x = indicator (Ioi a) ((fun x => g x) ∘ HMul.hMul b) x
Theorem: Finset.subset_singleton_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← coe_subset, coe_singleton, Set.subset_singleton_iff_eq, coe_eq_empty, coe_eq_singleton]
state_before: α : Type u_1
β : Type ?u.35142
γ : Type ?u.35145
s✝ : Finset α
a✝ b : α
s : Finset α
a : α
⊢ s ⊆ {a} ↔ s = ∅ ∨ s = {a}
Theorem: sub_lie
File: Mathlib/Algebra/Lie/Basic.lean

tactic: simp [sub_eq_add_neg]
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
t : R
x y z : L
m n : M
⊢ ⁅x - y, m⁆ = ⁅x, m⁆ - ⁅y, m⁆
Theorem: ENNReal.toReal_eq_toReal
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift a to ℝ≥0 using ha
state_before: α : Type ?u.827878
β : Type ?u.827881
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ ⊤
⊢ ENNReal.toReal a = ENNReal.toReal b ↔ a = b

tactic: lift b to ℝ≥0 using hb
state_before: case intro
α : Type ?u.827878
β : Type ?u.827881
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ ENNReal.toReal ↑a = ENNReal.toReal b ↔ ↑a = b

tactic: simp only [coe_eq_coe, NNReal.coe_eq, coe_toReal]
state_before: case intro.intro
α : Type ?u.827878
β : Type ?u.827881
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ ENNReal.toReal ↑a = ENNReal.toReal ↑b ↔ ↑a = ↑b
Theorem: Real.sqrt_mul
File: Mathlib/Data/Real/Sqrt.lean

tactic: simp_rw [sqrt, ← NNReal.coe_mul, NNReal.coe_eq, Real.toNNReal_mul hx, NNReal.sqrt_mul]
state_before: x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ sqrt (x * y) = sqrt x * sqrt y
Theorem: numDerangements_sum
File: Mathlib/Combinatorics/Derangements/Finite.lean

tactic: induction' n with n hn
state_before: α : Type ?u.22310
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
⊢ ↑(numDerangements n) = ∑ k in Finset.range (n + 1), (-1) ^ k * ↑(Nat.ascFactorial k (n - k))

tactic: rw [Finset.sum_range_succ, numDerangements_succ, hn, Finset.mul_sum, tsub_self,
  Nat.ascFactorial_zero, Int.ofNat_one, mul_one, pow_succ, neg_one_mul, sub_eq_add_neg,
  add_left_inj, Finset.sum_congr rfl]
state_before: case succ
α : Type ?u.22310
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
hn : ↑(numDerangements n) = ∑ k in Finset.range (n + 1), (-1) ^ k * ↑(Nat.ascFactorial k (n - k))
⊢ ↑(numDerangements (Nat.succ n)) =
    ∑ k in Finset.range (Nat.succ n + 1), (-1) ^ k * ↑(Nat.ascFactorial k (Nat.succ n - k))

tactic: intro x hx
state_before: case succ
α : Type ?u.22310
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
hn : ↑(numDerangements n) = ∑ k in Finset.range (n + 1), (-1) ^ k * ↑(Nat.ascFactorial k (n - k))
⊢ ∀ (x : ℕ),
    x ∈ Finset.range (n + 1) →
      (↑n + 1) * ((-1) ^ x * ↑(Nat.ascFactorial x (n - x))) = (-1) ^ x * ↑(Nat.ascFactorial x (Nat.succ n - x))

tactic: have h_le : x ≤ n := Finset.mem_range_succ_iff.mp hx
state_before: case succ
α : Type ?u.22310
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
hn : ↑(numDerangements n) = ∑ k in Finset.range (n + 1), (-1) ^ k * ↑(Nat.ascFactorial k (n - k))
x : ℕ
hx : x ∈ Finset.range (n + 1)
⊢ (↑n + 1) * ((-1) ^ x * ↑(Nat.ascFactorial x (n - x))) = (-1) ^ x * ↑(Nat.ascFactorial x (Nat.succ n - x))

tactic: rw [Nat.succ_sub h_le, Nat.ascFactorial_succ, add_tsub_cancel_of_le h_le, Int.ofNat_mul,
  Int.ofNat_succ, mul_left_comm]
state_before: case succ
α : Type ?u.22310
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
hn : ↑(numDerangements n) = ∑ k in Finset.range (n + 1), (-1) ^ k * ↑(Nat.ascFactorial k (n - k))
x : ℕ
hx : x ∈ Finset.range (n + 1)
h_le : x ≤ n
⊢ (↑n + 1) * ((-1) ^ x * ↑(Nat.ascFactorial x (n - x))) = (-1) ^ x * ↑(Nat.ascFactorial x (Nat.succ n - x))

tactic: rfl
state_before: case zero
α : Type ?u.22310
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ ↑(numDerangements Nat.zero) = ∑ k in Finset.range (Nat.zero + 1), (-1) ^ k * ↑(Nat.ascFactorial k (Nat.zero - k))
Theorem: Mathlib.Tactic.Ring.mul_add
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₁ c₁ b₂ c₂ d : R
x✝² : a * b₁ = c₁
x✝¹ : a * b₂ = c₂
x✝ : c₁ + 0 + c₂ = d
⊢ a * (b₁ + b₂) = d

tactic: simp [_root_.mul_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₁ b₂ : R
⊢ a * (b₁ + b₂) = a * b₁ + 0 + a * b₂
Theorem: HasDerivAt.complexToReal_fderiv'
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: simpa only [Complex.restrictScalars_one_smulRight'] using h.hasFDerivAt.restrictScalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
x : ℂ
f' : E
h : HasDerivAt f f' x
⊢ HasFDerivAt f (ContinuousLinearMap.smulRight reClm f' + I • ContinuousLinearMap.smulRight imClm f') x
Theorem: Function.Involutive.iterate_two_mul
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [iterate_mul, involutive_iff_iter_2_eq_id.1 hf, iterate_id]
state_before: α : Type u_1
f : α → α
n✝ : ℕ
hf : Involutive f
n : ℕ
⊢ f^[2 * n] = id
Theorem: Int.min_eq_left
File: Std/Data/Int/Lemmas.lean

tactic: simp [Int.min_def, h]
state_before: a b : Int
h : a ≤ b
⊢ min a b = a
Theorem: HomologicalComplex.singleMapHomologicalComplex_inv_app_ne
File: Mathlib/Algebra/Homology/Additive.lean

tactic: simp [singleMapHomologicalComplex, h]
state_before: ι : Type u_1
V : Type u
inst✝⁶ : Category V
inst✝⁵ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
inst✝⁴ : HasZeroObject V
W : Type u_3
inst✝³ : Category W
inst✝² : Preadditive W
inst✝¹ : HasZeroObject W
F : V ⥤ W
inst✝ : Functor.Additive F
i j : ι
h : i ≠ j
X : V
⊢ Hom.f ((singleMapHomologicalComplex F c j).inv.app X) i = 0
Theorem: Matrix.mul_transvection_apply_of_ne
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: simp [transvection, Matrix.mul_add, hb]
state_before: n : Type u_1
p : Type ?u.18322
R : Type u₂
𝕜 : Type ?u.18327
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
a b : n
hb : b ≠ j
c : R
M : Matrix n n R
⊢ (M ⬝ transvection i j c) a b = M a b
Theorem: LocalHomeomorph.ext_iff
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.28742
δ : Type ?u.28745
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e'✝ : LocalHomeomorph β γ
e e' : LocalHomeomorph α β
⊢ e = e' →
    (∀ (x : α), ↑e x = ↑e' x) ∧
      (∀ (x : β), ↑(LocalHomeomorph.symm e) x = ↑(LocalHomeomorph.symm e') x) ∧ e.source = e'.source

tactic: exact ⟨fun x => rfl, fun x => rfl, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.28742
δ : Type ?u.28745
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
⊢ (∀ (x : α), ↑e x = ↑e x) ∧
    (∀ (x : β), ↑(LocalHomeomorph.symm e) x = ↑(LocalHomeomorph.symm e) x) ∧ e.source = e.source
Theorem: Ordinal.nadd_le_nadd_right
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rcases lt_or_eq_of_le h with (h | rfl)
state_before: a✝ b c : Ordinal
h : b ≤ c
a : Ordinal
⊢ b ♯ a ≤ c ♯ a

tactic: exact (nadd_lt_nadd_right h a).le
state_before: case inl
a✝ b c : Ordinal
h✝ : b ≤ c
a : Ordinal
h : b < c
⊢ b ♯ a ≤ c ♯ a

tactic: exact le_rfl
state_before: case inr
a✝ b a : Ordinal
h : b ≤ b
⊢ b ♯ a ≤ b ♯ a
Theorem: Set.image_insert_eq
File: Mathlib/Data/Set/Image.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.40151
ι : Sort ?u.40154
ι' : Sort ?u.40157
f✝ : α → β
s✝ t : Set α
f : α → β
a : α
s : Set α
⊢ f '' insert a s = insert (f a) (f '' s)

tactic: simp [and_or_left, exists_or, eq_comm, or_comm, and_comm]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.40151
ι : Sort ?u.40154
ι' : Sort ?u.40157
f✝ : α → β
s✝ t : Set α
f : α → β
a : α
s : Set α
x✝ : β
⊢ x✝ ∈ f '' insert a s ↔ x✝ ∈ insert (f a) (f '' s)
Theorem: neg_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [neg_eq_neg_one_mul, mul_div_assoc, ← neg_eq_neg_one_mul]
state_before: α : Type ?u.30697
β : Type ?u.30700
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ -b / a = -(b / a)
Theorem: pow_lt_pow_succ
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [← one_mul (a ^ n), pow_succ]
state_before: β : Type ?u.278866
A : Type ?u.278869
G : Type ?u.278872
M : Type u_1
R : Type ?u.278878
inst✝ : LinearOrderedCommGroupWithZero M
a : M
m n : ℕ
ha : 1 < a
⊢ a ^ n < a ^ Nat.succ n

tactic: exact mul_lt_right₀ _ ha (pow_ne_zero _ (zero_lt_one.trans ha).ne')
state_before: β : Type ?u.278866
A : Type ?u.278869
G : Type ?u.278872
M : Type u_1
R : Type ?u.278878
inst✝ : LinearOrderedCommGroupWithZero M
a : M
m n : ℕ
ha : 1 < a
⊢ 1 * a ^ n < a * a ^ n
Theorem: Subtype.preconnectedSpace
File: Mathlib/Topology/Connected.lean

tactic: rwa [← inducing_subtype_val.isPreconnected_image, image_univ, Subtype.range_val]
state_before: α : Type u
β : Type v
ι : Type ?u.71334
π : ι → Type ?u.71339
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
h : IsPreconnected s
⊢ IsPreconnected univ
Theorem: Function.Periodic.map_mod_nat
File: Mathlib/Data/Nat/Periodic.lean

tactic: conv_rhs => rw [← Nat.mod_add_div n a, mul_comm, ← Nat.nsmul_eq_mul, hf.nsmul]
state_before: α : Type u_1
f : ℕ → α
a : ℕ
hf : Periodic f a
n : ℕ
⊢ f (n % a) = f n
Theorem: List.any_iff_exists_prop
File: Mathlib/Data/Bool/AllAny.lean

tactic: simp [any_iff_exists]
state_before: α : Type u_1
p : α → Prop
inst✝ : DecidablePred p
l : List α
a : α
⊢ (any l fun a => decide (p a)) = true ↔ ∃ a, a ∈ l ∧ p a
Theorem: Mathlib.Meta.NormNum.isNat_natMod
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: aesop
state_before: n✝¹ n✝ : ℕ
⊢ ↑n✝¹ % ↑n✝ = ↑(Nat.mod n✝¹ n✝)