tasksource/leandojo huggingface dataset:
Theorem: Finset.untrop_sum'
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: convert Multiset.untrop_sum (s.val.map f)
state_before: R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → Tropical R
⊢ untrop (∑ i in s, f i) = inf s (untrop ∘ f)

tactic: simp only [Multiset.map_map, Function.comp_apply]
state_before: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → Tropical R
⊢ inf s (untrop ∘ f) = Multiset.inf (Multiset.map untrop (Multiset.map f s.val))

tactic: rfl
state_before: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → Tropical R
⊢ inf s (untrop ∘ f) = Multiset.inf (Multiset.map (fun x => untrop (f x)) s.val)
Theorem: toAdd_multiset_sum
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp [toAdd, ofAdd]
state_before: ι : Type ?u.1000663
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : AddCommMonoid α
s : Multiset (Multiplicative α)
⊢ ↑toAdd (Multiset.prod s) = Multiset.sum (Multiset.map (↑toAdd) s)

tactic: rfl
state_before: ι : Type ?u.1000663
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : AddCommMonoid α
s : Multiset (Multiplicative α)
⊢ Multiset.prod s = Multiset.sum s
Theorem: Set.preimage_div_preimage_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rintro _ ⟨_, _, _, _, rfl⟩
state_before: F : Type u_3
α : Type u_2
β : Type u_1
γ : Type ?u.158165
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
⊢ ↑m ⁻¹' s / ↑m ⁻¹' t ⊆ ↑m ⁻¹' (s / t)

tactic: exact ⟨_, _, ‹_›, ‹_›, (map_div m _ _).symm⟩
state_before: case intro.intro.intro.intro
F : Type u_3
α : Type u_2
β : Type u_1
γ : Type ?u.158165
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
w✝¹ w✝ : α
left✝¹ : w✝¹ ∈ ↑m ⁻¹' s
left✝ : w✝ ∈ ↑m ⁻¹' t
⊢ (fun x x_1 => x / x_1) w✝¹ w✝ ∈ ↑m ⁻¹' (s / t)
Theorem: Finset.prod_induction_nonempty
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp [nonempty_iff_ne_empty.mp nonempty]
state_before: ι : Type ?u.614536
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
M : Type u_1
inst✝ : CommMonoid M
f : α → M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
nonempty : Finset.Nonempty s
base : ∀ (x : α), x ∈ s → p (f x)
⊢ Multiset.map (fun x => f x) s.val ≠ ∅
Theorem: ProbabilityTheory.condCount_inter'
File: Mathlib/Probability/CondCount.lean

tactic: rw [← Set.inter_comm]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
⊢ ↑↑(condCount s) (t ∩ u) = ↑↑(condCount (s ∩ u)) t * ↑↑(condCount s) u

tactic: exact condCount_inter hs
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
⊢ ↑↑(condCount s) (u ∩ t) = ↑↑(condCount (s ∩ u)) t * ↑↑(condCount s) u
Theorem: Finset.inter_subset_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: intro a a_in
state_before: α : Type u_1
β : Type ?u.188858
γ : Type ?u.188861
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b : α
x y s t : Finset α
h : x ⊆ y
h' : s ⊆ t
⊢ x ∩ s ⊆ y ∩ t

tactic: rw [Finset.mem_inter] at a_in ⊢
state_before: α : Type u_1
β : Type ?u.188858
γ : Type ?u.188861
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b : α
x y s t : Finset α
h : x ⊆ y
h' : s ⊆ t
a : α
a_in : a ∈ x ∩ s
⊢ a ∈ y ∩ t

tactic: exact ⟨h a_in.1, h' a_in.2⟩
state_before: α : Type u_1
β : Type ?u.188858
γ : Type ?u.188861
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b : α
x y s t : Finset α
h : x ⊆ y
h' : s ⊆ t
a : α
a_in : a ∈ x ∧ a ∈ s
⊢ a ∈ y ∧ a ∈ t
Theorem: Zsqrtd.add_le_add_left
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [add_sub_add_left_eq_sub]
state_before: d : ℕ
a b : ℤ√↑d
ab : a ≤ b
c : ℤ√↑d
⊢ Nonneg (c + b - (c + a))

tactic: exact ab
state_before: d : ℕ
a b : ℤ√↑d
ab : a ≤ b
c : ℤ√↑d
⊢ Nonneg (b - a)
Theorem: Linarith.without_one_mul
File: Mathlib/Tactic/Linarith/Preprocessing.lean

tactic: rwa [one_mul] at h
state_before: M : Type u_1
inst✝ : MulOneClass M
a b : M
h : 1 * a = b
⊢ a = b
Theorem: Set.preimage_const_mul_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp only [← preimage_mul_const_uIcc ha, mul_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a : α
ha : a ≠ 0
b c : α
⊢ (fun x => a * x) ⁻¹' [[b, c]] = [[b / a, c / a]]
Theorem: CancelDenoms.cancel_factors_ne
File: Mathlib/Tactic/CancelDenoms.lean

tactic: classical
rw [eq_iff_iff, not_iff_not, cancel_factors_eq ha hb had hbd hgcd]
state_before: α : Type u_1
inst✝ : Field α
a b ad bd a' b' gcd : α
ha : ad * a = a'
hb : bd * b = b'
had : ad ≠ 0
hbd : bd ≠ 0
hgcd : gcd ≠ 0
⊢ (a ≠ b) = (1 / gcd * (bd * a') ≠ 1 / gcd * (ad * b'))

tactic: rw [eq_iff_iff, not_iff_not, cancel_factors_eq ha hb had hbd hgcd]
state_before: α : Type u_1
inst✝ : Field α
a b ad bd a' b' gcd : α
ha : ad * a = a'
hb : bd * b = b'
had : ad ≠ 0
hbd : bd ≠ 0
hgcd : gcd ≠ 0
⊢ (a ≠ b) = (1 / gcd * (bd * a') ≠ 1 / gcd * (ad * b'))
Theorem: WithTop.mul_coe
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: simp [hb]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
b : α
hb : b ≠ 0
⊢ (if ⊤ = 0 ∨ ↑b = 0 then 0 else ⊤) = ⊤

tactic: rw [some_eq_coe, ← coe_mul]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
b : α
hb : b ≠ 0
a : α
⊢ Option.some a * ↑b = Option.bind (Option.some a) fun a => Option.some (a * b)

tactic: rfl
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
b : α
hb : b ≠ 0
a : α
⊢ ↑(a * b) = Option.bind ↑a fun a => Option.some (a * b)
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_add
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [add_eq_map₂, map_setToSimpleFunc T h_add hp_pair]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.265062
G : Type ?u.265065
𝕜 : Type ?u.265068
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f g : α →ₛ E
hf : Integrable ↑f
hg : Integrable ↑g
hp_pair : Integrable ↑(pair f g)
⊢ setToSimpleFunc T (f + g) = ∑ x in SimpleFunc.range (pair f g), ↑(T (↑(pair f g) ⁻¹' {x})) (x.fst + x.snd)

tactic: simp
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.265062
G : Type ?u.265065
𝕜 : Type ?u.265068
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f g : α →ₛ E
hf : Integrable ↑f
hg : Integrable ↑g
hp_pair : Integrable ↑(pair f g)
⊢ 0.fst + 0.snd = 0

tactic: rw [Finset.sum_add_distrib]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.265062
G : Type ?u.265065
𝕜 : Type ?u.265068
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f g : α →ₛ E
hf : Integrable ↑f
hg : Integrable ↑g
hp_pair : Integrable ↑(pair f g)
⊢ ∑ x in SimpleFunc.range (pair f g), (↑(T (↑(pair f g) ⁻¹' {x})) x.fst + ↑(T (↑(pair f g) ⁻¹' {x})) x.snd) =
    ∑ x in SimpleFunc.range (pair f g), ↑(T (↑(pair f g) ⁻¹' {x})) x.fst +
      ∑ x in SimpleFunc.range (pair f g), ↑(T (↑(pair f g) ⁻¹' {x})) x.snd

tactic: rw [map_setToSimpleFunc T h_add hp_pair Prod.snd_zero,
  map_setToSimpleFunc T h_add hp_pair Prod.fst_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.265062
G : Type ?u.265065
𝕜 : Type ?u.265068
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f g : α →ₛ E
hf : Integrable ↑f
hg : Integrable ↑g
hp_pair : Integrable ↑(pair f g)
⊢ ∑ x in SimpleFunc.range (pair f g), ↑(T (↑(pair f g) ⁻¹' {x})) x.fst +
      ∑ x in SimpleFunc.range (pair f g), ↑(T (↑(pair f g) ⁻¹' {x})) x.snd =
    setToSimpleFunc T (map Prod.fst (pair f g)) + setToSimpleFunc T (map Prod.snd (pair f g))
Theorem: TopCat.openEmbedding_iff_isIso_comp'
File: Mathlib/Topology/Category/TopCat/Basic.lean

tactic: simp only [←Functor.map_comp]
state_before: X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding ((forget TopCat).map g)

tactic: exact openEmbedding_iff_isIso_comp f g
state_before: X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ((forget TopCat).map (f ≫ g)) ↔ OpenEmbedding ((forget TopCat).map g)
Theorem: Stream'.Seq.head_dropn
File: Mathlib/Data/Seq/Seq.lean

tactic: induction' n with n IH generalizing s
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ head (drop s n) = get? s n

tactic: rw [Nat.succ_eq_add_one, ← get?_tail, ← dropn_tail]
state_before: case succ
α : Type u
β : Type v
γ : Type w
s✝ : Seq α
n : ℕ
IH : ∀ (s : Seq α), head (drop s n) = get? s n
s : Seq α
⊢ head (drop s (Nat.succ n)) = get? s (Nat.succ n)

tactic: apply IH
state_before: case succ
α : Type u
β : Type v
γ : Type w
s✝ : Seq α
n : ℕ
IH : ∀ (s : Seq α), head (drop s n) = get? s n
s : Seq α
⊢ head (drop (tail s) n) = get? (tail s) n

tactic: rfl
state_before: case zero
α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ head (drop s Nat.zero) = get? s Nat.zero
Theorem: Finset.gcd_insert
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: by_cases h : b ∈ s
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.14340
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
⊢ gcd (insert b s) f = GCDMonoid.gcd (f b) (gcd s f)

tactic: apply fold_insert h
state_before: case neg
α : Type u_2
β : Type u_1
γ : Type ?u.14340
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
h : ¬b ∈ s
⊢ gcd (insert b s) f = GCDMonoid.gcd (f b) (gcd s f)

tactic: rw [insert_eq_of_mem h,
  (gcd_eq_right_iff (f b) (s.gcd f) (Multiset.normalize_gcd (s.1.map f))).2 (gcd_dvd h)]
state_before: case pos
α : Type u_2
β : Type u_1
γ : Type ?u.14340
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
h : b ∈ s
⊢ gcd (insert b s) f = GCDMonoid.gcd (f b) (gcd s f)
Theorem: Set.image_swap_prod
File: Mathlib/Data/Set/Prod.lean

tactic: rw [image_swap_eq_preimage_swap, preimage_swap_prod]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30722
δ : Type ?u.30725
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
⊢ Prod.swap '' s ×ˢ t = t ×ˢ s
Theorem: Equiv.Perm.prod_comp'
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: convert σ.prod_comp s (fun x => f x (σ.symm x)) hs
state_before: ι : Type ?u.298556
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
σ : Equiv.Perm α
s : Finset α
f : α → α → β
hs : {a | ↑σ a ≠ a} ⊆ ↑s
⊢ ∏ x in s, f (↑σ x) x = ∏ x in s, f x (↑σ.symm x)

tactic: rw [Equiv.symm_apply_apply]
state_before: case h.e'_2.a.h.e'_2
ι : Type ?u.298556
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
σ : Equiv.Perm α
s : Finset α
f : α → α → β
hs : {a | ↑σ a ≠ a} ⊆ ↑s
x✝ : α
a✝ : x✝ ∈ s
⊢ x✝ = ↑σ.symm (↑σ x✝)
Theorem: uniformEmbedding_inr
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: simpa using h
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set (β × β)
hs : s ∈ 𝓤 β
x : β × β
h : x ∈ Prod.map Sum.inr Sum.inr ⁻¹' (range (Prod.map Sum.inl Sum.inl) ∪ Prod.map Sum.inr Sum.inr '' s)
⊢ x ∈ s
Theorem: MvPolynomial.eval_indicator_apply_eq_one
File: Mathlib/FieldTheory/Finite/Polynomial.lean

tactic: nontriviality
state_before: K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : CommRing K
a : σ → K
⊢ ↑(eval a) (indicator a) = 1

tactic: have : 0 < Fintype.card K - 1 := tsub_pos_of_lt Fintype.one_lt_card
state_before: K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : CommRing K
a : σ → K
✝ : Nontrivial ((fun x => K) (indicator a))
⊢ ↑(eval a) (indicator a) = 1

tactic: simp only [indicator, map_prod, map_sub, map_one, map_pow, eval_X, eval_C, sub_self,
  zero_pow this, sub_zero, Finset.prod_const_one]
state_before: K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : CommRing K
a : σ → K
✝ : Nontrivial ((fun x => K) (indicator a))
this : 0 < Fintype.card K - 1
⊢ ↑(eval a) (indicator a) = 1
Theorem: Projectivization.submodule_injective
File: Mathlib/LinearAlgebra/ProjectiveSpace/Basic.lean

tactic: induction' u using ind with u hu
state_before: K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u v : ℙ K V
h : Projectivization.submodule u = Projectivization.submodule v
⊢ u = v

tactic: induction' v using ind with v hv
state_before: case h
K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u✝ v : ℙ K V
h✝ : Projectivization.submodule u✝ = Projectivization.submodule v
u : V
hu : u ≠ 0
h : Projectivization.submodule (mk K u hu) = Projectivization.submodule v
⊢ mk K u hu = v

tactic: rw [submodule_mk, submodule_mk, Submodule.span_singleton_eq_span_singleton] at h
state_before: case h.h
K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u✝ v✝ : ℙ K V
h✝² : Projectivization.submodule u✝ = Projectivization.submodule v✝
u : V
hu : u ≠ 0
h✝¹ : Projectivization.submodule (mk K u hu) = Projectivization.submodule v✝
v : V
hv : v ≠ 0
h✝ : Projectivization.submodule u✝ = Projectivization.submodule (mk K v hv)
h : Projectivization.submodule (mk K u hu) = Projectivization.submodule (mk K v hv)
⊢ mk K u hu = mk K v hv

tactic: exact ((mk_eq_mk_iff K v u hv hu).2 h).symm
state_before: case h.h
K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u✝ v✝ : ℙ K V
h✝² : Projectivization.submodule u✝ = Projectivization.submodule v✝
u : V
hu : u ≠ 0
h✝¹ : Projectivization.submodule (mk K u hu) = Projectivization.submodule v✝
v : V
hv : v ≠ 0
h✝ : Projectivization.submodule u✝ = Projectivization.submodule (mk K v hv)
h : ∃ z, z • u = v
⊢ mk K u hu = mk K v hv
Theorem: Equiv.finsetCongr_refl
File: Mathlib/Data/Finset/Image.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.154829
γ : Type ?u.154832
⊢ Equiv.finsetCongr (Equiv.refl α) = Equiv.refl (Finset α)

tactic: simp
state_before: case H.a
α : Type u_1
β : Type ?u.154829
γ : Type ?u.154832
x✝ : Finset α
a✝ : α
⊢ a✝ ∈ ↑(Equiv.finsetCongr (Equiv.refl α)) x✝ ↔ a✝ ∈ ↑(Equiv.refl (Finset α)) x✝
Theorem: IsClosed.not_mem_iff_infDist_pos
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [h.mem_iff_infDist_zero hs, infDist_nonneg.gt_iff_ne]
state_before: ι : Sort ?u.66060
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : IsClosed s
hs : Set.Nonempty s
⊢ ¬x ∈ s ↔ 0 < infDist x s
Theorem: Polynomial.content_monomial
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [← C_mul_X_pow_eq_monomial, content_C_mul, content_X_pow, mul_one]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
r : R
k : ℕ
⊢ content (↑(monomial k) r) = ↑normalize r
Theorem: MeasureTheory.snorm_measure_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: by_cases h0 : p = 0
state_before: α : Type u_1
E : Type ?u.951858
F : Type u_2
G : Type ?u.951864
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
⊢ snorm f p 0 = 0

tactic: by_cases h_top : p = ∞
state_before: case neg
α : Type u_1
E : Type ?u.951858
F : Type u_2
G : Type ?u.951864
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
h0 : ¬p = 0
⊢ snorm f p 0 = 0

tactic: rw [← Ne.def] at h0
state_before: case neg
α : Type u_1
E : Type ?u.951858
F : Type u_2
G : Type ?u.951864
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
h0 : ¬p = 0
h_top : ¬p = ⊤
⊢ snorm f p 0 = 0

tactic: simp [snorm_eq_snorm' h0 h_top, snorm', ENNReal.toReal_pos h0 h_top]
state_before: case neg
α : Type u_1
E : Type ?u.951858
F : Type u_2
G : Type ?u.951864
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ snorm f p 0 = 0

tactic: simp [h0]
state_before: case pos
α : Type u_1
E : Type ?u.951858
F : Type u_2
G : Type ?u.951864
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
h0 : p = 0
⊢ snorm f p 0 = 0

tactic: simp [h_top]
state_before: case pos
α : Type u_1
E : Type ?u.951858
F : Type u_2
G : Type ?u.951864
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
h0 : ¬p = 0
h_top : p = ⊤
⊢ snorm f p 0 = 0
Theorem: Real.cosh_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ cosh (x + y) = cosh x * cosh y + sinh x * sinh y

tactic: simp [cosh_add]
state_before: x y : ℝ
⊢ ↑(cosh (x + y)) = ↑(cosh x * cosh y + sinh x * sinh y)
Theorem: Matrix.det_conj
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← h.unit_spec, ← coe_units_inv, det_units_conj]
state_before: l : Type ?u.408621
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m m α
h : IsUnit M
N : Matrix m m α
⊢ det (M ⬝ N ⬝ M⁻¹) = det N
Theorem: MeasureTheory.set_average_eq'
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: simp only [average_eq', restrict_apply_univ]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.198493
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ : Measure α
s✝ : Set E
f : α → E
s : Set α
⊢ (⨍ (x : α) in s, f x ∂μ) = ∫ (x : α), f x ∂(↑↑μ s)⁻¹ • Measure.restrict μ s
Theorem: Set.image_pair
File: Mathlib/Data/Set/Image.lean

tactic: simp only [image_insert_eq, image_singleton]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.43908
ι : Sort ?u.43911
ι' : Sort ?u.43914
f✝ : α → β
s t : Set α
f : α → β
a b : α
⊢ f '' {a, b} = {f a, f b}
Theorem: Configuration.ProjectivePlane.two_lt_lineCount
File: Mathlib/Combinatorics/Configuration.lean

tactic: simpa only [lineCount_eq L p, Nat.succ_lt_succ_iff] using one_lt_order P L
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
⊢ 2 < lineCount L p
Theorem: Polynomial.trailingDegree_mul
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
⊢ trailingDegree (p * q) = trailingDegree p + trailingDegree q

tactic: by_cases hq : q = 0
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : ¬p = 0
⊢ trailingDegree (p * q) = trailingDegree p + trailingDegree q

tactic: rw [hp, MulZeroClass.zero_mul, trailingDegree_zero, top_add]
state_before: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : p = 0
⊢ trailingDegree (p * q) = trailingDegree p + trailingDegree q

tactic: rw [hq, MulZeroClass.mul_zero, trailingDegree_zero, add_top]
state_before: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : ¬p = 0
hq : q = 0
⊢ trailingDegree (p * q) = trailingDegree p + trailingDegree q

tactic: rw [trailingDegree_eq_natTrailingDegree hp, trailingDegree_eq_natTrailingDegree hq,
trailingDegree_eq_natTrailingDegree (mul_ne_zero hp hq), natTrailingDegree_mul hp hq]
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : ¬p = 0
hq : ¬q = 0
⊢ trailingDegree (p * q) = trailingDegree p + trailingDegree q

tactic: apply WithTop.coe_add
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : ¬p = 0
hq : ¬q = 0
⊢ ↑(natTrailingDegree p + natTrailingDegree q) = ↑(natTrailingDegree p) + ↑(natTrailingDegree q)
Theorem: Nat.decreasingInduction_self
File: Mathlib/Data/Nat/Basic.lean

tactic: dsimp only [decreasingInduction]
state_before: m n✝ k : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
n : ℕ
nn : n ≤ n
hP : P n
⊢ decreasingInduction h nn hP = hP

tactic: rw [leRecOn_self]
state_before: m n✝ k : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
n : ℕ
nn : n ≤ n
hP : P n
⊢ leRecOn nn (fun {k} ih hsk => ih (h k hsk)) (fun h => h) hP = hP
Theorem: Monoid.closure_subset
File: Mathlib/Deprecated/Submonoid.lean

tactic: induction ha <;> simp [h _, *, IsSubmonoid.one_mem, IsSubmonoid.mul_mem]
state_before: M : Type u_1
inst✝¹ : Monoid M
s✝ : Set M
A : Type ?u.62775
inst✝ : AddMonoid A
t✝ : Set A
s t : Set M
ht : IsSubmonoid t
h : s ⊆ t
a : M
ha : a ∈ Closure s
⊢ a ∈ t
Theorem: Finset.prod_Ico_add'
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [← map_add_right_Ico, prod_map]
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → β
inst✝³ : CommMonoid β
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
f : α → β
a b c : α
⊢ ∏ x in Ico a b, f (x + c) = ∏ x in Ico (a + c) (b + c), f x

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → β
inst✝³ : CommMonoid β
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
f : α → β
a b c : α
⊢ ∏ x in Ico a b, f (x + c) = ∏ x in Ico a b, f (↑(addRightEmbedding c) x)
Theorem: Zsqrtd.decompose
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp [ext]
state_before: d x y : ℤ
⊢ { re := x, im := y } = ↑x + sqrtd * ↑y
Theorem: LocalHomeomorph.IsImage.map_nhdsWithin_eq
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [e.map_nhdsWithin_eq hx, h.image_eq, e.nhdsWithin_target_inter (e.map_source hx)]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.44482
δ : Type ?u.44485
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
s : Set α
t : Set β
x : α
y : β
h : IsImage e s t
hx : x ∈ e.source
⊢ map (↑e) (𝓝[s] x) = 𝓝[t] ↑e x
Theorem: Polynomial.nextCoeff_of_pos_natDegree
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [nextCoeff, if_neg]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p : R[X]
hp : 0 < natDegree p
⊢ nextCoeff p = coeff p (natDegree p - 1)

tactic: contrapose! hp
state_before: case hnc
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p : R[X]
hp : 0 < natDegree p
⊢ ¬natDegree p = 0

tactic: simpa
state_before: case hnc
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p : R[X]
hp : natDegree p = 0
⊢ natDegree p ≤ 0