tasksource/leandojo huggingface dataset:
Theorem: Finsupp.antidiagonal_filter_fst_eq
File: Mathlib/Data/Finsupp/Antidiagonal.lean

tactic: ext ⟨a, b⟩
state_before: α : Type u
f g : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = g)
⊢ Finset.filter (fun p => p.fst = g) (antidiagonal f) = if g ≤ f then {(g, f - g)} else ∅

tactic: suffices a = g → (a + b = f ↔ g ≤ f ∧ b = f - g) by
  simpa [apply_ite (fun f ↦ (a, b) ∈ f), mem_filter, mem_antidiagonal, mem_singleton,
    Prod.mk.inj_iff, ← and_assoc, @and_right_comm _ (a = _), and_congr_left_iff]
state_before: case a.mk
α : Type u
f g : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = g)
a b : α →₀ ℕ
⊢ (a, b) ∈ Finset.filter (fun p => p.fst = g) (antidiagonal f) ↔ (a, b) ∈ if g ≤ f then {(g, f - g)} else ∅

tactic: rintro rfl
state_before: case a.mk
α : Type u
f g : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = g)
a b : α →₀ ℕ
⊢ a = g → (a + b = f ↔ g ≤ f ∧ b = f - g)

tactic: constructor
state_before: case a.mk
α : Type u
f a b : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = a)
⊢ a + b = f ↔ a ≤ f ∧ b = f - a

tactic: simpa [apply_ite (fun f ↦ (a, b) ∈ f), mem_filter, mem_antidiagonal, mem_singleton,
  Prod.mk.inj_iff, ← and_assoc, @and_right_comm _ (a = _), and_congr_left_iff]
state_before: α : Type u
f g : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = g)
a b : α →₀ ℕ
this : a = g → (a + b = f ↔ g ≤ f ∧ b = f - g)
⊢ (a, b) ∈ Finset.filter (fun p => p.fst = g) (antidiagonal f) ↔ (a, b) ∈ if g ≤ f then {(g, f - g)} else ∅

tactic: rintro rfl
state_before: case a.mk.mp
α : Type u
f a b : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = a)
⊢ a + b = f → a ≤ f ∧ b = f - a

tactic: exact ⟨le_add_right le_rfl, (add_tsub_cancel_left _ _).symm⟩
state_before: case a.mk.mp
α : Type u
a b : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = a)
⊢ a ≤ a + b ∧ b = a + b - a

tactic: rintro ⟨h, rfl⟩
state_before: case a.mk.mpr
α : Type u
f a b : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = a)
⊢ a ≤ f ∧ b = f - a → a + b = f

tactic: exact add_tsub_cancel_of_le h
state_before: case a.mk.mpr.intro
α : Type u
f a : α →₀ ℕ
D : (p : (α →₀ ℕ) × (α →₀ ℕ)) → Decidable (p.fst = a)
h : a ≤ f
⊢ a + (f - a) = f
Theorem: image2_upperBounds_upperBounds_subset_upperBounds_image2
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro _ ⟨a, b, ha, hb, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
⊢ image2 f (lowerBounds s) (lowerBounds t) ⊆ upperBounds (image2 f s t)

tactic: exact mem_upperBounds_image2_of_mem_lowerBounds h₀ h₁ ha hb
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
b : β
ha : a ∈ lowerBounds s
hb : b ∈ lowerBounds t
⊢ f a b ∈ upperBounds (image2 f s t)
Theorem: isIntegral_sup
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: simp only [← le_integralClosure_iff_isIntegral, sup_le_iff]
state_before: R : Type u_1
A : Type u_2
B : Type ?u.722967
S✝ : Type ?u.722970
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S✝
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S✝
S T : Subalgebra R A
⊢ Algebra.IsIntegral R { x // x ∈ S ⊔ T } ↔ Algebra.IsIntegral R { x // x ∈ S } ∧ Algebra.IsIntegral R { x // x ∈ T }
Theorem: Real.exp_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [exp_add, exp]
state_before: x y : ℝ
⊢ exp (x + y) = exp x * exp y
Theorem: Metric.closure_eq_iInter_cthickening
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [← cthickening_zero]
state_before: ι : Sort ?u.144673
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
E : Set α
⊢ closure E = ⋂ (δ : ℝ) (_ : 0 < δ), cthickening δ E

tactic: exact cthickening_eq_iInter_cthickening E
state_before: ι : Sort ?u.144673
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
E : Set α
⊢ cthickening 0 E = ⋂ (δ : ℝ) (_ : 0 < δ), cthickening δ E
Theorem: MeasurableEquiv.sigmaFinite_map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine' SigmaFinite.of_map _ f.symm.measurable.aemeasurable _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.799057
δ : Type ?u.799060
ι : Type ?u.799063
R : Type ?u.799066
R' : Type ?u.799069
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μ : Measure α
f : α ≃ᵐ β
h : SigmaFinite μ
⊢ SigmaFinite (Measure.map (↑f) μ)

tactic: rwa [map_map f.symm.measurable f.measurable, f.symm_comp_self, Measure.map_id]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.799057
δ : Type ?u.799060
ι : Type ?u.799063
R : Type ?u.799066
R' : Type ?u.799069
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μ : Measure α
f : α ≃ᵐ β
h : SigmaFinite μ
⊢ SigmaFinite (Measure.map (↑(MeasurableEquiv.symm f)) (Measure.map (↑f) μ))
Theorem: CategoryTheory.Limits.Pi.reindex_hom_π
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: dsimp [Pi.reindex]
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasProduct f
inst✝ : HasProduct (f ∘ ↑ε)
b : β
⊢ (reindex ε f).hom ≫ π f (↑ε b) = π (f ∘ ↑ε) b

tactic: simp only [HasLimit.isoOfEquivalence_hom_π, Discrete.equivalence_inverse, Discrete.functor_obj,
  Function.comp_apply, Functor.id_obj, Discrete.equivalence_functor, Functor.comp_obj,
  Discrete.natIso_inv_app, Iso.refl_inv, Category.id_comp]
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasProduct f
inst✝ : HasProduct (f ∘ ↑ε)
b : β
⊢ (HasLimit.isoOfEquivalence (Discrete.equivalence ε)
          (Discrete.natIso fun x =>
            Iso.refl ((Discrete.functor f).obj ((Discrete.functor (Discrete.mk ∘ ↑ε)).obj x)))).hom ≫
      π f (↑ε b) =
    π (f ∘ ↑ε) b

tactic: dsimp
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasProduct f
inst✝ : HasProduct (f ∘ ↑ε)
b : β
⊢ limit.π (Discrete.functor (f ∘ ↑ε)) { as := ↑ε.symm (↑ε b) } ≫
      (Discrete.functor f).map ((Equivalence.counit (Discrete.equivalence ε)).app { as := ↑ε b }) =
    π (f ∘ ↑ε) b

tactic: simpa [eqToHom_map]
  using limit.w (Discrete.functor (f ∘ ε)) (Discrete.eqToHom' (ε.symm_apply_apply b))
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasProduct f
inst✝ : HasProduct (f ∘ ↑ε)
b : β
⊢ limit.π (Discrete.functor (f ∘ ↑ε)) { as := ↑ε.symm (↑ε b) } ≫
      (Discrete.functor f).map ((Equivalence.counit (Discrete.equivalence ε)).app { as := ↑ε b }) =
    π (f ∘ ↑ε) b
Theorem: ContinuousLinearMap.reApplyInnerSelf_smul
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [ContinuousLinearMap.map_smul, ContinuousLinearMap.reApplyInnerSelf_apply,
  inner_smul_left, inner_smul_right, ← mul_assoc, mul_conj, normSq_eq_def', ← smul_re,
  Algebra.smul_def (‖c‖ ^ 2) ⟪T x, x⟫, algebraMap_eq_ofReal]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.4189796
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
T : E →L[𝕜] E
x : E
c : 𝕜
⊢ reApplyInnerSelf T (c • x) = ‖c‖ ^ 2 * reApplyInnerSelf T x
Theorem: Finset.orderEmbOfFin_zero
File: Mathlib/Data/Finset/Sort.lean

tactic: simp only [orderEmbOfFin_apply, Fin.val_mk, sorted_zero_eq_min']
state_before: α : Type u_1
β : Type ?u.43189
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : card s = k
hz : 0 < k
⊢ ↑(orderEmbOfFin s h) { val := 0, isLt := hz } = min' s (_ : Finset.Nonempty s)
Theorem: divp_eq_divp_iff
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [divp_eq_iff_mul_eq, divp_mul_eq_mul_divp, divp_eq_iff_mul_eq]
state_before: α : Type u
inst✝ : CommMonoid α
x y : α
ux uy : αˣ
⊢ x /ₚ ux = y /ₚ uy ↔ x * ↑uy = y * ↑ux
Theorem: List.Perm.dedup
File: Mathlib/Data/List/Perm.lean

tactic: simp [nodup_dedup, h, p.subset h]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
p : l₁ ~ l₂
a : α
h : a ∈ l₁
⊢ count a (List.dedup l₁) = count a (List.dedup l₂)

tactic: simp [h, mt p.mem_iff.2 h]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
p : l₁ ~ l₂
a : α
h : ¬a ∈ l₁
⊢ count a (List.dedup l₁) = count a (List.dedup l₂)
Theorem: max_mul_mul_le_max_mul_max
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa [mul_comm, max_comm] using ba
state_before: α : Type u
β : Type ?u.218570
inst✝ : LinearOrderedCommRing α
a b✝ c✝ d b c : α
ha : 0 ≤ a
hd : 0 ≤ d
ba : b * a ≤ max d b * max c a
cd : c * d ≤ max a c * max b d
⊢ a * b ≤ max a c * max d b

tactic: simpa [mul_comm, max_comm] using cd
state_before: α : Type u
β : Type ?u.218570
inst✝ : LinearOrderedCommRing α
a b✝ c✝ d b c : α
ha : 0 ≤ a
hd : 0 ≤ d
ba : b * a ≤ max d b * max c a
cd : c * d ≤ max a c * max b d
⊢ d * c ≤ max a c * max d b
Theorem: SimpleGraph.edgeSet_sup
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext ⟨x, y⟩
state_before: ι : Sort ?u.70414
𝕜 : Type ?u.70417
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
⊢ edgeSet (G₁ ⊔ G₂) = edgeSet G₁ ∪ edgeSet G₂

tactic: rfl
state_before: case h.mk.mk
ι : Sort ?u.70414
𝕜 : Type ?u.70417
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
x✝ : Sym2 V
x y : V
⊢ Quot.mk Setoid.r (x, y) ∈ edgeSet (G₁ ⊔ G₂) ↔ Quot.mk Setoid.r (x, y) ∈ edgeSet G₁ ∪ edgeSet G₂
Theorem: IsLocalMaxOn.fderivWithin_nonpos
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: rw [fderivWithin_zero_of_not_differentiableWithinAt hf]
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ ↑(fderivWithin ℝ f s a) y ≤ 0

tactic: rfl
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ ↑0 y ≤ 0
Theorem: SimplicialObject.Splitting.ιSummand_eq
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: dsimp only [ιSummand, Iso.hom]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ιSummand s A = ι s (len A.fst.unop) ≫ X.map (IndexSet.e A).op

tactic: erw [colimit.ι_desc, Cofan.mk_ι_app]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ιCoprod s.N A ≫ (iso s Δ).hom = ι s (len A.fst.unop) ≫ X.map (IndexSet.e A).op
Theorem: Multiset.le_count_iff_replicate_le
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [quot_mk_to_coe'', mem_coe, coe_count]
state_before: α : Type u_1
β : Type ?u.395888
γ : Type ?u.395891
inst✝ : DecidableEq α
a : α
s : Multiset α
n : ℕ
_l : List α
⊢ n ≤ count a (Quot.mk Setoid.r _l) ↔ replicate n a ≤ Quot.mk Setoid.r _l

tactic: exact le_count_iff_replicate_sublist.trans replicate_le_coe.symm
state_before: α : Type u_1
β : Type ?u.395888
γ : Type ?u.395891
inst✝ : DecidableEq α
a : α
s : Multiset α
n : ℕ
_l : List α
⊢ n ≤ List.count a _l ↔ replicate n a ≤ ↑_l
Theorem: Equiv.Perm.sign_trans
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: rw [← mul_def, sign_mul]
state_before: α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
⊢ ↑sign (f.trans g) = ↑sign g * ↑sign f
Theorem: Filter.map_atTop_finset_prod_le_of_prod_eq
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: classical
  refine' ((atTop_basis.map _).le_basis_iff (atTop_basis.map _)).2 fun b _ => _
  let ⟨v, hv⟩ := h_eq b
  refine ⟨v, trivial, ?_⟩
  simpa [image_subset_iff] using hv
state_before: ι : Type ?u.355390
ι' : Type ?u.355393
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝ : CommMonoid α
f : β → α
g : γ → α
h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x in u', g x = ∏ b in v', f b
⊢ map (fun s => ∏ b in s, f b) atTop ≤ map (fun s => ∏ x in s, g x) atTop

tactic: refine' ((atTop_basis.map _).le_basis_iff (atTop_basis.map _)).2 fun b _ => _
state_before: ι : Type ?u.355390
ι' : Type ?u.355393
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝ : CommMonoid α
f : β → α
g : γ → α
h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x in u', g x = ∏ b in v', f b
⊢ map (fun s => ∏ b in s, f b) atTop ≤ map (fun s => ∏ x in s, g x) atTop

tactic: let ⟨v, hv⟩ := h_eq b
state_before: ι : Type ?u.355390
ι' : Type ?u.355393
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝ : CommMonoid α
f : β → α
g : γ → α
h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x in u', g x = ∏ b in v', f b
b : Finset γ
x✝ : True
⊢ ∃ i, True ∧ (fun s => ∏ b in s, f b) '' Ici i ⊆ (fun s => ∏ x in s, g x) '' Ici b

tactic: refine ⟨v, trivial, ?_⟩
state_before: ι : Type ?u.355390
ι' : Type ?u.355393
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝ : CommMonoid α
f : β → α
g : γ → α
h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x in u', g x = ∏ b in v', f b
b : Finset γ
x✝ : True
v : Finset β
hv : ∀ (v' : Finset β), v ⊆ v' → ∃ u', b ⊆ u' ∧ ∏ x in u', g x = ∏ b in v', f b
⊢ ∃ i, True ∧ (fun s => ∏ b in s, f b) '' Ici i ⊆ (fun s => ∏ x in s, g x) '' Ici b

tactic: simpa [image_subset_iff] using hv
state_before: ι : Type ?u.355390
ι' : Type ?u.355393
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝ : CommMonoid α
f : β → α
g : γ → α
h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x in u', g x = ∏ b in v', f b
b : Finset γ
x✝ : True
v : Finset β
hv : ∀ (v' : Finset β), v ⊆ v' → ∃ u', b ⊆ u' ∧ ∏ x in u', g x = ∏ b in v', f b
⊢ (fun s => ∏ b in s, f b) '' Ici v ⊆ (fun s => ∏ x in s, g x) '' Ici b
Theorem: Real.sq_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [sq, mul_self_sqrt h]
state_before: x y : ℝ
h : 0 ≤ x
⊢ sqrt x ^ 2 = x
Theorem: MeasureTheory.HasFiniteIntegral.tendsto_set_integral_nhds_zero
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [tendsto_zero_iff_norm_tendsto_zero]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.973542
𝕜 : Type ?u.973545
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 α
ι : Type u_1
f : α → E
hf : HasFiniteIntegral f
l : Filter ι
s : ι → Set α
hs : Tendsto (↑↑μ ∘ s) l (𝓝 0)
⊢ Tendsto (fun i => ∫ (x : α) in s i, f x ∂μ) l (𝓝 0)

tactic: simp_rw [← coe_nnnorm, ← NNReal.coe_zero, NNReal.tendsto_coe, ← ENNReal.tendsto_coe,
  ENNReal.coe_zero]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.973542
𝕜 : Type ?u.973545
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 α
ι : Type u_1
f : α → E
hf : HasFiniteIntegral f
l : Filter ι
s : ι → Set α
hs : Tendsto (↑↑μ ∘ s) l (𝓝 0)
⊢ Tendsto (fun e => ‖∫ (x : α) in s e, f x ∂μ‖) l (𝓝 0)

tactic: exact tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds
  (tendsto_set_lintegral_zero (ne_of_lt hf) hs) (fun i => zero_le _)
  fun i => ennnorm_integral_le_lintegral_ennnorm _
state_before: α : Type u_2
E : Type u_3
F : Type ?u.973542
𝕜 : Type ?u.973545
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 α
ι : Type u_1
f : α → E
hf : HasFiniteIntegral f
l : Filter ι
s : ι → Set α
hs : Tendsto (↑↑μ ∘ s) l (𝓝 0)
⊢ Tendsto (fun a => ↑‖∫ (x : α) in s a, f x ∂μ‖₊) l (𝓝 0)
Theorem: Int.not_lt
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.not_le, Decidable.not_not]
state_before: a b : Int
⊢ ¬a < b ↔ b ≤ a
Theorem: Rat.num_dvd
File: Mathlib/Data/Rat/Lemmas.lean

tactic: cases' e : a /. b with n d h c
state_before: a b : ℤ
b0 : b ≠ 0
⊢ (a /. b).num ∣ a

tactic: rw [Rat.num_den', divInt_eq_iff b0 (ne_of_gt (Int.coe_nat_pos.2 (Nat.pos_of_ne_zero h)))] at e
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (Int.natAbs n) d
e : a /. b = mk' n d
⊢ (mk' n d).num ∣ a

tactic: refine' Int.natAbs_dvd.1 <| Int.dvd_natAbs.1 <| Int.coe_nat_dvd.2 <| c.dvd_of_dvd_mul_right _
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (Int.natAbs n) d
e : a * ↑d = n * b
⊢ (mk' n d).num ∣ a

tactic: have := congr_arg Int.natAbs e
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (Int.natAbs n) d
e : a * ↑d = n * b
⊢ Int.natAbs n ∣ Int.natAbs a * d

tactic: simp only [Int.natAbs_mul, Int.natAbs_ofNat] at this
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (Int.natAbs n) d
e : a * ↑d = n * b
this : Int.natAbs (a * ↑d) = Int.natAbs (n * b)
⊢ Int.natAbs n ∣ Int.natAbs a * d

tactic: simp [this]
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (Int.natAbs n) d
e : a * ↑d = n * b
this : Int.natAbs a * d = Int.natAbs n * Int.natAbs b
⊢ Int.natAbs n ∣ Int.natAbs a * d
Theorem: CategoryTheory.Localization.Construction.fac
File: Mathlib/CategoryTheory/Localization/Construction.lean

tactic: intro X Y f
state_before: C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_3
inst✝ : Category D
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
⊢ ∀ (X Y : C) (f : X ⟶ Y),
    (MorphismProperty.Q W ⋙ lift G hG).map f =
      eqToHom (_ : (MorphismProperty.Q W ⋙ lift G hG).obj X = (MorphismProperty.Q W ⋙ lift G hG).obj X) ≫
        G.map f ≫ eqToHom (_ : G.obj Y = (MorphismProperty.Q W ⋙ lift G hG).obj Y)

tactic: simp only [Functor.comp_map, eqToHom_refl, comp_id, id_comp]
state_before: C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_3
inst✝ : Category D
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
X Y : C
f : X ⟶ Y
⊢ (MorphismProperty.Q W ⋙ lift G hG).map f =
    eqToHom (_ : (MorphismProperty.Q W ⋙ lift G hG).obj X = (MorphismProperty.Q W ⋙ lift G hG).obj X) ≫
      G.map f ≫ eqToHom (_ : G.obj Y = (MorphismProperty.Q W ⋙ lift G hG).obj Y)

tactic: dsimp [MorphismProperty.Q, Quot.liftOn]
state_before: C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_3
inst✝ : Category D
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
X Y : C
f : X ⟶ Y
⊢ (lift G hG).map ((MorphismProperty.Q W).map f) = G.map f

tactic: rw [composePath_toPath]
state_before: C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_3
inst✝ : Category D
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
X Y : C
f : X ⟶ Y
⊢ composePath (Quiver.Hom.toPath (G.map f)) = G.map f
Theorem: QuaternionGroup.orderOf_a_one
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: cases' eq_zero_or_neZero n with hn hn
state_before: n : ℕ
⊢ orderOf (a 1) = 2 * n

tactic: apply (Nat.le_of_dvd
  (NeZero.pos _) (orderOf_dvd_of_pow_eq_one (@a_one_pow_n n))).lt_or_eq.resolve_left
state_before: case inr
n : ℕ
hn : NeZero n
⊢ orderOf (a 1) = 2 * n

tactic: intro h
state_before: case inr
n : ℕ
hn : NeZero n
⊢ ¬orderOf (a 1) < 2 * n

tactic: have h1 : (a 1 : QuaternionGroup n) ^ orderOf (a 1) = 1 := pow_orderOf_eq_one _
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
⊢ False

tactic: rw [a_one_pow] at h1
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h1 : a 1 ^ orderOf (a 1) = 1
⊢ False

tactic: injection h1 with h2
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h1 : a ↑(orderOf (a 1)) = 1
⊢ False

tactic: rw [← ZMod.val_eq_zero, ZMod.val_nat_cast, Nat.mod_eq_of_lt h] at h2
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h2 : ↑(orderOf (a 1)) = 0
⊢ False

tactic: exact absurd h2.symm (orderOf_pos _).ne
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h2 : orderOf (a 1) = 0
⊢ False

tactic: subst hn
state_before: case inl
n : ℕ
hn : n = 0
⊢ orderOf (a 1) = 2 * n

tactic: simp_rw [MulZeroClass.mul_zero, orderOf_eq_zero_iff']
state_before: case inl

⊢ orderOf (a 1) = 2 * 0

tactic: intro n h
state_before: case inl

⊢ ∀ (n : ℕ), 0 < n → QuaternionGroup.a 1 ^ n ≠ 1

tactic: rw [one_def, a_one_pow]
state_before: case inl
n : ℕ
h : 0 < n
⊢ a 1 ^ n ≠ 1

tactic: apply mt a.inj
state_before: case inl
n : ℕ
h : 0 < n
⊢ a ↑n ≠ a 0

tactic: haveI : CharZero (ZMod (2 * 0)) := ZMod.charZero
state_before: case inl
n : ℕ
h : 0 < n
⊢ ¬↑n = 0

tactic: simpa using h.ne'
state_before: case inl
n : ℕ
h : 0 < n
this : CharZero (ZMod (2 * 0))
⊢ ¬↑n = 0
Theorem: HahnSeries.C_injective
File: Mathlib/RingTheory/HahnSeries.lean

tactic: intro r s rs
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
⊢ Injective ↑C

tactic: rw [HahnSeries.ext_iff, Function.funext_iff] at rs
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r s : R
rs : ↑C r = ↑C s
⊢ r = s

tactic: have h := rs 0
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r s : R
rs : ∀ (a : Γ), coeff (↑C r) a = coeff (↑C s) a
⊢ r = s

tactic: rwa [C_apply, single_coeff_same, C_apply, single_coeff_same] at h
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r s : R
rs : ∀ (a : Γ), coeff (↑C r) a = coeff (↑C s) a
h : coeff (↑C r) 0 = coeff (↑C s) 0
⊢ r = s
Theorem: InitialSeg.leLT_apply
File: Mathlib/Order/InitialSeg.lean

tactic: delta InitialSeg.leLT
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
⊢ ↑(leLT f g).toRelEmbedding a = ↑g.toRelEmbedding (↑f a)

tactic: cases' h : f.ltOrEq with f' f'
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
⊢ ↑(match ltOrEq f with
          | Sum.inl f' => PrincipalSeg.trans f' g
          | Sum.inr f' => PrincipalSeg.equivLT f' g).toRelEmbedding
      a =
    ↑g.toRelEmbedding (↑f a)

tactic: simp only [PrincipalSeg.trans_apply, f.ltOrEq_apply_left]
state_before: case inl
α : Type u_3
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
f' : r ≺i s
h : ltOrEq f = Sum.inl f'
⊢ ↑(match Sum.inl f' with
          | Sum.inl f' => PrincipalSeg.trans f' g
          | Sum.inr f' => PrincipalSeg.equivLT f' g).toRelEmbedding
      a =
    ↑g.toRelEmbedding (↑f a)

tactic: simp only [PrincipalSeg.equivLT_apply, f.ltOrEq_apply_right]
state_before: case inr
α : Type u_3
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
f' : r ≃r s
h : ltOrEq f = Sum.inr f'
⊢ ↑(match Sum.inr f' with
          | Sum.inl f' => PrincipalSeg.trans f' g
          | Sum.inr f' => PrincipalSeg.equivLT f' g).toRelEmbedding
      a =
    ↑g.toRelEmbedding (↑f a)