tasksource/leandojo huggingface dataset:
Theorem: MvPolynomial.weightedHomogeneousComponent_isWeightedHomogeneous
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

tactic: classical
intro d hd
contrapose! hd
rw [coeff_weightedHomogeneousComponent, if_neg hd]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
⊢ IsWeightedHomogeneous w (↑(weightedHomogeneousComponent w n) φ) n

tactic: intro d hd
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
⊢ IsWeightedHomogeneous w (↑(weightedHomogeneousComponent w n) φ) n

tactic: contrapose! hd
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
hd : coeff d (↑(weightedHomogeneousComponent w n) φ) ≠ 0
⊢ ↑(weightedDegree' w) d = n

tactic: rw [coeff_weightedHomogeneousComponent, if_neg hd]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
hd : ↑(weightedDegree' w) d ≠ n
⊢ coeff d (↑(weightedHomogeneousComponent w n) φ) = 0
Theorem: div_le_div_of_le_left
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv]
state_before: ι : Type ?u.62267
α : Type u_1
β : Type ?u.62273
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 ≤ a
hc : 0 < c
h : c ≤ b
⊢ a / b ≤ a / c

tactic: exact mul_le_mul_of_nonneg_left ((inv_le_inv (hc.trans_le h) hc).mpr h) ha
state_before: ι : Type ?u.62267
α : Type u_1
β : Type ?u.62273
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 ≤ a
hc : 0 < c
h : c ≤ b
⊢ a * b⁻¹ ≤ a * c⁻¹
Theorem: disjoint_sdiff_iff_le
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sup_sdiff_cancel_right hx]
state_before: α : Type u
β : Type ?u.13662
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y \ x ≤ x ⊔ y \ x

tactic: refine' le_trans (sup_le_sup_left sdiff_le z) _
state_before: α : Type u
β : Type ?u.13662
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y \ x ≤ y

tactic: rw [sup_eq_right.2 hz]
state_before: α : Type u
β : Type ?u.13662
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y ≤ y
Theorem: Set.image_update_uIcc
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simp_rw [uIcc, update_sup, update_inf]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Lattice (α i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
i : ι
a b : α i
⊢ Icc (update f i (a ⊓ b)) (update f i (a ⊔ b)) = uIcc (update f i a) (update f i b)
Theorem: List.map_append_bind_perm
File: Mathlib/Data/List/Perm.lean

tactic: simpa [← map_eq_bind] using bind_append_perm l (fun x => [f x]) g
state_before: α : Type uu
β : Type vv
l₁ l₂ l : List α
f : α → β
g : α → List β
⊢ map f l ++ List.bind l g ~ List.bind l fun x => f x :: g x
Theorem: Int.div_zero
File: Std/Data/Int/DivMod.lean

tactic: simp
state_before: a✝ : Nat
⊢ ofNat (a✝ / 0) = 0
Theorem: CategoryTheory.Discrete.functor_map
File: Mathlib/CategoryTheory/DiscreteCategory.lean

tactic: aesop_cat
state_before: α : Type u₁
C : Type u₂
inst✝ : Category C
I : Type u₁
F : I → C
i : Discrete I
f : i ⟶ i
⊢ (functor F).map f = 𝟙 (F i.as)
Theorem: Zspan.repr_ceil_apply
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: classical simp only [ceil, zsmul_eq_smul_cast K, b.repr.map_smul, Finsupp.single_apply,
  Finset.sum_apply', Basis.repr_self, Finsupp.smul_single', mul_one, Finset.sum_ite_eq', coe_sum,
  Finset.mem_univ, if_true, coe_smul_of_tower, Basis.restrictScalars_apply, LinearEquiv.map_sum]
state_before: E : Type u_3
ι : Type u_2
K : Type u_1
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
i : ι
⊢ ↑(↑b.repr ↑(ceil b m)) i = ↑⌈↑(↑b.repr m) i⌉

tactic: simp only [ceil, zsmul_eq_smul_cast K, b.repr.map_smul, Finsupp.single_apply,
Finset.sum_apply', Basis.repr_self, Finsupp.smul_single', mul_one, Finset.sum_ite_eq', coe_sum,
Finset.mem_univ, if_true, coe_smul_of_tower, Basis.restrictScalars_apply, LinearEquiv.map_sum]
state_before: E : Type u_3
ι : Type u_2
K : Type u_1
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
i : ι
⊢ ↑(↑b.repr ↑(ceil b m)) i = ↑⌈↑(↑b.repr m) i⌉
Theorem: Derivation.eqOn_adjoin
File: Mathlib/RingTheory/Derivation/Basic.lean

tactic: simp only [map_add, *]
state_before: R : Type u_3
inst✝⁵ : CommSemiring R
A : Type u_1
inst✝⁴ : CommSemiring A
inst✝³ : Algebra R A
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a b : A
s : Set A
h : Set.EqOn (↑D1) (↑D2) s
x✝ : A
hx✝ : x✝ ∈ ↑(adjoin R s)
x y : A
hx : ↑D1 x = ↑D2 x
hy : ↑D1 y = ↑D2 y
⊢ ↑D1 (x + y) = ↑D2 (x + y)

tactic: simp only [leibniz, *]
state_before: R : Type u_3
inst✝⁵ : CommSemiring R
A : Type u_1
inst✝⁴ : CommSemiring A
inst✝³ : Algebra R A
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a b : A
s : Set A
h : Set.EqOn (↑D1) (↑D2) s
x✝ : A
hx✝ : x✝ ∈ ↑(adjoin R s)
x y : A
hx : ↑D1 x = ↑D2 x
hy : ↑D1 y = ↑D2 y
⊢ ↑D1 (x * y) = ↑D2 (x * y)
Theorem: UniformSpace.Completion.dist_comm
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: refine' induction_on₂ x y _ _
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
⊢ dist x y = dist y x

tactic: exact isClosed_eq (Completion.continuous_dist continuous_fst continuous_snd)
    (Completion.continuous_dist continuous_snd continuous_fst)
state_before: case refine'_1
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
⊢ IsClosed {x | dist x.fst x.snd = dist x.snd x.fst}

tactic: intro a b
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
⊢ ∀ (a b : α), dist (↑α a) (↑α b) = dist (↑α b) (↑α a)

tactic: rw [Completion.dist_eq, Completion.dist_eq, dist_comm]
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
a b : α
⊢ dist (↑α a) (↑α b) = dist (↑α b) (↑α a)
Theorem: Cardinal.mul_eq_max_of_aleph0_le_left
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: cases' le_or_lt ℵ₀ b with hb hb
state_before: a b : Cardinal
h : ℵ₀ ≤ a
h' : b ≠ 0
⊢ a * b = max a b

tactic: refine' (mul_le_max_of_aleph0_le_left h).antisymm _
state_before: case inr
a b : Cardinal
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
⊢ a * b = max a b

tactic: have : b ≤ a := hb.le.trans h
state_before: case inr
a b : Cardinal
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
⊢ max a b ≤ a * b

tactic: rw [max_eq_left this]
state_before: case inr
a b : Cardinal
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ max a b ≤ a * b

tactic: convert mul_le_mul_left' (one_le_iff_ne_zero.mpr h') a
state_before: case inr
a b : Cardinal
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ a ≤ a * b

tactic: rw [mul_one]
state_before: case h.e'_3
a b : Cardinal
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ a = a * 1

tactic: exact mul_eq_max h hb
state_before: case inl
a b : Cardinal
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : ℵ₀ ≤ b
⊢ a * b = max a b
Theorem: div_helper
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

tactic: rw [div_mul_eq_mul_div, one_mul, div_mul_right _ h]
state_before: α : Type ?u.13686
M₀ : Type ?u.13689
G₀ : Type u_1
M₀' : Type ?u.13695
G₀' : Type ?u.13698
F : Type ?u.13701
F' : Type ?u.13704
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a b✝ c d b : G₀
h : a ≠ 0
⊢ 1 / (a * b) * a = 1 / b
Theorem: ENat.toNat_add
File: Mathlib/Data/ENat/Basic.lean

tactic: lift m to ℕ using hm
state_before: m✝ n✝ m n : ℕ∞
hm : m ≠ ⊤
hn : n ≠ ⊤
⊢ ↑toNat (m + n) = ↑toNat m + ↑toNat n

tactic: lift n to ℕ using hn
state_before: case intro
m✝ n✝ n : ℕ∞
hn : n ≠ ⊤
m : ℕ
⊢ ↑toNat (↑m + n) = ↑toNat ↑m + ↑toNat n

tactic: rfl
state_before: case intro.intro
m✝ n✝ : ℕ∞
m n : ℕ
⊢ ↑toNat (↑m + ↑n) = ↑toNat ↑m + ↑toNat ↑n
Theorem: MeasureTheory.Measure.toENNRealVectorMeasure_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: ext i
state_before: α : Type u_1
β : Type ?u.147666
m : MeasurableSpace α
⊢ toENNRealVectorMeasure 0 = 0

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.147666
m : MeasurableSpace α
i : Set α
⊢ MeasurableSet i → ↑(toENNRealVectorMeasure 0) i = ↑0 i
Theorem: DenseRange.subset_closure_image_preimage_of_isOpen
File: Mathlib/Topology/Basic.lean

tactic: rw [image_preimage_eq_inter_range]
state_before: α : Type ?u.175524
β : Type u_1
γ : Type ?u.175530
δ : Type ?u.175533
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
κ : Type u_2
ι : Type ?u.175548
f : κ → β
g : β → γ
hf : DenseRange f
s : Set β
hs : IsOpen s
⊢ s ⊆ closure (f '' (f ⁻¹' s))

tactic: exact hf.open_subset_closure_inter hs
state_before: α : Type ?u.175524
β : Type u_1
γ : Type ?u.175530
δ : Type ?u.175533
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
κ : Type u_2
ι : Type ?u.175548
f : κ → β
g : β → γ
hf : DenseRange f
s : Set β
hs : IsOpen s
⊢ s ⊆ closure (s ∩ range f)
Theorem: mem_closure_iff_nhds'
File: Mathlib/Topology/Basic.lean

tactic: simp only [mem_closure_iff_nhds, Set.inter_nonempty_iff_exists_right, SetCoe.exists, exists_prop]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
a : α
⊢ a ∈ closure s ↔ ∀ (t : Set α), t ∈ 𝓝 a → ∃ y, ↑y ∈ t
Theorem: EuclideanDomain.gcd_mul_lcm
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [lcm]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
⊢ gcd x y * lcm x y = x * y

tactic: by_cases h : gcd x y = 0
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
⊢ gcd x y * (x * y / gcd x y) = x * y

tactic: rcases gcd_dvd x y with ⟨⟨r, hr⟩, ⟨s, hs⟩⟩
state_before: case neg
R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
h : ¬gcd x y = 0
⊢ gcd x y * (x * y / gcd x y) = x * y

tactic: generalize gcd x y = g at h hr⊢
state_before: case neg.intro.intro.intro
R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
h : ¬gcd x y = 0
r : R
hr : x = gcd x y * r
s : R
hs : y = gcd x y * s
⊢ gcd x y * (x * y / gcd x y) = x * y

tactic: subst hr
state_before: case neg.intro.intro.intro
R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y r s : R
hs : y = gcd x y * s
g : R
h : ¬g = 0
hr : x = g * r
⊢ g * (x * y / g) = x * y

tactic: rw [mul_assoc, mul_div_cancel_left _ h]
state_before: case neg.intro.intro.intro
R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
y r s g : R
h : ¬g = 0
hs : y = gcd (g * r) y * s
⊢ g * (g * r * y / g) = g * r * y

tactic: rw [h, zero_mul]
state_before: case pos
R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
h : gcd x y = 0
⊢ gcd x y * (x * y / gcd x y) = x * y

tactic: rw [EuclideanDomain.gcd_eq_zero_iff] at h
state_before: case pos
R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
h : gcd x y = 0
⊢ 0 = x * y

tactic: rw [h.1, zero_mul]
state_before: case pos
R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
h : x = 0 ∧ y = 0
⊢ 0 = x * y
Theorem: Matrix.Nondegenerate.toLinearMap₂'
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: simpa only [toLinearMap₂'_apply'] using hx y
state_before: R : Type ?u.2676271
R₁ : Type u_2
R₂ : Type ?u.2676277
M✝ : Type ?u.2676280
M₁ : Type ?u.2676283
M₂ : Type ?u.2676286
M₁' : Type ?u.2676289
M₂' : Type ?u.2676292
n : Type ?u.2676295
m : Type ?u.2676298
n' : Type ?u.2676301
m' : Type ?u.2676304
ι : Type u_1
inst✝⁴ : CommRing R₁
inst✝³ : AddCommMonoid M₁
inst✝² : Module R₁ M₁
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
B : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁
M : Matrix ι ι R₁
h : Matrix.Nondegenerate M
x : ι → R₁
hx : ∀ (y : ι → R₁), ↑(↑(↑Matrix.toLinearMap₂' M) x) y = 0
y : ι → R₁
⊢ x ⬝ᵥ mulVec M y = 0
Theorem: Submonoid.LocalizationMap.lift_unique
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: ext
state_before: M : Type u_3
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
j : N →* P
hj : ∀ (x : M), ↑j (↑(toMap f) x) = ↑g x
⊢ lift f hg = j

tactic: rw [lift_spec, ← hj, ← hj, ← j.map_mul]
state_before: case h
M : Type u_3
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
j : N →* P
hj : ∀ (x : M), ↑j (↑(toMap f) x) = ↑g x
x✝ : N
⊢ ↑(lift f hg) x✝ = ↑j x✝

tactic: apply congr_arg
state_before: case h
M : Type u_3
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
j : N →* P
hj : ∀ (x : M), ↑j (↑(toMap f) x) = ↑g x
x✝ : N
⊢ ↑j (↑(toMap f) (sec f x✝).fst) = ↑j (↑(toMap f) ↑(sec f x✝).snd * x✝)

tactic: rw [← sec_spec']
state_before: case h.h
M : Type u_3
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
j : N →* P
hj : ∀ (x : M), ↑j (↑(toMap f) x) = ↑g x
x✝ : N
⊢ ↑(toMap f) (sec f x✝).fst = ↑(toMap f) ↑(sec f x✝).snd * x✝
Theorem: IsROrC.conj_smul
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [conj_eq_re_sub_im, conj_eq_re_sub_im, smul_re, smul_im, ofReal_mul, ofReal_mul,
  real_smul_eq_coe_mul r (_ - _), mul_sub, mul_assoc]
state_before: K : Type u_1
E : Type ?u.3206159
inst✝ : IsROrC K
r : ℝ
z : K
⊢ ↑(starRingEnd K) (r • z) = r • ↑(starRingEnd K) z
Theorem: Multiset.Ico_sub_Ico_right
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ico, Ico, Ico, ← Finset.sdiff_val, Finset.Ico_diff_Ico_right]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c✝ d a b c : α
⊢ Ico a b - Ico c b = Ico a (min b c)
Theorem: MeasureTheory.integral_sub
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.913636
𝕜 : Type ?u.913639
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f g : α → E
m : MeasurableSpace α
μ : Measure α
hf : Integrable f
hg : Integrable g
⊢ (∫ (a : α), f a - g a ∂μ) = (∫ (a : α), f a ∂μ) - ∫ (a : α), g a ∂μ

tactic: exact setToFun_sub (dominatedFinMeasAdditive_weightedSMul μ) hf hg
state_before: α : Type u_2
E : Type u_1
F : Type ?u.913636
𝕜 : Type ?u.913639
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f g : α → E
m : MeasurableSpace α
μ : Measure α
hf : Integrable f
hg : Integrable g
⊢ (if hf : Integrable fun a => f a - g a then ↑L1.integralCLM (Integrable.toL1 (fun a => f a - g a) hf) else 0) =
    (if hf : Integrable fun a => f a then ↑L1.integralCLM (Integrable.toL1 (fun a => f a) hf) else 0) -
      if hf : Integrable fun a => g a then ↑L1.integralCLM (Integrable.toL1 (fun a => g a) hf) else 0
Theorem: Polynomial.support_add
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ support (p + q) ⊆ support p ∪ support q

tactic: rcases q with ⟨⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ support ({ toFinsupp := toFinsupp✝ } + q) ⊆ support { toFinsupp := toFinsupp✝ } ∪ support q

tactic: simp only [← ofFinsupp_add, support]
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ support ({ toFinsupp := toFinsupp✝¹ } + { toFinsupp := toFinsupp✝ }) ⊆
    support { toFinsupp := toFinsupp✝¹ } ∪ support { toFinsupp := toFinsupp✝ }

tactic: exact support_add
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ (toFinsupp✝¹ + toFinsupp✝).support ⊆ toFinsupp✝¹.support ∪ toFinsupp✝.support
Theorem: CategoryTheory.Abelian.coimage_image_factorisation
File: Mathlib/CategoryTheory/Abelian/Images.lean

tactic: simp [coimageImageComparison]
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
P Q : C
f : P ⟶ Q
⊢ coimage.π f ≫ coimageImageComparison f ≫ image.ι f = f
Theorem: SemidirectProduct.hom_ext
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: rw [lift_unique f, lift_unique g]
state_before: N : Type u_2
G : Type u_1
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h :
  ∀ (g : G),
    MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑f₂ g))) f₁
f g : N ⋊[φ] G →* H
hl : MonoidHom.comp f inl = MonoidHom.comp g inl
hr : MonoidHom.comp f inr = MonoidHom.comp g inr
⊢ f = g

tactic: simp only [*]
state_before: N : Type u_2
G : Type u_1
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h :
  ∀ (g : G),
    MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑f₂ g))) f₁
f g : N ⋊[φ] G →* H
hl : MonoidHom.comp f inl = MonoidHom.comp g inl
hr : MonoidHom.comp f inr = MonoidHom.comp g inr
⊢ lift (MonoidHom.comp f inl) (MonoidHom.comp f inr)
      (_ :
        ∀ (x : G),
          MonoidHom.comp (MonoidHom.comp f inl) (MulEquiv.toMonoidHom (↑φ x)) =
            MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑(MonoidHom.comp f inr) x))) (MonoidHom.comp f inl)) =
    lift (MonoidHom.comp g inl) (MonoidHom.comp g inr)
      (_ :
        ∀ (x : G),
          MonoidHom.comp (MonoidHom.comp g inl) (MulEquiv.toMonoidHom (↑φ x)) =
            MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑(MonoidHom.comp g inr) x))) (MonoidHom.comp g inl))
Theorem: Complex.tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simpa only [arg_eq_pi_iff.2 ⟨hre, him⟩] using
  (continuousWithinAt_arg_of_re_neg_of_im_zero hre him).tendsto
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ Tendsto arg (𝓝[{z | 0 ≤ z.im}] z) (𝓝 π)
Theorem: ENNReal.add_biSup'
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [add_comm a, biSup_add' h]
state_before: α : Type ?u.131868
β : Type ?u.131871
γ : Type ?u.131874
a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
p : ι → Prop
h : ∃ i, p i
f : ι → ℝ≥0∞
⊢ (a + ⨆ (i : ι) (_ : p i), f i) = ⨆ (i : ι) (_ : p i), a + f i
Theorem: Ultrafilter.union_mem_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: simp only [← mem_coe, ← le_principal_iff, ← sup_principal, le_sup_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.11570
f g : Ultrafilter α
s t : Set α
p q : α → Prop
⊢ s ∪ t ∈ f ↔ s ∈ f ∨ t ∈ f
Theorem: Subtype.preimage_coe_nonempty
File: Mathlib/Data/Set/Image.lean

tactic: rw [inter_comm, ← image_preimage_coe, nonempty_image_iff]
state_before: α : Type u_1
s t : Set α
⊢ Set.Nonempty (val ⁻¹' t) ↔ Set.Nonempty (s ∩ t)
Theorem: Matrix.IsAdjMatrix.toGraph_compl_eq
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: ext (v w)
state_before: V : Type u_2
α : Type u_1
β : Type ?u.18379
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
h : IsAdjMatrix A
⊢ toGraph (_ : IsAdjMatrix (Matrix.compl A)) = toGraph hᶜ

tactic: cases' h.zero_or_one v w with h h <;> by_cases hvw : v = w <;> simp [Matrix.compl, h, hvw]
state_before: case Adj.h.h.a
V : Type u_2
α : Type u_1
β : Type ?u.18379
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
h : IsAdjMatrix A
v w : V
⊢ Adj (toGraph (_ : IsAdjMatrix (Matrix.compl A))) v w ↔ Adj (toGraph hᶜ) v w
Theorem: Filter.Tendsto.const_mul_atTop'
File: Mathlib/Order/Filter/Archimedean.lean

tactic: refine' tendsto_atTop.2 fun b => _
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
⊢ Tendsto (fun x => r * f x) l atTop

tactic: obtain ⟨n : ℕ, hn : 1 ≤ n • r⟩ := Archimedean.arch 1 hr
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
⊢ ∀ᶠ (a : α) in l, b ≤ r * f a

tactic: rw [nsmul_eq_mul'] at hn
state_before: case intro
α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
⊢ ∀ᶠ (a : α) in l, b ≤ r * f a

tactic: filter_upwards [tendsto_atTop.1 hf (n * max b 0)]with x hx
state_before: case intro
α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ r * ↑n
⊢ ∀ᶠ (a : α) in l, b ≤ r * f a

tactic: calc
  b ≤ 1 * max b 0 := by
  { rw [one_mul]
    exact le_max_left _ _ }
  _ ≤ r * n * max b 0 := by gcongr
  _ = r * (n * max b 0) := by rw [mul_assoc]
  _ ≤ r * f x := by gcongr
state_before: case h
α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ r * ↑n
x : α
hx : ↑n * max b 0 ≤ f x
⊢ b ≤ r * f x

tactic: gcongr
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ r * ↑n
x : α
hx : ↑n * max b 0 ≤ f x
⊢ 1 * max b 0 ≤ r * ↑n * max b 0

tactic: rw [mul_assoc]
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ r * ↑n
x : α
hx : ↑n * max b 0 ≤ f x
⊢ r * ↑n * max b 0 = r * (↑n * max b 0)

tactic: gcongr
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ r * ↑n
x : α
hx : ↑n * max b 0 ≤ f x
⊢ r * (↑n * max b 0) ≤ r * f x
Theorem: CategoryTheory.initial_mono
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

tactic: haveI := strict_initial t g
state_before: C : Type u
inst✝³ : Category C
A B✝ X X' Y Y' Z : C
inst✝² : HasFiniteProducts C
inst✝¹ : Exponentiable A
I B : C
t : IsInitial I
inst✝ : CartesianClosed C
Z✝ : C
g h : Z✝ ⟶ I
x✝ : g ≫ IsInitial.to t B = h ≫ IsInitial.to t B
⊢ g = h

tactic: haveI := strict_initial t h
state_before: C : Type u
inst✝³ : Category C
A B✝ X X' Y Y' Z : C
inst✝² : HasFiniteProducts C
inst✝¹ : Exponentiable A
I B : C
t : IsInitial I
inst✝ : CartesianClosed C
Z✝ : C
g h : Z✝ ⟶ I
x✝ : g ≫ IsInitial.to t B = h ≫ IsInitial.to t B
this : IsIso g
⊢ g = h

tactic: exact eq_of_inv_eq_inv (t.hom_ext _ _)
state_before: C : Type u
inst✝³ : Category C
A B✝ X X' Y Y' Z : C
inst✝² : HasFiniteProducts C
inst✝¹ : Exponentiable A
I B : C
t : IsInitial I
inst✝ : CartesianClosed C
Z✝ : C
g h : Z✝ ⟶ I
x✝ : g ≫ IsInitial.to t B = h ≫ IsInitial.to t B
this✝ : IsIso g
this : IsIso h
⊢ g = h