tasksource/leandojo huggingface dataset:
Theorem: dual_solid
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: apply solid
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ ‖a‖ ≤ ‖b‖

tactic: rw [abs_eq_sup_neg]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ abs a ≤ abs b

tactic: nth_rw 1 [← neg_neg a]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ a ⊔ -a ≤ abs b

tactic: rw [← neg_inf_eq_sup_neg]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ - -a ⊔ -a ≤ abs b

tactic: rw [abs_eq_sup_neg]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ abs b

tactic: nth_rw 1 [← neg_neg b]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ b ⊔ -b

tactic: rwa [← neg_inf_eq_sup_neg, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ - -b ⊔ -b
Theorem: integral_sin_pow
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: have : n + 2 ≠ 0 := by linarith
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) =
    (sin a ^ (n + 1) * cos a - sin b ^ (n + 1) * cos b) / (↑n + 2) + (↑n + 1) / (↑n + 2) * ∫ (x : ℝ) in a..b, sin x ^ n

tactic: have : (n : ℝ) + 2 ≠ 0 := by norm_cast
state_before: a b : ℝ
n : ℕ
this : n + 2 ≠ 0
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) =
    (sin a ^ (n + 1) * cos a - sin b ^ (n + 1) * cos b) / (↑n + 2) + (↑n + 1) / (↑n + 2) * ∫ (x : ℝ) in a..b, sin x ^ n

tactic: field_simp
state_before: a b : ℝ
n : ℕ
this✝ : n + 2 ≠ 0
this : ↑n + 2 ≠ 0
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) =
    (sin a ^ (n + 1) * cos a - sin b ^ (n + 1) * cos b) / (↑n + 2) + (↑n + 1) / (↑n + 2) * ∫ (x : ℝ) in a..b, sin x ^ n

tactic: convert eq_sub_iff_add_eq.mp (integral_sin_pow_aux n) using 1
state_before: a b : ℝ
n : ℕ
this✝ : n + 2 ≠ 0
this : ↑n + 2 ≠ 0
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) * (↑n + 2) =
    sin a ^ (n + 1) * cos a - sin b ^ (n + 1) * cos b + (↑n + 1) * ∫ (x : ℝ) in a..b, sin x ^ n

tactic: ring
state_before: case h.e'_2
a b : ℝ
n : ℕ
this✝ : n + 2 ≠ 0
this : ↑n + 2 ≠ 0
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) * (↑n + 2) =
    (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) + (↑n + 1) * ∫ (x : ℝ) in a..b, sin x ^ (n + 2)

tactic: linarith
state_before: a b : ℝ
n : ℕ
⊢ n + 2 ≠ 0

tactic: norm_cast
state_before: a b : ℝ
n : ℕ
this : n + 2 ≠ 0
⊢ ↑n + 2 ≠ 0
Theorem: Cardinal.cantorFunctionAux_nonneg
File: Mathlib/Data/Real/Cardinality.lean

tactic: cases h' : f n <;> simp [h']
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h : 0 ≤ c
⊢ 0 ≤ cantorFunctionAux c f n

tactic: apply pow_nonneg h
state_before: case true
c : ℝ
f g : ℕ → Bool
n : ℕ
h : 0 ≤ c
h' : f n = true
⊢ 0 ≤ c ^ n
Theorem: Nat.binomial_spec
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: simpa [Finset.sum_pair hab, Finset.prod_pair hab] using multinomial_spec {a, b} f
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
hab : a ≠ b
⊢ (f a)! * (f b)! * multinomial {a, b} f = (f a + f b)!
Theorem: CategoryTheory.NatIso.cancel_natIso_inv_right
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp only [cancel_mono, refl]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
α : F ≅ G
X : D
Y : C
f f' : X ⟶ G.obj Y
⊢ f ≫ α.inv.app Y = f' ≫ α.inv.app Y ↔ f = f'
Theorem: Finset.eraseNone_map_some
File: Mathlib/Data/Finset/Option.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.9818
s : Finset α
⊢ ↑eraseNone (map Embedding.some s) = s

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.9818
s : Finset α
a✝ : α
⊢ a✝ ∈ ↑eraseNone (map Embedding.some s) ↔ a✝ ∈ s
Theorem: ZFSet.mem_range
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: constructor
state_before: α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
⊢ Quotient.mk setoid y ∈ range f ↔ Quotient.mk setoid y ∈ Set.range f

tactic: rintro ⟨z, hz⟩
state_before: case mp
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
⊢ Quotient.mk setoid y ∈ range f → Quotient.mk setoid y ∈ Set.range f

tactic: exact ⟨z.down, Quotient.eq_mk_iff_out.2 hz.symm⟩
state_before: case mp.intro
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : Type (PSet.mk (ULift α) (Quotient.out ∘ f ∘ ULift.down))
hz : PSet.Equiv y (Func (PSet.mk (ULift α) (Quotient.out ∘ f ∘ ULift.down)) z)
⊢ Quotient.mk setoid y ∈ Set.range f

tactic: rintro ⟨z, hz⟩
state_before: case mpr
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
⊢ Quotient.mk setoid y ∈ Set.range f → Quotient.mk setoid y ∈ range f

tactic: use ULift.up z
state_before: case mpr.intro
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : α
hz : f z = Quotient.mk setoid y
⊢ Quotient.mk setoid y ∈ range f

tactic: simpa [hz] using PSet.Equiv.symm (Quotient.mk_out y)
state_before: case mpr.intro
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : α
hz : f z = Quotient.mk setoid y
⊢ PSet.Equiv y (Func (PSet.mk (ULift α) (Quotient.out ∘ f ∘ ULift.down)) { down := z })
Theorem: MeasureTheory.measure_union₀_aux
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [union_eq_iUnion, measure_iUnion₀, tsum_fintype, Fintype.sum_bool, cond, cond]
state_before: ι : Type ?u.12592
α : Type u_1
β : Type ?u.12598
γ : Type ?u.12601
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s
ht : NullMeasurableSet t
hd : AEDisjoint μ s t
⊢ ↑↑μ (s ∪ t) = ↑↑μ s + ↑↑μ t

tactic: exacts [(pairwise_on_bool AEDisjoint.symmetric).2 hd, fun b => Bool.casesOn b ht hs]
state_before: case hd
ι : Type ?u.12592
α : Type u_1
β : Type ?u.12598
γ : Type ?u.12601
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s
ht : NullMeasurableSet t
hd : AEDisjoint μ s t
⊢ Pairwise (AEDisjoint μ on fun b => bif b then s else t)

case h
ι : Type ?u.12592
α : Type u_1
β : Type ?u.12598
γ : Type ?u.12601
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s
ht : NullMeasurableSet t
hd : AEDisjoint μ s t
⊢ ∀ (i : Bool), NullMeasurableSet (bif i then s else t)
Theorem: factorization_mul
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp [factorization, normalizedFactors_mul ha hb]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
a b : α
ha : a ≠ 0
hb : b ≠ 0
⊢ factorization (a * b) = factorization a + factorization b
Theorem: LieIdeal.comap_bracket_le
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [← map_le_iff_le_comap]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J J₁ J₂ : LieIdeal R L'
⊢ ⁅comap f J₁, comap f J₂⁆ ≤ comap f ⁅J₁, J₂⁆

tactic: exact le_trans (map_bracket_le f) (LieSubmodule.mono_lie _ _ _ _ map_comap_le map_comap_le)
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J J₁ J₂ : LieIdeal R L'
⊢ map f ⁅comap f J₁, comap f J₂⁆ ≤ ⁅J₁, J₂⁆
Theorem: SModEq.bot
File: Mathlib/LinearAlgebra/SModEq.lean

tactic: rw [SModEq.def, Submodule.Quotient.eq, mem_bot, sub_eq_zero]
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
U U₁ U₂ : Submodule R M
x x₁ x₂ y y₁ y₂ z z₁ z₂ : M
N : Type ?u.37082
inst✝¹ : AddCommGroup N
inst✝ : Module R N
V V₁ V₂ : Submodule R N
⊢ x ≡ y [SMOD ⊥] ↔ x = y
Theorem: Finset.eq_affineCombination_subset_iff_eq_affineCombination_subtype
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [affineCombination_apply, eq_vadd_iff_vsub_eq]
state_before: k : Type u_2
V : Type u_4
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s✝ : Finset ι
ι₂ : Type ?u.394352
s₂ : Finset ι₂
p0 : P
s : Set ι
p : ι → P
⊢ (∃ fs x w x, p0 = ↑(affineCombination k fs p) w) ↔ ∃ fs w x, p0 = ↑(affineCombination k fs fun i => p ↑i) w

tactic: exact eq_weightedVSubOfPoint_subset_iff_eq_weightedVSubOfPoint_subtype
state_before: k : Type u_2
V : Type u_4
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s✝ : Finset ι
ι₂ : Type ?u.394352
s₂ : Finset ι₂
p0 : P
s : Set ι
p : ι → P
⊢ (∃ fs h w h,
      p0 -ᵥ Classical.choice (_ : Nonempty P) = ↑(weightedVSubOfPoint fs p (Classical.choice (_ : Nonempty P))) w) ↔
    ∃ fs w h,
      p0 -ᵥ Classical.choice (_ : Nonempty P) =
        ↑(weightedVSubOfPoint fs (fun i => p ↑i) (Classical.choice (_ : Nonempty P))) w
Theorem: normalize_coe_units
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
u : αˣ
⊢ ↑normalize ↑u = 1
Theorem: Finset.mem_diag
File: Mathlib/Data/Finset/Prod.lean

tactic: simp (config := { contextual := true }) [diag]
state_before: α : Type u_1
β : Type ?u.94346
γ : Type ?u.94349
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ x ∈ diag s ↔ x.fst ∈ s ∧ x.fst = x.snd
Theorem: CauchyFilter.extend_pureCauchy
File: Mathlib/Topology/UniformSpace/Completion.lean

tactic: rw [extend, if_pos hf]
state_before: α : Type u
inst✝³ : UniformSpace α
β : Type v
γ : Type w
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : UniformContinuous f
a : α
⊢ extend f (pureCauchy a) = f a

tactic: exact uniformly_extend_of_ind uniformInducing_pureCauchy denseRange_pureCauchy hf _
state_before: α : Type u
inst✝³ : UniformSpace α
β : Type v
γ : Type w
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : UniformContinuous f
a : α
⊢ DenseInducing.extend (_ : DenseInducing pureCauchy) f (pureCauchy a) = f a
Theorem: Finset.Ioo_subset_Ioc_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_subset, coe_Ioo, coe_Ioc]
state_before: ι : Type ?u.24009
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Ioo a b ⊆ Ioc a b

tactic: exact Set.Ioo_subset_Ioc_self
state_before: ι : Type ?u.24009
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.Ioo a b ⊆ Set.Ioc a b
Theorem: mul_pow_le_nat_floor_pow
File: Mathlib/Analysis/SpecificLimits/FloorPow.lean

tactic: have cpos : 0 < c := zero_lt_one.trans hc
state_before: c : ℝ
hc : 1 < c
i : ℕ
⊢ (1 - c⁻¹) * c ^ i ≤ ↑⌊c ^ i⌋₊

tactic: rcases Nat.eq_zero_or_pos i with (rfl | hi)
state_before: c : ℝ
hc : 1 < c
i : ℕ
cpos : 0 < c
⊢ (1 - c⁻¹) * c ^ i ≤ ↑⌊c ^ i⌋₊

tactic: have hident : 1 ≤ i := hi
state_before: case inr
c : ℝ
hc : 1 < c
i : ℕ
cpos : 0 < c
hi : i > 0
⊢ (1 - c⁻¹) * c ^ i ≤ ↑⌊c ^ i⌋₊

tactic: calc
  (1 - c⁻¹) * c ^ i = c ^ i - c ^ i * c⁻¹ := by ring
  _ ≤ c ^ i - 1 := by
    simpa only [← div_eq_mul_inv, sub_le_sub_iff_left, one_le_div cpos, pow_one] using
      pow_le_pow hc.le hident
  _ ≤ ⌊c ^ i⌋₊ := (Nat.sub_one_lt_floor _).le
state_before: case inr
c : ℝ
hc : 1 < c
i : ℕ
cpos : 0 < c
hi : i > 0
hident : 1 ≤ i
⊢ (1 - c⁻¹) * c ^ i ≤ ↑⌊c ^ i⌋₊

tactic: simp only [pow_zero, Nat.floor_one, Nat.cast_one, mul_one, sub_le_self_iff, inv_nonneg, cpos.le]
state_before: case inl
c : ℝ
hc : 1 < c
cpos : 0 < c
⊢ (1 - c⁻¹) * c ^ 0 ≤ ↑⌊c ^ 0⌋₊

tactic: ring
state_before: c : ℝ
hc : 1 < c
i : ℕ
cpos : 0 < c
hi : i > 0
hident : 1 ≤ i
⊢ (1 - c⁻¹) * c ^ i = c ^ i - c ^ i * c⁻¹

tactic: simpa only [← div_eq_mul_inv, sub_le_sub_iff_left, one_le_div cpos, pow_one] using
  pow_le_pow hc.le hident
state_before: c : ℝ
hc : 1 < c
i : ℕ
cpos : 0 < c
hi : i > 0
hident : 1 ≤ i
⊢ c ^ i - c ^ i * c⁻¹ ≤ c ^ i - 1
Theorem: minpoly.aeval_ne_zero_of_dvdNotUnit_minpoly
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: refine' fun ha => (min A x hamonic ha).not_lt (degree_lt_degree _)
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.144402
inst✝² : CommRing A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
a : A[X]
hx : IsIntegral A x
hamonic : Monic a
hdvd : DvdNotUnit a (minpoly A x)
⊢ ↑(Polynomial.aeval x) a ≠ 0

tactic: obtain ⟨_, c, hu, he⟩ := hdvd
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.144402
inst✝² : CommRing A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
a : A[X]
hx : IsIntegral A x
hamonic : Monic a
hdvd : DvdNotUnit a (minpoly A x)
ha : ↑(Polynomial.aeval x) a = 0
⊢ natDegree a < natDegree (minpoly A x)

tactic: have hcm := hamonic.of_mul_monic_left (he.subst <| monic hx)
state_before: case intro.intro.intro
A : Type u_1
B : Type u_2
B' : Type ?u.144402
inst✝² : CommRing A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
a : A[X]
hx : IsIntegral A x
hamonic : Monic a
ha : ↑(Polynomial.aeval x) a = 0
left✝ : a ≠ 0
c : A[X]
hu : ¬IsUnit c
he : minpoly A x = a * c
⊢ natDegree a < natDegree (minpoly A x)

tactic: rw [he, hamonic.natDegree_mul hcm]
state_before: case intro.intro.intro
A : Type u_1
B : Type u_2
B' : Type ?u.144402
inst✝² : CommRing A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
a : A[X]
hx : IsIntegral A x
hamonic : Monic a
ha : ↑(Polynomial.aeval x) a = 0
left✝ : a ≠ 0
c : A[X]
hu : ¬IsUnit c
he : minpoly A x = a * c
hcm : Monic c
⊢ natDegree a < natDegree (minpoly A x)

tactic: apply lt_add_of_pos_right
state_before: case intro.intro.intro
A : Type u_1
B : Type u_2
B' : Type ?u.144402
inst✝² : CommRing A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
a : A[X]
hx : IsIntegral A x
hamonic : Monic a
ha : ↑(Polynomial.aeval x) a = 0
left✝ : a ≠ 0
c : A[X]
hu : ¬IsUnit c
he : minpoly A x = a * c
hcm : Monic c
⊢ natDegree a < natDegree a + natDegree c

tactic: refine (lt_of_not_le fun h => hu ?_)
state_before: case intro.intro.intro.h
A : Type u_1
B : Type u_2
B' : Type ?u.144402
inst✝² : CommRing A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
a : A[X]
hx : IsIntegral A x
hamonic : Monic a
ha : ↑(Polynomial.aeval x) a = 0
left✝ : a ≠ 0
c : A[X]
hu : ¬IsUnit c
he : minpoly A x = a * c
hcm : Monic c
⊢ 0 < natDegree c

tactic: rw [eq_C_of_natDegree_le_zero h, ← Nat.eq_zero_of_le_zero h, ← leadingCoeff, hcm.leadingCoeff,
  C_1]
state_before: case intro.intro.intro.h
A : Type u_1
B : Type u_2
B' : Type ?u.144402
inst✝² : CommRing A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
a : A[X]
hx : IsIntegral A x
hamonic : Monic a
ha : ↑(Polynomial.aeval x) a = 0
left✝ : a ≠ 0
c : A[X]
hu : ¬IsUnit c
he : minpoly A x = a * c
hcm : Monic c
h : natDegree c ≤ 0
⊢ IsUnit c

tactic: exact isUnit_one
state_before: case intro.intro.intro.h
A : Type u_1
B : Type u_2
B' : Type ?u.144402
inst✝² : CommRing A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
a : A[X]
hx : IsIntegral A x
hamonic : Monic a
ha : ↑(Polynomial.aeval x) a = 0
left✝ : a ≠ 0
c : A[X]
hu : ¬IsUnit c
he : minpoly A x = a * c
hcm : Monic c
h : natDegree c ≤ 0
⊢ IsUnit 1
Theorem: MvPolynomial.support_X
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: classical rw [X, support_monomial, if_neg]; exact one_ne_zero
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ support (X n) = {Finsupp.single n 1}

tactic: rw [X, support_monomial, if_neg]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ support (X n) = {Finsupp.single n 1}

tactic: exact one_ne_zero
state_before: case hnc
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ ¬1 = 0
Theorem: Filter.tendsto_const_mul_atBot_iff_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [tendsto_const_mul_atBot_iff, h, h.not_tendsto disjoint_atBot_atTop]
state_before: ι : Type ?u.242288
ι' : Type ?u.242291
α : Type u_2
β : Type u_1
γ : Type ?u.242300
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : NeBot l
h : Tendsto f l atBot
⊢ Tendsto (fun x => r * f x) l atBot ↔ 0 < r
Theorem: AddCommGroup.modEq_iff_eq_add_zsmul
File: Mathlib/Algebra/ModEq.lean

tactic: simp_rw [ModEq, sub_eq_iff_eq_add']
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a ≡ b [PMOD p] ↔ ∃ z, b = a + z • p
Theorem: Stream'.WSeq.dropn_congr
File: Mathlib/Data/Seq/WSeq.lean

tactic: induction n <;> simp [*, tail_congr, drop]
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
n : ℕ
⊢ drop s n ~ʷ drop t n
Theorem: sSup_compact_le_eq
File: Mathlib/Order/CompactlyGenerated.lean

tactic: rcases IsCompactlyGenerated.exists_sSup_eq b with ⟨s, hs, rfl⟩
state_before: ι : Sort ?u.86401
α : Type u_1
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b✝ : α
s : Set α
b : α
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ b} = b

tactic: exact le_antisymm (sSup_le fun c hc => hc.2) (sSup_le_sSup fun c cs => ⟨hs c cs, le_sSup cs⟩)
state_before: case intro.intro
ι : Sort ?u.86401
α : Type u_1
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s✝ s : Set α
hs : ∀ (x : α), x ∈ s → CompleteLattice.IsCompactElement x
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ sSup s} = sSup s
Theorem: Filter.not_disjoint_self_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [disjoint_self, neBot_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.62551
ι : Sort x
f g : Filter α
s t : Set α
⊢ ¬Disjoint f f ↔ NeBot f
Theorem: AddCommGroup.modEq_comm
File: Mathlib/Algebra/ModEq.lean

tactic: simp [ModEq, ← neg_eq_iff_eq_neg]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ (∃ b_1, b - a = ↑(Equiv.neg ℤ).symm b_1 • p) ↔ b ≡ a [PMOD p]
Theorem: MeasureTheory.Measure.restrict_sUnion_congr
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [sUnion_eq_biUnion, restrict_biUnion_congr hc]
state_before: α : Type u_1
β : Type ?u.317105
γ : Type ?u.317108
δ : Type ?u.317111
ι : Type ?u.317114
R : Type ?u.317117
R' : Type ?u.317120
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
S : Set (Set α)
hc : Set.Countable S
⊢ restrict μ (⋃₀ S) = restrict ν (⋃₀ S) ↔ ∀ (s : Set α), s ∈ S → restrict μ s = restrict ν s
Theorem: HasFDerivAtFilter.sum
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: dsimp [HasFDerivAtFilter] at *
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.326768
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.326863
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
ι : Type u_1
u : Finset ι
A : ι → E → F
A' : ι → E →L[𝕜] F
h : ∀ (i : ι), i ∈ u → HasFDerivAtFilter (A i) (A' i) x L
⊢ HasFDerivAtFilter (fun y => ∑ i in u, A i y) (∑ i in u, A' i) x L

tactic: convert IsLittleO.sum h
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.326768
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.326863
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
ι : Type u_1
u : Finset ι
A : ι → E → F
A' : ι → E →L[𝕜] F
h : ∀ (i : ι), i ∈ u → (fun x' => A i x' - A i x - ↑(A' i) (x' - x)) =o[L] fun x' => x' - x
⊢ (fun x' => ∑ i in u, A i x' - ∑ i in u, A i x - ↑(∑ i in u, A' i) (x' - x)) =o[L] fun x' => x' - x

tactic: simp [ContinuousLinearMap.sum_apply]
state_before: case h.e'_7.h
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.326768
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.326863
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
ι : Type u_1
u : Finset ι
A : ι → E → F
A' : ι → E →L[𝕜] F
h : ∀ (i : ι), i ∈ u → (fun x' => A i x' - A i x - ↑(A' i) (x' - x)) =o[L] fun x' => x' - x
x✝ : E
⊢ ∑ i in u, A i x✝ - ∑ i in u, A i x - ↑(∑ i in u, A' i) (x✝ - x) = ∑ i in u, (A i x✝ - A i x - ↑(A' i) (x✝ - x))
Theorem: PNat.Coprime.factor_eq_gcd_left_right
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [gcd_comm]
state_before: a b m n : ℕ+
cop : Coprime m n
am : a ∣ m
bn : b ∣ n
⊢ a = gcd m (a * b)

tactic: apply Coprime.factor_eq_gcd_left cop am bn
state_before: a b m n : ℕ+
cop : Coprime m n
am : a ∣ m
bn : b ∣ n
⊢ a = gcd (a * b) m
Theorem: CategoryTheory.OplaxNatTrans.whiskerRight_naturality_naturality
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: rw [← comp_whiskerRight, naturality_naturality, comp_whiskerRight, whisker_assoc]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f g : a ⟶ b
β : f ⟶ g
h : (↑G.toPrelaxFunctor).obj b ⟶ a'
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor β ▷ app η b ▷ h ≫ naturality η g ▷ h =
    naturality η f ▷ h ≫
      (α_ (app η a) ((↑G.toPrelaxFunctor).map f) h).hom ≫
        app η a ◁ PrelaxFunctor.map₂ G.toPrelaxFunctor β ▷ h ≫ (α_ (app η a) ((↑G.toPrelaxFunctor).map g) h).inv
Theorem: IsLowerSet.image
File: Mathlib/Order/UpperLower/Basic.lean

tactic: change IsLowerSet ((f : α ≃ β) '' s)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19191
ι : Sort ?u.19194
κ : ι → Sort ?u.19199
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
p : α → Prop
a : α
hs : IsLowerSet s
f : α ≃o β
⊢ IsLowerSet (↑f '' s)

tactic: rw [Set.image_equiv_eq_preimage_symm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19191
ι : Sort ?u.19194
κ : ι → Sort ?u.19199
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
p : α → Prop
a : α
hs : IsLowerSet s
f : α ≃o β
⊢ IsLowerSet (↑↑f '' s)

tactic: exact hs.preimage f.symm.monotone
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19191
ι : Sort ?u.19194
κ : ι → Sort ?u.19199
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
p : α → Prop
a : α
hs : IsLowerSet s
f : α ≃o β
⊢ IsLowerSet (↑(↑f).symm ⁻¹' s)
Theorem: MeasureTheory.OuterMeasure.le_add_caratheodory
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp [hs₁ t, hs₂ t, add_left_comm, add_assoc]
state_before: α : Type u_1
m₁ m₂ : OuterMeasure α
s : Set α
x✝ : MeasurableSet s
t : Set α
hs₁ : s ∈ (fun m => {t | MeasurableSet t}) (OuterMeasure.caratheodory m₁)
hs₂ : s ∈ (fun m => {t | MeasurableSet t}) (OuterMeasure.caratheodory m₂)
⊢ ↑(m₁ + m₂) t = ↑(m₁ + m₂) (t ∩ s) + ↑(m₁ + m₂) (t \ s)
Theorem: Multiset.prod_eq_one
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: induction' m using Quotient.inductionOn with l
state_before: ι : Type ?u.136499
α : Type u_1
β : Type ?u.136505
γ : Type ?u.136508
inst✝ : CommMonoid α
m : Multiset α
h : ∀ (x : α), x ∈ m → x = 1
⊢ prod m = 1

tactic: simp [List.prod_eq_one h]
state_before: case h
ι : Type ?u.136499
α : Type u_1
β : Type ?u.136505
γ : Type ?u.136508
inst✝ : CommMonoid α
m : Multiset α
h✝ : ∀ (x : α), x ∈ m → x = 1
l : List α
h : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) l → x = 1
⊢ prod (Quotient.mk (List.isSetoid α) l) = 1
Theorem: Set.Ioo_union_right
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simpa only [dual_Ioo, dual_Ico] using Ioo_union_left hab.dual
state_before: α : Type u_1
β : Type ?u.46814
inst✝ : PartialOrder α
a b c : α
hab : a < b
⊢ Ioo a b ∪ {b} = Ioc a b
Theorem: Finset.neg_smul_finset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp only [← image_smul, ← image_neg, image_image, neg_smul, Function.comp]
state_before: F : Type ?u.946851
α : Type u_2
β : Type u_1
γ : Type ?u.946860
inst✝³ : Ring α
inst✝² : AddCommGroup β
inst✝¹ : Module α β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
a : α
⊢ -a • t = -(a • t)