tasksource/leandojo huggingface dataset:
Theorem: NNReal.rpow_add_le_add_rpow
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: rcases hp.eq_or_lt with (rfl | hp_pos)
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: have h := rpow_add_rpow_le a b hp_pos hp1
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: rw [one_div_one] at h
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ (1 / 1) ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: repeat' rw [NNReal.rpow_one] at h
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: exact (NNReal.le_rpow_one_div_iff hp_pos).mp h
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: simp
state_before: case inl
ι : Type u
s : Finset ι
a b : ℝ≥0
hp : 0 ≤ 0
hp1 : 0 ≤ 1
⊢ (a + b) ^ 0 ≤ a ^ 0 + b ^ 0

tactic: rw [NNReal.rpow_one] at h
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
Theorem: Finsupp.mul_sum
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: simp only [Finsupp.sum, Finset.mul_sum]
state_before: α : Type u_1
ι : Type ?u.632330
γ : Type ?u.632333
A : Type ?u.632336
B : Type ?u.632339
C : Type ?u.632342
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.635472
M : Type ?u.635475
M' : Type ?u.635478
N : Type ?u.635481
P : Type ?u.635484
G : Type ?u.635487
H : Type ?u.635490
R : Type u_2
S : Type u_3
inst✝¹ : NonUnitalNonAssocSemiring R
inst✝ : NonUnitalNonAssocSemiring S
b : S
s : α →₀ R
f : α → R → S
⊢ b * sum s f = sum s fun a c => b * f a c
Theorem: Finset.prod_eq_mul_prod_diff_singleton
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: convert (s.prod_inter_mul_prod_diff {i} f).symm
state_before: ι : Type ?u.778920
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
⊢ ∏ x in s, f x = f i * ∏ x in s \ {i}, f x

tactic: simp [h]
state_before: case h.e'_3.h.e'_5
ι : Type ?u.778920
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
⊢ f i = ∏ x in s ∩ {i}, f x
Theorem: LinearMap.det_toLin'
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: simp only [← toLin_eq_toLin', det_toLin]
state_before: R : Type u_2
inst✝⁹ : CommRing R
M : Type ?u.566367
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
M' : Type ?u.566952
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M'
ι : Type u_1
inst✝⁴ : DecidableEq ι
inst✝³ : Fintype ι
e : Basis ι R M
A : Type ?u.567972
inst✝² : CommRing A
inst✝¹ : Module A M
κ : Type ?u.568470
inst✝ : Fintype κ
f : Matrix ι ι R
⊢ ↑LinearMap.det (↑toLin' f) = det f
Theorem: midpoint_zero_add
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: simp [sub_add_eq_sub_sub_swap]
state_before: R : Type u_2
V : Type u_1
V' : Type ?u.119583
P : Type ?u.119586
P' : Type ?u.119589
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z : P
x y : V
⊢ 0 -ᵥ x = y -ᵥ (x + y)
Theorem: Int.neg_nonpos_of_nonneg
File: Std/Data/Int/Lemmas.lean

tactic: have : -a ≤ -0 := Int.neg_le_neg h
state_before: a : Int
h : 0 ≤ a
⊢ -a ≤ 0

tactic: rwa [Int.neg_zero] at this
state_before: a : Int
h : 0 ≤ a
this : -a ≤ -0
⊢ -a ≤ 0
Theorem: Real.abs_log_mul_self_lt
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: have : 0 < 1 / x := by simpa only [one_div, inv_pos] using h1
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
⊢ abs (log x * x) < 1

tactic: replace := log_le_sub_one_of_pos this
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : 0 < 1 / x
⊢ abs (log x * x) < 1

tactic: replace : log (1 / x) < 1 / x := by linarith
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : log (1 / x) ≤ 1 / x - 1
⊢ abs (log x * x) < 1

tactic: rw [log_div one_ne_zero h1.ne', log_one, zero_sub, lt_div_iff h1] at this
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : log (1 / x) < 1 / x
⊢ abs (log x * x) < 1

tactic: have aux : 0 ≤ -log x * x := by
  refine' mul_nonneg _ h1.le
  rw [← log_inv]
  apply log_nonneg
  rw [← le_inv h1 zero_lt_one, inv_one]
  exact h2
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ abs (log x * x) < 1

tactic: rw [← abs_of_nonneg aux, neg_mul, abs_neg] at this
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
aux : 0 ≤ -log x * x
⊢ abs (log x * x) < 1

tactic: exact this
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : abs (log x * x) < 1
aux : 0 ≤ -log x * x
⊢ abs (log x * x) < 1

tactic: simpa only [one_div, inv_pos] using h1
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
⊢ 0 < 1 / x

tactic: linarith
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : log (1 / x) ≤ 1 / x - 1
⊢ log (1 / x) < 1 / x

tactic: refine' mul_nonneg _ h1.le
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 0 ≤ -log x * x

tactic: rw [← log_inv]
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 0 ≤ -log x

tactic: apply log_nonneg
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 0 ≤ log x⁻¹

tactic: rw [← le_inv h1 zero_lt_one, inv_one]
state_before: case hx
x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 1 ≤ x⁻¹

tactic: exact h2
state_before: case hx
x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ x ≤ 1
Theorem: IsSubgroup.inv_mem_iff
File: Mathlib/Deprecated/Subgroup.lean

tactic: simpa using hs.inv_mem h
state_before: G : Type u_1
H : Type ?u.12515
A : Type ?u.12518
a a₁ a₂ b c : G
inst✝ : Group G
s : Set G
hs : IsSubgroup s
h : a⁻¹ ∈ s
⊢ a ∈ s
Theorem: Finset.le_sup'_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← WithBot.coe_le_coe, coe_sup', Finset.le_sup_iff (WithBot.bot_lt_coe a)]
state_before: F : Type ?u.300601
α : Type u_1
β : Type ?u.300607
γ : Type ?u.300610
ι : Type u_2
κ : Type ?u.300616
inst✝ : LinearOrder α
s : Finset ι
H : Finset.Nonempty s
f : ι → α
a : α
⊢ a ≤ sup' s H f ↔ ∃ b, b ∈ s ∧ a ≤ f b

tactic: exact exists_congr (fun _ => and_congr_right' WithBot.coe_le_coe)
state_before: F : Type ?u.300601
α : Type u_1
β : Type ?u.300607
γ : Type ?u.300610
ι : Type u_2
κ : Type ?u.300616
inst✝ : LinearOrder α
s : Finset ι
H : Finset.Nonempty s
f : ι → α
a : α
⊢ (∃ b, b ∈ s ∧ ↑a ≤ (WithBot.some ∘ f) b) ↔ ∃ b, b ∈ s ∧ a ≤ f b
Theorem: Filter.map_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: simp [Filter.ext_iff, mem_prod_iff, mem_map_seq_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.29986
ι : Sort ?u.29989
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
m : α × β → γ
f : Filter α
g : Filter β
⊢ map m (f ×ˢ g) = seq (map (fun a b => m (a, b)) f) g

tactic: intro s
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.29986
ι : Sort ?u.29989
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
m : α × β → γ
f : Filter α
g : Filter β
⊢ ∀ (s : Set γ),
    (∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ t₁ ×ˢ t₂ ⊆ m ⁻¹' s) ↔
      ∃ t, t ∈ g ∧ ∃ x, x ∈ f ∧ ∀ (x_1 : α), x_1 ∈ x → ∀ (y : β), y ∈ t → m (x_1, y) ∈ s

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.29986
ι : Sort ?u.29989
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
m : α × β → γ
f : Filter α
g : Filter β
s : Set γ
⊢ (∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ t₁ ×ˢ t₂ ⊆ m ⁻¹' s) ↔
    ∃ t, t ∈ g ∧ ∃ x, x ∈ f ∧ ∀ (x_1 : α), x_1 ∈ x → ∀ (y : β), y ∈ t → m (x_1, y) ∈ s

tactic: exact fun ⟨t, ht, s, hs, h⟩ => ⟨s, hs, t, ht, fun x hx y hy => @h ⟨x, y⟩ ⟨hx, hy⟩⟩
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.29986
ι : Sort ?u.29989
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
m : α × β → γ
f : Filter α
g : Filter β
s : Set γ
⊢ (∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ t₁ ×ˢ t₂ ⊆ m ⁻¹' s) →
    ∃ t, t ∈ g ∧ ∃ x, x ∈ f ∧ ∀ (x_1 : α), x_1 ∈ x → ∀ (y : β), y ∈ t → m (x_1, y) ∈ s

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.29986
ι : Sort ?u.29989
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
m : α × β → γ
f : Filter α
g : Filter β
s : Set γ
⊢ (∃ t, t ∈ g ∧ ∃ x, x ∈ f ∧ ∀ (x_1 : α), x_1 ∈ x → ∀ (y : β), y ∈ t → m (x_1, y) ∈ s) →
    ∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ t₁ ×ˢ t₂ ⊆ m ⁻¹' s

tactic: exact fun ⟨s, hs, t, ht, h⟩ => ⟨t, ht, s, hs, fun ⟨x, y⟩ ⟨hx, hy⟩ => h x hx y hy⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.29986
ι : Sort ?u.29989
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
m : α × β → γ
f : Filter α
g : Filter β
s : Set γ
⊢ (∃ t, t ∈ g ∧ ∃ x, x ∈ f ∧ ∀ (x_1 : α), x_1 ∈ x → ∀ (y : β), y ∈ t → m (x_1, y) ∈ s) →
    ∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ t₁ ×ˢ t₂ ⊆ m ⁻¹' s
Theorem: PNat.modDivAux_spec
File: Mathlib/Data/PNat/Basic.lean

tactic: change (k : ℕ) + (k : ℕ) * (q + 1).pred = 0 + (k : ℕ) * (q + 1)
state_before: k : ℕ+
q : ℕ
x✝ : ¬(0 = 0 ∧ q + 1 = 0)
⊢ ↑(modDivAux k 0 (q + 1)).fst + ↑k * (modDivAux k 0 (q + 1)).snd = 0 + ↑k * (q + 1)

tactic: rw [Nat.pred_succ, Nat.mul_succ, zero_add, add_comm]
state_before: k : ℕ+
q : ℕ
x✝ : ¬(0 = 0 ∧ q + 1 = 0)
⊢ ↑k + ↑k * pred (q + 1) = 0 + ↑k * (q + 1)
Theorem: Finset.not_disjoint_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [not_imp, not_not]
state_before: α : Type u_1
β : Type ?u.52972
γ : Type ?u.52975
f : α → β
s t u : Finset α
a b x✝ : α
⊢ ¬(x✝ ∈ s → ¬x✝ ∈ t) ↔ x✝ ∈ s ∧ x✝ ∈ t
Theorem: Set.image_sub_const_Ioi
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_neg_add]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) '' Ioi b = Ioi (b - a)
Theorem: not_differentiableWithinAt_of_local_left_inverse_hasDerivWithinAt_zero
File: Mathlib/Analysis/Calculus/Deriv/Inverse.lean

tactic: intro hg
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g✝ : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s✝ t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
s t : Set 𝕜
ha : a ∈ s
hsu : UniqueDiffWithinAt 𝕜 s a
hf : HasDerivWithinAt f 0 t (g a)
hst : MapsTo g s t
hfg : f ∘ g =ᶠ[𝓝[s] a] id
⊢ ¬DifferentiableWithinAt 𝕜 g s a

tactic: have := (hf.comp a hg.hasDerivWithinAt hst).congr_of_eventuallyEq_of_mem hfg.symm ha
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g✝ : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s✝ t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
s t : Set 𝕜
ha : a ∈ s
hsu : UniqueDiffWithinAt 𝕜 s a
hf : HasDerivWithinAt f 0 t (g a)
hst : MapsTo g s t
hfg : f ∘ g =ᶠ[𝓝[s] a] id
hg : DifferentiableWithinAt 𝕜 g s a
⊢ False

tactic: simpa using hsu.eq_deriv _ this (hasDerivWithinAt_id _ _)
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g✝ : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s✝ t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
s t : Set 𝕜
ha : a ∈ s
hsu : UniqueDiffWithinAt 𝕜 s a
hf : HasDerivWithinAt f 0 t (g a)
hst : MapsTo g s t
hfg : f ∘ g =ᶠ[𝓝[s] a] id
hg : DifferentiableWithinAt 𝕜 g s a
this : HasDerivWithinAt id (0 * derivWithin g s a) s a
⊢ False
Theorem: CategoryTheory.WithInitial.liftStar_lift_map
File: Mathlib/CategoryTheory/WithTerminal.lean

tactic: erw [Category.id_comp, Category.comp_id]
state_before: C : Type u
inst✝¹ : Category C
D : Type u_1
inst✝ : Category D
Z : D
F : C ⥤ D
M : (x : C) → Z ⟶ F.obj x
hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y
x : C
⊢ (liftStar F M hM).hom ≫ (lift F M hM).map (Limits.IsInitial.to starInitial (incl.obj x)) =
    M x ≫ (inclLift F M hM).hom.app x

tactic: rfl
state_before: C : Type u
inst✝¹ : Category C
D : Type u_1
inst✝ : Category D
Z : D
F : C ⥤ D
M : (x : C) → Z ⟶ F.obj x
hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y
x : C
⊢ (lift F M hM).map (Limits.IsInitial.to starInitial (incl.obj x)) = M x
Theorem: Finset.map_subtype_embedding_Iic
File: Mathlib/Order/LocallyFinite.lean

tactic: rw [subtype_Iic_eq]
state_before: α : Type u_1
β : Type ?u.225442
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Iic a) = Iic ↑a

tactic: exact Finset.subtype_map_of_mem fun x hx => hp (mem_Iic.1 hx) a.prop
state_before: α : Type u_1
β : Type ?u.225442
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Iic ↑a)) = Iic ↑a
Theorem: Real.cosh_sq_sub_sinh_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x✝ y x : ℝ
⊢ cosh x ^ 2 - sinh x ^ 2 = 1

tactic: simp
state_before: x✝ y x : ℝ
⊢ ↑(cosh x ^ 2 - sinh x ^ 2) = ↑1
Theorem: Finset.multiplicativeEnergy_empty_left
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: simp [multiplicativeEnergy]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ multiplicativeEnergy ∅ t = 0
Theorem: nhdsWithin_pi_univ_eq
File: Mathlib/Topology/ContinuousOn.lean

tactic: simpa [nhdsWithin] using nhdsWithin_pi_eq finite_univ s x
state_before: α✝ : Type ?u.81510
β : Type ?u.81513
γ : Type ?u.81516
δ : Type ?u.81519
inst✝² : TopologicalSpace α✝
ι : Type u_1
α : ι → Type u_2
inst✝¹ : Finite ι
inst✝ : (i : ι) → TopologicalSpace (α i)
s : (i : ι) → Set (α i)
x : (i : ι) → α i
⊢ 𝓝[Set.pi univ s] x = ⨅ (i : ι), comap (fun x => x i) (𝓝[s i] x i)
Theorem: Submonoid.equivMapOfInjective_coe_mulEquiv
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: ext
state_before: M : Type u_1
N : Type u_2
P : Type ?u.176338
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.176359
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
e : M ≃* N
⊢ equivMapOfInjective S ↑e (_ : Function.Injective ↑e) = MulEquiv.submonoidMap e S

tactic: rfl
state_before: case h.a
M : Type u_1
N : Type u_2
P : Type ?u.176338
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.176359
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
e : M ≃* N
x✝ : { x // x ∈ S }
⊢ ↑(↑(equivMapOfInjective S ↑e (_ : Function.Injective ↑e)) x✝) = ↑(↑(MulEquiv.submonoidMap e S) x✝)
Theorem: FreeAbelianGroup.support_add
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: simp only [support, AddMonoidHom.map_add]
state_before: X : Type u_1
a b : FreeAbelianGroup X
⊢ support (a + b) ⊆ support a ∪ support b

tactic: apply Finsupp.support_add
state_before: X : Type u_1
a b : FreeAbelianGroup X
⊢ (↑toFinsupp a + ↑toFinsupp b).support ⊆ (↑toFinsupp a).support ∪ (↑toFinsupp b).support
Theorem: ZMod.neg_val'
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [Nat.mod_eq_of_lt (-a).val_lt]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ val (-a) = val (-a) % n

tactic: rw [Nat.ModEq, ← val_add, add_left_neg, tsub_add_cancel_of_le a.val_le, Nat.mod_self,
  val_zero]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ val (-a) + ?m.539514 a ≡ n - val a + ?m.539514 a [MOD n]
Theorem: Pmf.support_ofMultiset
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simp [mem_support_iff, hs]
state_before: α : Type u_1
β : Type ?u.178630
γ : Type ?u.178633
s : Multiset α
hs : s ≠ 0
⊢ ∀ (x : α), x ∈ support (ofMultiset s hs) ↔ x ∈ ↑(Multiset.toFinset s)
Theorem: decide_True'
File: Mathlib/Init/Logic.lean

tactic: simp
state_before: a b c d : Prop
p : ?m.25343
h : Decidable True
⊢ decide True = true
Theorem: wellFounded_lift₂_iff
File: Mathlib/Order/RelIso/Basic.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.45658
γ : Type ?u.45661
δ : Type ?u.45664
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
⊢ WellFounded (Quotient.lift₂ r H) ↔ WellFounded r

tactic: exact RelHomClass.wellFounded (Quotient.mkRelHom H)
state_before: case mp
α : Type u_1
β : Type ?u.45658
γ : Type ?u.45661
δ : Type ?u.45664
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
⊢ WellFounded (Quotient.lift₂ r H) → WellFounded r

tactic: refine' fun wf => ⟨fun q => _⟩
state_before: case mpr
α : Type u_1
β : Type ?u.45658
γ : Type ?u.45661
δ : Type ?u.45664
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
⊢ WellFounded r → WellFounded (Quotient.lift₂ r H)

tactic: obtain ⟨a, rfl⟩ := q.exists_rep
state_before: case mpr
α : Type u_1
β : Type ?u.45658
γ : Type ?u.45661
δ : Type ?u.45664
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
wf : WellFounded r
q : Quotient inst✝
⊢ Acc (Quotient.lift₂ r H) q

tactic: exact acc_lift₂_iff.2 (wf.apply a)
state_before: case mpr.intro
α : Type u_1
β : Type ?u.45658
γ : Type ?u.45661
δ : Type ?u.45664
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
wf : WellFounded r
a : α
⊢ Acc (Quotient.lift₂ r H) (Quotient.mk inst✝ a)
Theorem: Cardinal.aleph'_nat
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [aleph'_succ, aleph'_nat n, nat_succ]
state_before: n : ℕ
⊢ aleph' (succ ↑n) = ↑(Nat.succ n)
Theorem: PiToModule.fromEnd_injective
File: Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean

tactic: intro x y e
state_before: ι : Type u_3
inst✝³ : Fintype ι
M : Type u_1
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
b : ι → M
hb✝ hb : Submodule.span R (Set.range b) = ⊤
⊢ Function.Injective ↑(fromEnd R b)

tactic: ext m
state_before: ι : Type u_3
inst✝³ : Fintype ι
M : Type u_1
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
b : ι → M
hb✝ hb : Submodule.span R (Set.range b) = ⊤
x y : Module.End R M
e : ↑(fromEnd R b) x = ↑(fromEnd R b) y
⊢ x = y

tactic: obtain ⟨m, rfl⟩ : m ∈ LinearMap.range (Fintype.total R R b) := by
  rw [(Fintype.range_total R b).trans hb]
  exact Submodule.mem_top
state_before: case h
ι : Type u_3
inst✝³ : Fintype ι
M : Type u_1
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
b : ι → M
hb✝ hb : Submodule.span R (Set.range b) = ⊤
x y : Module.End R M
e : ↑(fromEnd R b) x = ↑(fromEnd R b) y
m : M
⊢ ↑x m = ↑y m

tactic: exact (LinearMap.congr_fun e m : _)
state_before: case h.intro
ι : Type u_3
inst✝³ : Fintype ι
M : Type u_1
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
b : ι → M
hb✝ hb : Submodule.span R (Set.range b) = ⊤
x y : Module.End R M
e : ↑(fromEnd R b) x = ↑(fromEnd R b) y
m : ι → R
⊢ ↑x (↑(↑(Fintype.total R R) b) m) = ↑y (↑(↑(Fintype.total R R) b) m)

tactic: rw [(Fintype.range_total R b).trans hb]
state_before: ι : Type u_3
inst✝³ : Fintype ι
M : Type u_1
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
b : ι → M
hb✝ hb : Submodule.span R (Set.range b) = ⊤
x y : Module.End R M
e : ↑(fromEnd R b) x = ↑(fromEnd R b) y
m : M
⊢ m ∈ LinearMap.range (↑(Fintype.total R R) b)

tactic: exact Submodule.mem_top
state_before: ι : Type u_3
inst✝³ : Fintype ι
M : Type u_1
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
b : ι → M
hb✝ hb : Submodule.span R (Set.range b) = ⊤
x y : Module.End R M
e : ↑(fromEnd R b) x = ↑(fromEnd R b) y
m : M
⊢ m ∈ ⊤
Theorem: Holor.mul_assoc
File: Mathlib/Data/Holor.lean

tactic: simp [cast_heq, mul_assoc0, assocLeft]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Semigroup α
x : Holor α ds₁
y : Holor α ds₂
z : Holor α ds₃
⊢ HEq (x ⊗ y ⊗ z) (x ⊗ (y ⊗ z))
Theorem: Int.cast_four
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: rw [cast_ofNat, Nat.cast_ofNat]
state_before: R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑↑4 = ↑4
Theorem: Measurable.map_prod_mk_right
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: apply measurable_of_measurable_coe
state_before: α : Type u_1
α' : Type ?u.2748751
β : Type u_2
β' : Type ?u.2748757
γ : Type ?u.2748760
E : Type ?u.2748763
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ✝ μ' : MeasureTheory.Measure α
ν ν' : MeasureTheory.Measure β
τ : MeasureTheory.Measure γ
inst✝¹ : NormedAddCommGroup E
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
⊢ Measurable fun y => map (fun x => (x, y)) μ

tactic: intro s hs
state_before: case h
α : Type u_1
α' : Type ?u.2748751
β : Type u_2
β' : Type ?u.2748757
γ : Type ?u.2748760
E : Type ?u.2748763
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ✝ μ' : MeasureTheory.Measure α
ν ν' : MeasureTheory.Measure β
τ : MeasureTheory.Measure γ
inst✝¹ : NormedAddCommGroup E
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
⊢ ∀ (s : Set (α × β)), MeasurableSet s → Measurable fun b => ↑↑(map (fun x => (x, b)) μ) s

tactic: simp_rw [map_apply measurable_prod_mk_right hs]
state_before: case h
α : Type u_1
α' : Type ?u.2748751
β : Type u_2
β' : Type ?u.2748757
γ : Type ?u.2748760
E : Type ?u.2748763
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ✝ μ' : MeasureTheory.Measure α
ν ν' : MeasureTheory.Measure β
τ : MeasureTheory.Measure γ
inst✝¹ : NormedAddCommGroup E
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
s : Set (α × β)
hs : MeasurableSet s
⊢ Measurable fun b => ↑↑(map (fun x => (x, b)) μ) s

tactic: exact measurable_measure_prod_mk_right hs
state_before: case h
α : Type u_1
α' : Type ?u.2748751
β : Type u_2
β' : Type ?u.2748757
γ : Type ?u.2748760
E : Type ?u.2748763
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ✝ μ' : MeasureTheory.Measure α
ν ν' : MeasureTheory.Measure β
τ : MeasureTheory.Measure γ
inst✝¹ : NormedAddCommGroup E
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
s : Set (α × β)
hs : MeasurableSet s
⊢ Measurable fun b => ↑↑μ ((fun x => (x, b)) ⁻¹' s)
Theorem: Mathlib.Meta.NormNum.isNat_natDiv
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: aesop
state_before: n✝¹ n✝ : ℕ
⊢ ↑n✝¹ / ↑n✝ = ↑(Nat.div n✝¹ n✝)