tasksource/leandojo huggingface dataset:
Theorem: lp.sum_rpow_le_norm_rpow
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [lp.norm_rpow_eq_tsum hp f]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
s : Finset α
⊢ ∑ i in s, ‖↑f i‖ ^ ENNReal.toReal p ≤ ‖f‖ ^ ENNReal.toReal p

tactic: have : ∀ i, 0 ≤ ‖f i‖ ^ p.toReal := fun i => Real.rpow_nonneg_of_nonneg (norm_nonneg _) _
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
s : Finset α
⊢ ∑ i in s, ‖↑f i‖ ^ ENNReal.toReal p ≤ ∑' (i : α), ‖↑f i‖ ^ ENNReal.toReal p

tactic: refine' sum_le_tsum _ (fun i _ => this i) _
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
s : Finset α
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
⊢ ∑ i in s, ‖↑f i‖ ^ ENNReal.toReal p ≤ ∑' (i : α), ‖↑f i‖ ^ ENNReal.toReal p

tactic: exact (lp.memℓp f).summable hp
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
s : Finset α
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
⊢ Summable fun i => ‖↑f i‖ ^ ENNReal.toReal p
Theorem: Finset.fold_hom
File: Mathlib/Data/Finset/Fold.lean

tactic: rw [fold, fold, ← Multiset.fold_hom op hm, Multiset.map_map]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
op' : γ → γ → γ
inst✝¹ : IsCommutative γ op'
inst✝ : IsAssociative γ op'
m : β → γ
hm : ∀ (x y : β), m (op x y) = op' (m x) (m y)
⊢ fold op' (m b) (fun x => m (f x)) s = m (fold op b f s)

tactic: simp only [Function.comp_apply]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
op' : γ → γ → γ
inst✝¹ : IsCommutative γ op'
inst✝ : IsAssociative γ op'
m : β → γ
hm : ∀ (x y : β), m (op x y) = op' (m x) (m y)
⊢ Multiset.fold op' (m b) (Multiset.map (fun x => m (f x)) s.val) = Multiset.fold op' (m b) (Multiset.map (m ∘ f) s.val)
Theorem: Traversable.traverse_eq_map_id'
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: ext
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
f : β → γ
⊢ traverse (pure ∘ f) = pure ∘ map f

tactic: exact traverse_eq_map_id _ _
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
f : β → γ
x✝ : t β
⊢ traverse (pure ∘ f) x✝ = (pure ∘ map f) x✝
Theorem: Homeomorph.image_frontier
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [← preimage_symm, preimage_frontier]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.67510
δ : Type ?u.67513
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
s : Set α
⊢ ↑h '' frontier s = frontier (↑h '' s)
Theorem: Submodule.mem_torsionBySet_iff
File: Mathlib/Algebra/Module/Torsion.lean

tactic: refine' ⟨fun h ⟨a, ha⟩ => mem_sInf.mp h _ (Set.mem_image_of_mem _ ha), fun h => mem_sInf.mpr _⟩
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
⊢ x ∈ torsionBySet R M s ↔ ∀ (a : ↑s), ↑a • x = 0

tactic: rintro _ ⟨a, ha, rfl⟩
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
h : ∀ (a : ↑s), ↑a • x = 0
⊢ ∀ (p : Submodule R M), p ∈ torsionBy R M '' s → x ∈ p

tactic: exact h ⟨a, ha⟩
state_before: case intro.intro
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a✝ : R
x : M
h : ∀ (a : ↑s), ↑a • x = 0
a : R
ha : a ∈ s
⊢ x ∈ torsionBy R M a
Theorem: Bool.xor_false_left
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (a : Bool), xor false a = a
Theorem: Multiset.count_eq_card_filter_eq
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [count, countp_eq_card_filter]
state_before: α : Type u_1
β : Type ?u.433611
γ : Type ?u.433614
inst✝ : DecidableEq α
s : Multiset α
a : α
⊢ count a s = ↑card (filter (fun x => a = x) s)
Theorem: Finset.orderEmbOfFin_apply
File: Mathlib/Data/Finset/Sort.lean

tactic: rw [length_sort, h]
state_before: α : Type ?u.35647
β : Type ?u.35650
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : card s = k
i : Fin k
⊢ ↑i < List.length (sort (fun x x_1 => x ≤ x_1) s)

tactic: exact i.2
state_before: α : Type ?u.35647
β : Type ?u.35650
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : card s = k
i : Fin k
⊢ ↑i < k
Theorem: iteratedFDeriv_succ_const
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: ext x
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 ?u.69409
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c✝ : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
c : F
⊢ (iteratedFDeriv 𝕜 (n + 1) fun x => c) = 0

tactic: simp only [iteratedFDeriv_succ_eq_comp_right, fderiv_const, Pi.zero_apply,
  iteratedFDeriv_zero_fun, comp_apply, LinearIsometryEquiv.map_zero]
state_before: case h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 ?u.69409
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝¹ x₀ : E
c✝ : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
c : F
x : E
x✝ : Fin (n + 1) → E
⊢ ↑(iteratedFDeriv 𝕜 (n + 1) (fun x => c) x) x✝ = ↑(OfNat.ofNat 0 x) x✝
Theorem: Set.preimage_const_add_Ico
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iio]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a + x) ⁻¹' Ico b c = Ico (b - a) (c - a)
Theorem: Std.RBNode.Path.zoom_insert
File: Std/Data/RBMap/Alter.lean

tactic: have ⟨_, _, ht', hp'⟩ := ht.zoom .root H
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
t' : RBNode α
v : α
path : Path α
t : RBNode α
ht : Balanced t c n
H : zoom (cmp v) t root = (t', path)
⊢ setBlack (insert path t' v) = setBlack (RBNode.insert cmp t v)

tactic: cases ht' with simp [insert]
| nil => simp [insertNew_eq_insert H, setBlack_idem]
| red hl hr => rw [← ins_eq_fill hp' (.red hl hr), insert_setBlack]; exact (zoom_ins H).symm
| black hl hr => rw [← ins_eq_fill hp' (.black hl hr), insert_setBlack]; exact (zoom_ins H).symm
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
t' : RBNode α
v : α
path : Path α
t : RBNode α
ht : Balanced t c n
H : zoom (cmp v) t root = (t', path)
w✝¹ : RBColor
w✝ : Nat
ht' : Balanced t' w✝¹ w✝
hp' : Path.Balanced c n path w✝¹ w✝
⊢ setBlack (insert path t' v) = setBlack (RBNode.insert cmp t v)

tactic: simp [insertNew_eq_insert H, setBlack_idem]
state_before: case nil
α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
path : Path α
t : RBNode α
ht : Balanced t c n
H : zoom (cmp v) t root = (nil, path)
hp' : Path.Balanced c n path black 0
⊢ setBlack (insertNew path v) = setBlack (RBNode.insert cmp t v)

tactic: rw [← ins_eq_fill hp' (.red hl hr), insert_setBlack]
state_before: case red
α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
path : Path α
t : RBNode α
ht : Balanced t c n
w✝ : Nat
x✝ y✝ : RBNode α
v✝ : α
H : zoom (cmp v) t root = (node red x✝ v✝ y✝, path)
hp' : Path.Balanced c n path red w✝
hl : Balanced x✝ black w✝
hr : Balanced y✝ black w✝
⊢ setBlack (fill path (node red x✝ v y✝)) = setBlack (RBNode.insert cmp t v)

tactic: exact (zoom_ins H).symm
state_before: case red
α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
path : Path α
t : RBNode α
ht : Balanced t c n
w✝ : Nat
x✝ y✝ : RBNode α
v✝ : α
H : zoom (cmp v) t root = (node red x✝ v✝ y✝, path)
hp' : Path.Balanced c n path red w✝
hl : Balanced x✝ black w✝
hr : Balanced y✝ black w✝
⊢ ins path (node red x✝ v y✝) = setBlack (RBNode.ins cmp v t)

tactic: rw [← ins_eq_fill hp' (.black hl hr), insert_setBlack]
state_before: case black
α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
path : Path α
t : RBNode α
ht : Balanced t c n
x✝ : RBNode α
c₁✝ : RBColor
n✝ : Nat
y✝ : RBNode α
c₂✝ : RBColor
v✝ : α
hl : Balanced x✝ c₁✝ n✝
hr : Balanced y✝ c₂✝ n✝
H : zoom (cmp v) t root = (node black x✝ v✝ y✝, path)
hp' : Path.Balanced c n path black (n✝ + 1)
⊢ setBlack (fill path (node black x✝ v y✝)) = setBlack (RBNode.insert cmp t v)

tactic: exact (zoom_ins H).symm
state_before: case black
α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
path : Path α
t : RBNode α
ht : Balanced t c n
x✝ : RBNode α
c₁✝ : RBColor
n✝ : Nat
y✝ : RBNode α
c₂✝ : RBColor
v✝ : α
hl : Balanced x✝ c₁✝ n✝
hr : Balanced y✝ c₂✝ n✝
H : zoom (cmp v) t root = (node black x✝ v✝ y✝, path)
hp' : Path.Balanced c n path black (n✝ + 1)
⊢ ins path (node black x✝ v y✝) = setBlack (RBNode.ins cmp v t)
Theorem: Set.compl_section_ordSeparatingSet_mem_nhds
File: Mathlib/Topology/Algebra/Order/T5.lean

tactic: rw [← nhds_left_sup_nhds_right, mem_sup]
state_before: X : Type u_1
inst✝² : LinearOrder X
inst✝¹ : TopologicalSpace X
inst✝ : OrderTopology X
a b c : X
s t : Set X
hd : Disjoint s (closure t)
ha : a ∈ s
⊢ ordConnectedSection (ordSeparatingSet s t)ᶜ ∈ 𝓝 a

tactic: exact
  ⟨compl_section_ordSeparatingSet_mem_nhdsWithin_Iic hd ha,
    compl_section_ordSeparatingSet_mem_nhdsWithin_Ici hd ha⟩
state_before: X : Type u_1
inst✝² : LinearOrder X
inst✝¹ : TopologicalSpace X
inst✝ : OrderTopology X
a b c : X
s t : Set X
hd : Disjoint s (closure t)
ha : a ∈ s
⊢ ordConnectedSection (ordSeparatingSet s t)ᶜ ∈ 𝓝[Iic a] a ∧ ordConnectedSection (ordSeparatingSet s t)ᶜ ∈ 𝓝[Ici a] a
Theorem: le_ciSup_iff'
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: simp [iSup, h, le_csSup_iff', upperBounds]
state_before: α : Type u_1
β : Type ?u.75010
γ : Type ?u.75013
ι : Sort u_2
inst✝ : ConditionallyCompleteLinearOrderBot α
s : ι → α
a : α
h : BddAbove (range s)
⊢ a ≤ iSup s ↔ ∀ (b : α), (∀ (i : ι), s i ≤ b) → a ≤ b
Theorem: orderOf_eq_zero
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rwa [orderOf, minimalPeriod, dif_neg]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : ¬IsOfFinOrder x
⊢ orderOf x = 0
Theorem: isUpperSet_iff_Ici_subset
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [IsUpperSet, subset_def, @forall_swap (_ ∈ s)]
state_before: α : Type u_1
β : Type ?u.7423
γ : Type ?u.7426
ι : Sort ?u.7429
κ : ι → Sort ?u.7434
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
p : α → Prop
a : α
⊢ IsUpperSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Ici a ⊆ s
Theorem: Multiset.range_disjoint_map_add
File: Mathlib/Data/Multiset/Range.lean

tactic: intro x hxa hxb
state_before: a : ℕ
m : Multiset ℕ
⊢ Disjoint (range a) (map (fun x => a + x) m)

tactic: rw [range, mem_coe, List.mem_range] at hxa
state_before: a : ℕ
m : Multiset ℕ
x : ℕ
hxa : x ∈ range a
hxb : x ∈ map (fun x => a + x) m
⊢ False

tactic: obtain ⟨c, _, rfl⟩ := mem_map.1 hxb
state_before: a : ℕ
m : Multiset ℕ
x : ℕ
hxa : x < a
hxb : x ∈ map (fun x => a + x) m
⊢ False

tactic: exact (self_le_add_right _ _).not_lt hxa
state_before: case intro.intro
a : ℕ
m : Multiset ℕ
c : ℕ
left✝ : c ∈ m
hxa : a + c < a
hxb : a + c ∈ map (fun x => a + x) m
⊢ False
Theorem: PrimeMultiset.to_ofNatMultiset
File: Mathlib/Data/PNat/Factors.lean

tactic: dsimp [ofNatMultiset, toNatMultiset]
state_before: v : Multiset ℕ
h : ∀ (p : ℕ), p ∈ v → Nat.Prime p
⊢ toNatMultiset (ofNatMultiset v h) = v

tactic: have : (fun p h => (Coe.coe : Nat.Primes → ℕ) ⟨p, h⟩) = fun p _ => id p := by
  funext p h
  rfl
state_before: v : Multiset ℕ
h : ∀ (p : ℕ), p ∈ v → Nat.Prime p
⊢ Multiset.map Coe.coe (Multiset.pmap (fun p hp => { val := p, property := hp }) v h) = v

tactic: rw [Multiset.map_pmap, this, Multiset.pmap_eq_map, Multiset.map_id]
state_before: v : Multiset ℕ
h : ∀ (p : ℕ), p ∈ v → Nat.Prime p
this : (fun p h => Coe.coe { val := p, property := h }) = fun p x => id p
⊢ Multiset.map Coe.coe (Multiset.pmap (fun p hp => { val := p, property := hp }) v h) = v

tactic: funext p h
state_before: v : Multiset ℕ
h : ∀ (p : ℕ), p ∈ v → Nat.Prime p
⊢ (fun p h => Coe.coe { val := p, property := h }) = fun p x => id p

tactic: rfl
state_before: case h.h
v : Multiset ℕ
h✝ : ∀ (p : ℕ), p ∈ v → Nat.Prime p
p : ℕ
h : Nat.Prime p
⊢ Coe.coe { val := p, property := h } = id p
Theorem: ContinuousOn.comp_continuous
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [continuous_iff_continuousOn_univ] at *
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.336497
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
f : α → β
s : Set β
hg : ContinuousOn g s
hf : Continuous f
hs : ∀ (x : α), f x ∈ s
⊢ Continuous (g ∘ f)

tactic: exact hg.comp hf fun x _ => hs x
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.336497
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
f : α → β
s : Set β
hg : ContinuousOn g s
hf : ContinuousOn f univ
hs : ∀ (x : α), f x ∈ s
⊢ ContinuousOn (g ∘ f) univ
Theorem: Ideal.quotient_mk_maps_eq
File: Mathlib/RingTheory/Ideal/Over.lean

tactic: refine' RingHom.ext fun x => _
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.53760
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ RingHom.comp (RingHom.comp (Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) C) (Quotient.mk (comap C P)) =
    RingHom.comp
      (quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P)))
        (_ : P ≤ comap (mapRingHom (Quotient.mk (comap C P))) (map (mapRingHom (Quotient.mk (comap C P))) P)))
      (RingHom.comp (Quotient.mk P) C)

tactic: repeat' rw [RingHom.coe_comp, Function.comp_apply]
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.53760
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
x : R
⊢ ↑(RingHom.comp (RingHom.comp (Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) C)
          (Quotient.mk (comap C P)))
      x =
    ↑(RingHom.comp
          (quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P)))
            (_ : P ≤ comap (mapRingHom (Quotient.mk (comap C P))) (map (mapRingHom (Quotient.mk (comap C P))) P)))
          (RingHom.comp (Quotient.mk P) C))
      x

tactic: rw [quotientMap_mk, coe_mapRingHom, map_C]
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.53760
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
x : R
⊢ ↑(Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) (↑C (↑(Quotient.mk (comap C P)) x)) =
    ↑(quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P)))
          (_ : P ≤ comap (mapRingHom (Quotient.mk (comap C P))) (map (mapRingHom (Quotient.mk (comap C P))) P)))
      (↑(Quotient.mk P) (↑C x))

tactic: rw [RingHom.coe_comp, Function.comp_apply]
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.53760
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
x : R
⊢ ↑(Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) (↑C (↑(Quotient.mk (comap C P)) x)) =
    ↑(quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P)))
          (_ : P ≤ comap (mapRingHom (Quotient.mk (comap C P))) (map (mapRingHom (Quotient.mk (comap C P))) P)))
      (↑(Quotient.mk P) (↑C x))
Theorem: CategoryTheory.Limits.map_lift_pullbackComparison
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp only [← G.map_comp, w]
state_before: C : Type u
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ G.map h ≫ G.map f = G.map k ≫ G.map g

tactic: ext <;> simp [← G.map_comp]
state_before: C : Type u
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ G.map (pullback.lift h k w) ≫ pullbackComparison G f g =
    pullback.lift (G.map h) (G.map k) (_ : G.map h ≫ G.map f = G.map k ≫ G.map g)
Theorem: Commute.inv_sub_inv
File: Mathlib/Algebra/Field/Basic.lean

tactic: simp only [inv_eq_one_div, (Commute.one_right a).div_sub_div hab ha hb, one_mul, mul_one]
state_before: α : Type ?u.49028
β : Type ?u.49031
K : Type u_1
inst✝ : DivisionRing K
a b c d : K
hab : _root_.Commute a b
ha : a ≠ 0
hb : b ≠ 0
⊢ a⁻¹ - b⁻¹ = (b - a) / (a * b)
Theorem: differentiableWithinAt_neg_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [neg_neg] using h.neg
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.407641
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.407736
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : DifferentiableWithinAt 𝕜 (fun y => -f y) s x
⊢ DifferentiableWithinAt 𝕜 f s x
Theorem: mul_inv_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [mul_eq_one_iff_eq_inv, inv_inv]
state_before: α : Type ?u.55381
β : Type ?u.55384
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ a * b⁻¹ = 1 ↔ a = b
Theorem: Ordinal.deriv_add_eq_mul_omega_add
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: revert b
state_before: a b : Ordinal
⊢ deriv (fun x => a + x) b = a * ω + b

tactic: rw [← funext_iff, IsNormal.eq_iff_zero_and_succ (deriv_isNormal _) (add_isNormal _)]
state_before: a : Ordinal
⊢ ∀ (b : Ordinal), deriv (fun x => a + x) b = a * ω + b

tactic: refine' ⟨_, fun a h => _⟩
state_before: a : Ordinal
⊢ deriv (fun x => a + x) 0 = (fun x x_1 => x + x_1) (a * ω) 0 ∧
    ∀ (a_1 : Ordinal),
      deriv (fun x => a + x) a_1 = (fun x x_1 => x + x_1) (a * ω) a_1 →
        deriv (fun x => a + x) (succ a_1) = (fun x x_1 => x + x_1) (a * ω) (succ a_1)

tactic: dsimp
state_before: case refine'_1
a : Ordinal
⊢ deriv (fun x => a + x) 0 = (fun x x_1 => x + x_1) (a * ω) 0

tactic: rw [deriv_zero, add_zero]
state_before: case refine'_1
a : Ordinal
⊢ deriv (fun x => a + x) 0 = a * ω + 0

tactic: exact nfp_add_zero a
state_before: case refine'_1
a : Ordinal
⊢ nfp (fun x => a + x) 0 = a * ω

tactic: dsimp
state_before: case refine'_2
a✝ a : Ordinal
h : deriv (fun x => a✝ + x) a = (fun x x_1 => x + x_1) (a✝ * ω) a
⊢ deriv (fun x => a✝ + x) (succ a) = (fun x x_1 => x + x_1) (a✝ * ω) (succ a)

tactic: rw [deriv_succ, h, add_succ]
state_before: case refine'_2
a✝ a : Ordinal
h : deriv (fun x => a✝ + x) a = (fun x x_1 => x + x_1) (a✝ * ω) a
⊢ deriv (fun x => a✝ + x) (succ a) = a✝ * ω + succ a

tactic: exact nfp_eq_self (add_eq_right_iff_mul_omega_le.2 ((le_add_right _ _).trans (le_succ _)))
state_before: case refine'_2
a✝ a : Ordinal
h : deriv (fun x => a✝ + x) a = (fun x x_1 => x + x_1) (a✝ * ω) a
⊢ nfp (fun x => a✝ + x) (succ ((fun x x_1 => x + x_1) (a✝ * ω) a)) = succ (a✝ * ω + a)
Theorem: Complex.nnnorm_eq_one_of_pow_eq_one
File: Mathlib/Analysis/Complex/Basic.lean

tactic: refine' (@pow_left_inj NNReal _ _ _ _ zero_le' zero_le' hn.bot_lt).mp _
state_before: E : Type ?u.222428
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
ζ : ℂ
n : ℕ
h : ζ ^ n = 1
hn : n ≠ 0
⊢ ‖ζ‖₊ = 1

tactic: rw [← nnnorm_pow, h, nnnorm_one, one_pow]
state_before: E : Type ?u.222428
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
ζ : ℂ
n : ℕ
h : ζ ^ n = 1
hn : n ≠ 0
⊢ ‖ζ‖₊ ^ n = 1 ^ n
Theorem: MeasureTheory.SignedMeasure.toJordanDecomposition_neg
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: apply toSignedMeasure_injective
state_before: α : Type u_1
β : Type ?u.74331
inst✝ : MeasurableSpace α
s : SignedMeasure α
⊢ toJordanDecomposition (-s) = -toJordanDecomposition s

tactic: simp [toSignedMeasure_neg]
state_before: case a
α : Type u_1
β : Type ?u.74331
inst✝ : MeasurableSpace α
s : SignedMeasure α
⊢ toSignedMeasure (toJordanDecomposition (-s)) = toSignedMeasure (-toJordanDecomposition s)
Theorem: Valuation.Integers.dvd_of_le
File: Mathlib/RingTheory/Valuation/Integers.lean

tactic: rw [← v.map_one, ← inv_mul_cancel hy, v.map_mul, v.map_mul]
state_before: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : Integers v O
x y : O
h : ↑v (↑(algebraMap O F) x) ≤ ↑v (↑(algebraMap O F) y)
hy : ↑(algebraMap O F) y ≠ 0
⊢ ↑v ((↑(algebraMap O F) y)⁻¹ * ↑(algebraMap O F) x) ≤ 1

tactic: exact mul_le_mul_left' h _
state_before: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : Integers v O
x y : O
h : ↑v (↑(algebraMap O F) x) ≤ ↑v (↑(algebraMap O F) y)
hy : ↑(algebraMap O F) y ≠ 0
⊢ ↑v (↑(algebraMap O F) y)⁻¹ * ↑v (↑(algebraMap O F) x) ≤ ↑v (↑(algebraMap O F) y)⁻¹ * ↑v (↑(algebraMap O F) y)
Theorem: Relation.ReflTransGen.trans
File: Mathlib/Logic/Relation.lean

tactic: induction hbc
state_before: α : Type u_1
β : Type ?u.16334
γ : Type ?u.16337
δ : Type ?u.16340
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
hbc : ReflTransGen r b c
⊢ ReflTransGen r a c

tactic: case refl => assumption
state_before: case refl
α : Type u_1
β : Type ?u.16334
γ : Type ?u.16337
δ : Type ?u.16340
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
⊢ ReflTransGen r a b

case tail
α : Type u_1
β : Type ?u.16334
γ : Type ?u.16337
δ : Type ?u.16340
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
b✝ c✝ : α
a✝¹ : ReflTransGen r b b✝
a✝ : r b✝ c✝
a_ih✝ : ReflTransGen r a b✝
⊢ ReflTransGen r a c✝

tactic: case tail c d _ hcd hac => exact hac.tail hcd
state_before: case tail
α : Type u_1
β : Type ?u.16334
γ : Type ?u.16337
δ : Type ?u.16340
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
b✝ c✝ : α
a✝¹ : ReflTransGen r b b✝
a✝ : r b✝ c✝
a_ih✝ : ReflTransGen r a b✝
⊢ ReflTransGen r a c✝

tactic: assumption
state_before: α : Type u_1
β : Type ?u.16334
γ : Type ?u.16337
δ : Type ?u.16340
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
⊢ ReflTransGen r a b

tactic: exact hac.tail hcd
state_before: α : Type u_1
β : Type ?u.16334
γ : Type ?u.16337
δ : Type ?u.16340
r : α → α → Prop
a b c✝ d✝ : α
hab : ReflTransGen r a b
c d : α
a✝ : ReflTransGen r b c
hcd : r c d
hac : ReflTransGen r a c
⊢ ReflTransGen r a d