tasksource/leandojo huggingface dataset:
Theorem: BoxIntegral.Prepartition.isPartition_single_iff
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp [isPartition_iff_iUnion_eq]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
h : J ≤ I
⊢ IsPartition (single I J h) ↔ J = I
Theorem: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom_desc
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
r t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), s.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).hom ≫ desc Q r = s.ι.app j ≫ map P r w.hom
Theorem: UniqueFactorizationMonoid.mem_normalizedFactors_eq_of_associated
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [← normalize_normalized_factor a ha, ← normalize_normalized_factor b hb,
  normalize_eq_normalize_iff]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a b c : α
ha : a ∈ normalizedFactors c
hb : b ∈ normalizedFactors c
h : a ~ᵤ b
⊢ a = b

tactic: exact Associated.dvd_dvd h
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a b c : α
ha : a ∈ normalizedFactors c
hb : b ∈ normalizedFactors c
h : a ~ᵤ b
⊢ a ∣ b ∧ b ∣ a
Theorem: Interval.length_sub_le
File: Mathlib/Algebra/Order/Interval.lean

tactic: simpa [sub_eq_add_neg] using length_add_le s (-t)
state_before: ι : Type ?u.392141
α : Type u_1
inst✝ : OrderedAddCommGroup α
s t : Interval α
a : α
⊢ length (s - t) ≤ length s + length t
Theorem: BoxIntegral.Integrable.of_smul
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simpa [inv_smul_smul₀ hc] using hf.smul c⁻¹
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hf : Integrable I l (c • f) vol
hc : c ≠ 0
⊢ Integrable I l f vol
Theorem: Polynomial.coeff_sub_eq_neg_right_of_lt
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: rwa [sub_eq_add_neg, coeff_add_eq_right_of_lt, coeff_neg]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Ring R
p q : R[X]
df : natDegree p < n
⊢ coeff (p - q) n = -coeff q n
Theorem: LaurentPolynomial.T_add
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: simp [T, single_mul_single]
state_before: R : Type u_1
inst✝ : Semiring R
m n : ℤ
⊢ T (m + n) = T m * T n
Theorem: Set.toFinset_union
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.87559
γ : Type ?u.87562
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ∪ t)
⊢ toFinset (s ∪ t) = toFinset s ∪ toFinset t

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.87559
γ : Type ?u.87562
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ∪ t)
a✝ : α
⊢ a✝ ∈ toFinset (s ∪ t) ↔ a✝ ∈ toFinset s ∪ toFinset t
Theorem: zpow_bit1
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [bit1, zpow_add, zpow_bit0, zpow_one]
state_before: α : Type ?u.145698
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a : G
n : ℤ
⊢ a ^ bit1 n = a ^ n * a ^ n * a
Theorem: MeasureTheory.SignedMeasure.rnDeriv_add
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: refine'
  Integrable.ae_eq_of_withDensityᵥ_eq (integrable_rnDeriv _ _)
    ((integrable_rnDeriv _ _).add (integrable_rnDeriv _ _)) _
state_before: α : Type u_1
β : Type ?u.653242
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝² : HaveLebesgueDecomposition s μ
inst✝¹ : HaveLebesgueDecomposition t μ
inst✝ : HaveLebesgueDecomposition (s + t) μ
⊢ rnDeriv (s + t) μ =ᶠ[ae μ] rnDeriv s μ + rnDeriv t μ

tactic: rw [← add_right_inj ((s + t).singularPart μ), singularPart_add_withDensity_rnDeriv_eq,
  withDensityᵥ_add (integrable_rnDeriv _ _) (integrable_rnDeriv _ _), singularPart_add,
  add_assoc, add_comm (t.singularPart μ), add_assoc, add_comm _ (t.singularPart μ),
  singularPart_add_withDensity_rnDeriv_eq, ← add_assoc,
  singularPart_add_withDensity_rnDeriv_eq]
state_before: α : Type u_1
β : Type ?u.653242
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝² : HaveLebesgueDecomposition s μ
inst✝¹ : HaveLebesgueDecomposition t μ
inst✝ : HaveLebesgueDecomposition (s + t) μ
⊢ withDensityᵥ μ (rnDeriv (s + t) μ) = withDensityᵥ μ (rnDeriv s μ + rnDeriv t μ)
Theorem: Function.Embedding.nonempty_of_card_le
File: Mathlib/Data/Fintype/Card.lean

tactic: classical exact (truncOfCardLe h).nonempty
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.50772
inst✝¹ : Fintype α
inst✝ : Fintype β
h : Fintype.card α ≤ Fintype.card β
⊢ Nonempty (α ↪ β)

tactic: exact (truncOfCardLe h).nonempty
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.50772
inst✝¹ : Fintype α
inst✝ : Fintype β
h : Fintype.card α ≤ Fintype.card β
⊢ Nonempty (α ↪ β)
Theorem: List.singleton_disjoint
File: Std/Data/List/Lemmas.lean

tactic: simp [Disjoint]
state_before: α✝ : Type u_1
a : α✝
l : List α✝
⊢ Disjoint [a] l ↔ ¬a ∈ l
Theorem: AlternatingMap.map_perm
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: induction' σ using Equiv.Perm.swap_induction_on' with s x y hxy hI
state_before: R : Type u_4
inst✝¹⁶ : Semiring R
M : Type u_3
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
N : Type ?u.456393
inst✝¹³ : AddCommMonoid N
inst✝¹² : Module R N
P : Type ?u.456423
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : Module R P
M' : Type ?u.456453
inst✝⁹ : AddCommGroup M'
inst✝⁸ : Module R M'
N' : Type u_2
inst✝⁷ : AddCommGroup N'
inst✝⁶ : Module R N'
ι : Type u_1
ι' : Type ?u.457232
ι'' : Type ?u.457235
M₂ : Type ?u.457238
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
M₃ : Type ?u.457268
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
f f' : AlternatingMap R M N ι
g g₂ : AlternatingMap R M N' ι
g' : AlternatingMap R M' N' ι
v✝ : ι → M
v' : ι → M'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
v : ι → M
σ : Equiv.Perm ι
⊢ ↑g (v ∘ ↑σ) = ↑Equiv.Perm.sign σ • ↑g v

tactic: simp
state_before: case a
R : Type u_4
inst✝¹⁶ : Semiring R
M : Type u_3
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
N : Type ?u.456393
inst✝¹³ : AddCommMonoid N
inst✝¹² : Module R N
P : Type ?u.456423
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : Module R P
M' : Type ?u.456453
inst✝⁹ : AddCommGroup M'
inst✝⁸ : Module R M'
N' : Type u_2
inst✝⁷ : AddCommGroup N'
inst✝⁶ : Module R N'
ι : Type u_1
ι' : Type ?u.457232
ι'' : Type ?u.457235
M₂ : Type ?u.457238
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
M₃ : Type ?u.457268
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
f f' : AlternatingMap R M N ι
g g₂ : AlternatingMap R M N' ι
g' : AlternatingMap R M' N' ι
v✝ : ι → M
v' : ι → M'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
v : ι → M
⊢ ↑g (v ∘ ↑1) = ↑Equiv.Perm.sign 1 • ↑g v

tactic: simpa [← Function.comp.assoc, g.map_swap (v ∘ s) hxy,
  Equiv.Perm.sign_swap hxy, -Equiv.Perm.sign_swap'] using hI
state_before: case a
R : Type u_4
inst✝¹⁶ : Semiring R
M : Type u_3
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
N : Type ?u.456393
inst✝¹³ : AddCommMonoid N
inst✝¹² : Module R N
P : Type ?u.456423
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : Module R P
M' : Type ?u.456453
inst✝⁹ : AddCommGroup M'
inst✝⁸ : Module R M'
N' : Type u_2
inst✝⁷ : AddCommGroup N'
inst✝⁶ : Module R N'
ι : Type u_1
ι' : Type ?u.457232
ι'' : Type ?u.457235
M₂ : Type ?u.457238
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
M₃ : Type ?u.457268
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
f f' : AlternatingMap R M N ι
g g₂ : AlternatingMap R M N' ι
g' : AlternatingMap R M' N' ι
v✝ : ι → M
v' : ι → M'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
v : ι → M
s : Equiv.Perm ι
x y : ι
hxy : x ≠ y
hI : ↑g (v ∘ ↑s) = ↑Equiv.Perm.sign s • ↑g v
⊢ ↑g (v ∘ ↑(s * Equiv.swap x y)) = ↑Equiv.Perm.sign (s * Equiv.swap x y) • ↑g v
Theorem: holderOnWith_one
File: Mathlib/Topology/MetricSpace/Holder.lean

tactic: simp only [HolderOnWith, LipschitzOnWith, NNReal.coe_one, ENNReal.rpow_one]
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.128620
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
C : ℝ≥0
f : X → Y
s : Set X
⊢ HolderOnWith C 1 f s ↔ LipschitzOnWith C f s
Theorem: Algebra.FiniteType.isNoetherianRing
File: Mathlib/RingTheory/FiniteType.lean

tactic: obtain ⟨s, hs⟩ := h.1
state_before: R✝ : Type ?u.65970
A : Type u
B : Type ?u.65961
M : Type ?u.65964
N : Type ?u.65967
inst✝¹² : CommRing R✝
inst✝¹¹ : CommRing A
inst✝¹⁰ : Algebra R✝ A
inst✝⁹ : CommRing B
inst✝⁸ : Algebra R✝ B
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R✝ M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R✝ N
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
h : FiniteType R S
inst✝ : IsNoetherianRing R
⊢ IsNoetherianRing S

tactic: apply
  isNoetherianRing_of_surjective (MvPolynomial s R) S
    (MvPolynomial.aeval (↑) : MvPolynomial s R →ₐ[R] S).toRingHom
state_before: case intro
R✝ : Type ?u.65970
A : Type u
B : Type ?u.65961
M : Type ?u.65964
N : Type ?u.65967
inst✝¹² : CommRing R✝
inst✝¹¹ : CommRing A
inst✝¹⁰ : Algebra R✝ A
inst✝⁹ : CommRing B
inst✝⁸ : Algebra R✝ B
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R✝ M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R✝ N
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
h : FiniteType R S
inst✝ : IsNoetherianRing R
s : Finset S
hs : adjoin R ↑s = ⊤
⊢ IsNoetherianRing S

tactic: erw [← Set.range_iff_surjective, ← AlgHom.coe_range, ←
  Algebra.adjoin_range_eq_range_aeval, Subtype.range_coe_subtype, Finset.setOf_mem, hs]
state_before: case intro.hf
R✝ : Type ?u.65970
A : Type u
B : Type ?u.65961
M : Type ?u.65964
N : Type ?u.65967
inst✝¹² : CommRing R✝
inst✝¹¹ : CommRing A
inst✝¹⁰ : Algebra R✝ A
inst✝⁹ : CommRing B
inst✝⁸ : Algebra R✝ B
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R✝ M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R✝ N
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
h : FiniteType R S
inst✝ : IsNoetherianRing R
s : Finset S
hs : adjoin R ↑s = ⊤
⊢ Surjective ↑↑(MvPolynomial.aeval Subtype.val)

tactic: rfl
state_before: case intro.hf
R✝ : Type ?u.65970
A : Type u
B : Type ?u.65961
M : Type ?u.65964
N : Type ?u.65967
inst✝¹² : CommRing R✝
inst✝¹¹ : CommRing A
inst✝¹⁰ : Algebra R✝ A
inst✝⁹ : CommRing B
inst✝⁸ : Algebra R✝ B
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R✝ M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R✝ N
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
h : FiniteType R S
inst✝ : IsNoetherianRing R
s : Finset S
hs : adjoin R ↑s = ⊤
⊢ ↑⊤ = Set.univ
Theorem: SimpleGraph.cliqueFinset_eq_empty_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simp_rw [CliqueFree, eq_empty_iff_forall_not_mem, mem_cliqueFinset_iff]
state_before: α : Type u_1
G H : SimpleGraph α
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
n : ℕ
a b c : α
s : Finset α
⊢ cliqueFinset G n = ∅ ↔ CliqueFree G n
Theorem: Nat.mod_eq_zero_of_dvd
File: Std/Data/Nat/Lemmas.lean

tactic: let ⟨z, H⟩ := H
state_before: m n : Nat
H : m ∣ n
⊢ n % m = 0

tactic: rw [H, mul_mod_right]
state_before: m n : Nat
H✝ : m ∣ n
z : Nat
H : n = m * z
⊢ n % m = 0
Theorem: CategoryTheory.Limits.hasColimit_of_equivalence_comp
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: haveI : HasColimit (e.inverse ⋙ e.functor ⋙ F) := Limits.hasColimit_equivalence_comp e.symm
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F : J ⥤ C
e : K ≌ J
inst✝ : HasColimit (e.functor ⋙ F)
⊢ HasColimit F

tactic: apply hasColimitOfIso (e.invFunIdAssoc F).symm
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F : J ⥤ C
e : K ≌ J
inst✝ : HasColimit (e.functor ⋙ F)
this : HasColimit (e.inverse ⋙ e.functor ⋙ F)
⊢ HasColimit F
Theorem: Set.Finite.subset
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : Set.Finite s
t : Set α
ht : t ⊆ s
⊢ Set.Finite t

tactic: haveI := Finite.Set.subset _ ht
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
ht : t ⊆ s
a✝ : Fintype ↑s
⊢ Set.Finite t

tactic: apply toFinite
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
ht : t ⊆ s
a✝ : Fintype ↑s
this : Finite ↑t
⊢ Set.Finite t
Theorem: Multiset.mem_join
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.2554
γ : Type ?u.2557
δ : Type ?u.2560
a : α
S : Multiset (Multiset α)
⊢ a ∈ join 0 ↔ ∃ s, s ∈ 0 ∧ a ∈ s

tactic: simp (config := { contextual := true }) [or_and_right, exists_or]
state_before: α : Type u_1
β : Type ?u.2554
γ : Type ?u.2557
δ : Type ?u.2560
a : α
S : Multiset (Multiset α)
⊢ ∀ ⦃a_1 : Multiset α⦄ {s : Multiset (Multiset α)},
    (a ∈ join s ↔ ∃ s_1, s_1 ∈ s ∧ a ∈ s_1) → (a ∈ join (a_1 ::ₘ s) ↔ ∃ s_1, s_1 ∈ a_1 ::ₘ s ∧ a ∈ s_1)
Theorem: Polynomial.degree_le_iff_coeff_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp only [degree, Finset.max, Finset.sup_le_iff, mem_support_iff, Ne.def, ← not_le,
  not_imp_comm, Nat.cast_withBot]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.702057
f : R[X]
n : WithBot ℕ
⊢ degree f ≤ n ↔ ∀ (m : ℕ), n < ↑m → coeff f m = 0
Theorem: IsOpen.inter_frontier_eq
File: Mathlib/Topology/Basic.lean

tactic: rw [hs.frontier_eq, inter_diff_self]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
hs : IsOpen s
⊢ s ∩ frontier s = ∅
Theorem: chainClosure_empty
File: Mathlib/Order/Chain.lean

tactic: have : ChainClosure r (⋃₀∅) := ChainClosure.union fun a h => False.rec h
state_before: α : Type u_1
β : Type ?u.10878
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
⊢ ChainClosure r ∅

tactic: simpa using this
state_before: α : Type u_1
β : Type ?u.10878
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
this : ChainClosure r (⋃₀ ∅)
⊢ ChainClosure r ∅
Theorem: Finsupp.mem_graph_iff
File: Mathlib/Data/Finsupp/Basic.lean

tactic: cases c
state_before: α : Type u_1
β : Type ?u.1790
γ : Type ?u.1793
ι : Type ?u.1796
M : Type u_2
M' : Type ?u.1802
N : Type ?u.1805
P : Type ?u.1808
G : Type ?u.1811
H : Type ?u.1814
R : Type ?u.1817
S : Type ?u.1820
inst✝ : Zero M
c : α × M
f : α →₀ M
⊢ c ∈ graph f ↔ ↑f c.fst = c.snd ∧ c.snd ≠ 0

tactic: exact mk_mem_graph_iff
state_before: case mk
α : Type u_1
β : Type ?u.1790
γ : Type ?u.1793
ι : Type ?u.1796
M : Type u_2
M' : Type ?u.1802
N : Type ?u.1805
P : Type ?u.1808
G : Type ?u.1811
H : Type ?u.1814
R : Type ?u.1817
S : Type ?u.1820
inst✝ : Zero M
f : α →₀ M
fst✝ : α
snd✝ : M
⊢ (fst✝, snd✝) ∈ graph f ↔ ↑f (fst✝, snd✝).fst = (fst✝, snd✝).snd ∧ (fst✝, snd✝).snd ≠ 0
Theorem: Real.exp_approx_succ
File: Mathlib/Data/Complex/Exponential.lean

tactic: refine' (abs_sub_le _ _ _).trans ((add_le_add_right h _).trans _)
state_before: n : ℕ
x a₁ b₁ : ℝ
m : ℕ
e₁ : n + 1 = m
a₂ b₂ : ℝ
e : abs' (1 + x / ↑m * a₂ - a₁) ≤ b₁ - abs' x / ↑m * b₂
h : abs' (exp x - expNear m x a₂) ≤ abs' x ^ m / ↑(Nat.factorial m) * b₂
⊢ abs' (exp x - expNear n x a₁) ≤ abs' x ^ n / ↑(Nat.factorial n) * b₁

tactic: subst e₁
state_before: n : ℕ
x a₁ b₁ : ℝ
m : ℕ
e₁ : n + 1 = m
a₂ b₂ : ℝ
e : abs' (1 + x / ↑m * a₂ - a₁) ≤ b₁ - abs' x / ↑m * b₂
h : abs' (exp x - expNear m x a₂) ≤ abs' x ^ m / ↑(Nat.factorial m) * b₂
⊢ abs' x ^ m / ↑(Nat.factorial m) * b₂ + abs' (expNear m x a₂ - expNear n x a₁) ≤ abs' x ^ n / ↑(Nat.factorial n) * b₁

tactic: rw [expNear_succ, expNear_sub, abs_mul]
state_before: n : ℕ
x a₁ b₁ a₂ b₂ : ℝ
e : abs' (1 + x / ↑(n + 1) * a₂ - a₁) ≤ b₁ - abs' x / ↑(n + 1) * b₂
h : abs' (exp x - expNear (n + 1) x a₂) ≤ abs' x ^ (n + 1) / ↑(Nat.factorial (n + 1)) * b₂
⊢ abs' x ^ (n + 1) / ↑(Nat.factorial (n + 1)) * b₂ + abs' (expNear (n + 1) x a₂ - expNear n x a₁) ≤
    abs' x ^ n / ↑(Nat.factorial n) * b₁

tactic: convert mul_le_mul_of_nonneg_left (a := abs' x ^ n / ↑(Nat.factorial n))
    (le_sub_iff_add_le'.1 e) ?_ using 1
state_before: n : ℕ
x a₁ b₁ a₂ b₂ : ℝ
e : abs' (1 + x / ↑(n + 1) * a₂ - a₁) ≤ b₁ - abs' x / ↑(n + 1) * b₂
h : abs' (exp x - expNear (n + 1) x a₂) ≤ abs' x ^ (n + 1) / ↑(Nat.factorial (n + 1)) * b₂
⊢ abs' x ^ (n + 1) / ↑(Nat.factorial (n + 1)) * b₂ +
      abs' (x ^ n / ↑(Nat.factorial n)) * abs' (1 + x / (↑n + 1) * a₂ - a₁) ≤
    abs' x ^ n / ↑(Nat.factorial n) * b₁

tactic: simp [mul_add, pow_succ', div_eq_mul_inv, abs_mul, abs_inv, ← pow_abs, mul_inv]
state_before: case h.e'_3
n : ℕ
x a₁ b₁ a₂ b₂ : ℝ
e : abs' (1 + x / ↑(n + 1) * a₂ - a₁) ≤ b₁ - abs' x / ↑(n + 1) * b₂
h : abs' (exp x - expNear (n + 1) x a₂) ≤ abs' x ^ (n + 1) / ↑(Nat.factorial (n + 1)) * b₂
⊢ abs' x ^ (n + 1) / ↑(Nat.factorial (n + 1)) * b₂ +
      abs' (x ^ n / ↑(Nat.factorial n)) * abs' (1 + x / (↑n + 1) * a₂ - a₁) =
    abs' x ^ n / ↑(Nat.factorial n) * (abs' x / ↑(n + 1) * b₂ + abs' (1 + x / ↑(n + 1) * a₂ - a₁))

tactic: ac_rfl
state_before: case h.e'_3
n : ℕ
x a₁ b₁ a₂ b₂ : ℝ
e : abs' (1 + x / ↑(n + 1) * a₂ - a₁) ≤ b₁ - abs' x / ↑(n + 1) * b₂
h : abs' (exp x - expNear (n + 1) x a₂) ≤ abs' x ^ (n + 1) / ↑(Nat.factorial (n + 1)) * b₂
⊢ abs' x ^ n * abs' x * ((↑(Nat.factorial n))⁻¹ * (↑n + 1)⁻¹) * b₂ =
    abs' x ^ n * (↑(Nat.factorial n))⁻¹ * (abs' x * (↑n + 1)⁻¹ * b₂)

tactic: simp [div_nonneg, abs_nonneg]
state_before: n : ℕ
x a₁ b₁ a₂ b₂ : ℝ
e : abs' (1 + x / ↑(n + 1) * a₂ - a₁) ≤ b₁ - abs' x / ↑(n + 1) * b₂
h : abs' (exp x - expNear (n + 1) x a₂) ≤ abs' x ^ (n + 1) / ↑(Nat.factorial (n + 1)) * b₂
⊢ 0 ≤ abs' x ^ n / ↑(Nat.factorial n)
Theorem: min_lt_of_mul_lt_sq
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa using min_lt_max_of_mul_lt_mul (h.trans_eq <| pow_two _)
state_before: β : Type ?u.151798
A : Type ?u.151801
G : Type ?u.151804
M : Type u_1
R : Type ?u.151810
inst✝³ : Monoid M
inst✝² : LinearOrder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : M
h : a * b < c ^ 2
⊢ min a b < c
Theorem: Set.biUnion_and
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [iUnion_and, @iUnion_comm _ ι']
state_before: α : Type u_1
β : Type ?u.88687
γ : Type ?u.88690
ι : Sort u_2
ι' : Sort u_3
ι₂ : Sort ?u.88699
κ : ι → Sort ?u.88704
κ₁ : ι → Sort ?u.88709
κ₂ : ι → Sort ?u.88714
κ' : ι' → Sort ?u.88719
p : ι → Prop
q : ι → ι' → Prop
s : (x : ι) → (y : ι') → p x ∧ q x y → Set α
⊢ (⋃ (x : ι) (y : ι') (h : p x ∧ q x y), s x y h) = ⋃ (x : ι) (hx : p x) (y : ι') (hy : q x y), s x y (_ : p x ∧ q x y)
Theorem: Matrix.toLin_transpose
File: Mathlib/LinearAlgebra/Matrix/Dual.lean

tactic: apply (LinearMap.toMatrix B₁.dualBasis B₂.dualBasis).injective
state_before: K : Type u_3
V₁ : Type u_4
V₂ : Type u_5
ι₁ : Type u_1
ι₂ : Type u_2
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : Module K V₁
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module K V₂
inst✝³ : Fintype ι₁
inst✝² : Fintype ι₂
inst✝¹ : DecidableEq ι₁
inst✝ : DecidableEq ι₂
B₁ : Basis ι₁ K V₁
B₂ : Basis ι₂ K V₂
M : Matrix ι₁ ι₂ K
⊢ ↑(toLin (Basis.dualBasis B₁) (Basis.dualBasis B₂)) Mᵀ = ↑Module.Dual.transpose (↑(toLin B₂ B₁) M)

tactic: rw [LinearMap.toMatrix_toLin, LinearMap.toMatrix_transpose, LinearMap.toMatrix_toLin]
state_before: case a
K : Type u_3
V₁ : Type u_4
V₂ : Type u_5
ι₁ : Type u_1
ι₂ : Type u_2
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : Module K V₁
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module K V₂
inst✝³ : Fintype ι₁
inst✝² : Fintype ι₂
inst✝¹ : DecidableEq ι₁
inst✝ : DecidableEq ι₂
B₁ : Basis ι₁ K V₁
B₂ : Basis ι₂ K V₂
M : Matrix ι₁ ι₂ K
⊢ ↑(LinearMap.toMatrix (Basis.dualBasis B₁) (Basis.dualBasis B₂))
      (↑(toLin (Basis.dualBasis B₁) (Basis.dualBasis B₂)) Mᵀ) =
    ↑(LinearMap.toMatrix (Basis.dualBasis B₁) (Basis.dualBasis B₂)) (↑Module.Dual.transpose (↑(toLin B₂ B₁) M))
Theorem: Stream'.WSeq.ret_bind
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [bind]
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : α → WSeq β
⊢ bind (ret a) f ~ʷ f a
Theorem: Complex.dist_of_im_eq
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [dist_eq_re_im, h, sub_self, zero_pow two_pos, add_zero, Real.sqrt_sq_eq_abs, Real.dist_eq]
state_before: E : Type ?u.13792
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
h : z.im = w.im
⊢ dist z w = dist z.re w.re
Theorem: Real.isLittleO_one_exp_comp
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp only [← exp_zero, isLittleO_exp_comp_exp_comp, sub_zero]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => 1) =o[l] fun x => exp (f x)) ↔ Tendsto f l atTop
Theorem: sdiff_sdiff_sup_sdiff
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sdiff_sup, sdiff_sdiff_right, sdiff_sdiff_right]
state_before: α : Type u
β : Type ?u.31125
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ z \ (x \ y ⊔ y \ x) = (z \ x ⊔ z ⊓ x ⊓ y) ⊓ (z \ y ⊔ z ⊓ y ⊓ x)

tactic: rw [sup_inf_left, sup_comm, sup_inf_sdiff]
state_before: α : Type u
β : Type ?u.31125
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (z \ x ⊔ z ⊓ x ⊓ y) ⊓ (z \ y ⊔ z ⊓ y ⊓ x) = z ⊓ (z \ x ⊔ y) ⊓ (z \ y ⊔ z ⊓ y ⊓ x)

tactic: rw [sup_inf_left, @sup_comm _ _ (z \ y), sup_inf_sdiff]
state_before: α : Type u
β : Type ?u.31125
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ z ⊓ (z \ x ⊔ y) ⊓ (z \ y ⊔ z ⊓ y ⊓ x) = z ⊓ (z \ x ⊔ y) ⊓ (z ⊓ (z \ y ⊔ x))

tactic: ac_rfl
state_before: α : Type u
β : Type ?u.31125
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ z ⊓ (z \ x ⊔ y) ⊓ (z ⊓ (z \ y ⊔ x)) = z ⊓ z ⊓ (z \ x ⊔ y) ⊓ (z \ y ⊔ x)

tactic: rw [inf_idem]
state_before: α : Type u
β : Type ?u.31125
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ z ⊓ z ⊓ (z \ x ⊔ y) ⊓ (z \ y ⊔ x) = z ⊓ (z \ x ⊔ y) ⊓ (z \ y ⊔ x)
Theorem: FreeGroup.Red.Step.cons_cons_iff
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: simp (config := { contextual := true }) [Step.cons_left_iff, iff_def, or_imp]
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ ∀ {p : α × Bool}, Step (p :: L₁) (p :: L₂) ↔ Step L₁ L₂
Theorem: Polynomial.rootMultiplicity_add
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [le_rootMultiplicity_iff hzero]
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
hzero : p + q ≠ 0
⊢ min (rootMultiplicity a p) (rootMultiplicity a q) ≤ rootMultiplicity a (p + q)

tactic: have hdivp : (X - C a) ^ rootMultiplicity a p ∣ p := pow_rootMultiplicity_dvd p a
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
hzero : p + q ≠ 0
⊢ (X - ↑C a) ^ min (rootMultiplicity a p) (rootMultiplicity a q) ∣ p + q

tactic: have hdivq : (X - C a) ^ rootMultiplicity a q ∣ q := pow_rootMultiplicity_dvd q a
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
hzero : p + q ≠ 0
hdivp : (X - ↑C a) ^ rootMultiplicity a p ∣ p
⊢ (X - ↑C a) ^ min (rootMultiplicity a p) (rootMultiplicity a q) ∣ p + q

tactic: exact min_pow_dvd_add hdivp hdivq
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
hzero : p + q ≠ 0
hdivp : (X - ↑C a) ^ rootMultiplicity a p ∣ p
hdivq : (X - ↑C a) ^ rootMultiplicity a q ∣ q
⊢ (X - ↑C a) ^ min (rootMultiplicity a p) (rootMultiplicity a q) ∣ p + q