tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Integrable.comp_div_right
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: 𝕜 : Type ?u.62351
M : Type ?u.62354
α : Type ?u.62357
G : Type u_1
E : Type ?u.62363
F : Type u_2
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
f : G → F
inst✝ : IsMulRightInvariant μ
hf : Integrable f
g : G
⊢ Integrable fun t => f (t / g)

tactic: exact hf.comp_mul_right g⁻¹
state_before: 𝕜 : Type ?u.62351
M : Type ?u.62354
α : Type ?u.62357
G : Type u_1
E : Type ?u.62363
F : Type u_2
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
f : G → F
inst✝ : IsMulRightInvariant μ
hf : Integrable f
g : G
⊢ Integrable fun t => f (t * g⁻¹)
Theorem: MeasureTheory.SignedMeasure.haveLebesgueDecomposition_mk
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: by_cases hfi : Integrable f μ
state_before: α : Type u_1
β : Type ?u.458599
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
f : α → ℝ
hf : Measurable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
⊢ HaveLebesgueDecomposition s μ

tactic: exact haveLebesgueDecomposition_mk' μ hf hfi htμ hadd
state_before: case pos
α : Type u_1
β : Type ?u.458599
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
f : α → ℝ
hf : Measurable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
hfi : Integrable f
⊢ HaveLebesgueDecomposition s μ

tactic: rw [withDensityᵥ, dif_neg hfi, add_zero] at hadd
state_before: case neg
α : Type u_1
β : Type ?u.458599
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
f : α → ℝ
hf : Measurable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
hfi : ¬Integrable f
⊢ HaveLebesgueDecomposition s μ

tactic: refine' haveLebesgueDecomposition_mk' μ measurable_zero (integrable_zero _ _ μ) htμ _
state_before: case neg
α : Type u_1
β : Type ?u.458599
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
f : α → ℝ
hf : Measurable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t
hfi : ¬Integrable f
⊢ HaveLebesgueDecomposition s μ

tactic: rwa [withDensityᵥ_zero, add_zero]
state_before: case neg
α : Type u_1
β : Type ?u.458599
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
f : α → ℝ
hf : Measurable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t
hfi : ¬Integrable f
⊢ s = t + withDensityᵥ μ 0
Theorem: CategoryTheory.Sieve.sets_iff_generate
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rintro ⟨Z, f, g, hg, rfl⟩
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y✝ Z : C
f✝ : Y✝ ⟶ X
S✝ R✝ : Sieve X
R : Presieve X
S : Sieve X
ss : R ≤ S.arrows
Y : C
f : Y ⟶ X
⊢ (generate R).arrows f → S.arrows f

tactic: exact S.downward_closed (ss Z hg) f
state_before: case intro.intro.intro.intro
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y✝ Z✝ : C
f✝ : Y✝ ⟶ X
S✝ R✝ : Sieve X
R : Presieve X
S : Sieve X
ss : R ≤ S.arrows
Y Z : C
f : Y ⟶ Z
g : Z ⟶ X
hg : R g
⊢ S.arrows (f ≫ g)
Theorem: List.nthLe_enumFrom
File: Mathlib/Data/List/Basic.lean

tactic: simpa [length_enumFrom] using hi'
state_before: ι : Type ?u.455366
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n i : ℕ
hi' : i < length (enumFrom n l)
⊢ i < length l
Theorem: Function.iterate_add
File: Mathlib/Logic/Function/Iterate.lean

tactic: rw [Nat.add_succ, iterate_succ, iterate_succ, iterate_add m n]
state_before: α : Type u
β : Type v
f : α → α
m n : ℕ
⊢ f^[m + Nat.succ n] = f^[m] ∘ f^[Nat.succ n]

tactic: rfl
state_before: α : Type u
β : Type v
f : α → α
m n : ℕ
⊢ (f^[m] ∘ f^[n]) ∘ f = f^[m] ∘ f^[n] ∘ f
Theorem: EuclideanGeometry.dist_left_midpoint_eq_dist_right_midpoint
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: rw [dist_left_midpoint (𝕜 := ℝ) p1 p2, dist_right_midpoint (𝕜 := ℝ) p1 p2]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
⊢ dist p1 (midpoint ℝ p1 p2) = dist p2 (midpoint ℝ p1 p2)
Theorem: norm_image_sub_le_of_norm_deriv_le_segment
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: refine' norm_image_sub_le_of_norm_deriv_le_segment' _ bound
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.41030
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b C : ℝ
hf : DifferentiableOn ℝ f (Icc a b)
bound : ∀ (x : ℝ), x ∈ Ico a b → ‖derivWithin f (Icc a b) x‖ ≤ C
⊢ ∀ (x : ℝ), x ∈ Icc a b → ‖f x - f a‖ ≤ C * (x - a)

tactic: exact fun x hx => (hf x hx).hasDerivWithinAt
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.41030
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b C : ℝ
hf : DifferentiableOn ℝ f (Icc a b)
bound : ∀ (x : ℝ), x ∈ Ico a b → ‖derivWithin f (Icc a b) x‖ ≤ C
⊢ ∀ (x : ℝ), x ∈ Icc a b → HasDerivWithinAt (fun x => f x) (derivWithin f (Icc a b) x) (Icc a b) x
Theorem: List.foldrIdxM_eq_foldrM_enum
File: Mathlib/Data/List/Indexes.lean

tactic: simp only [foldrIdxM, foldrM_eq_foldr, foldrIdx_eq_foldr_enum, uncurry]
state_before: α✝ : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
β : Type u
f : ℕ → α → β → m β
b : β
as : List α
inst✝ : LawfulMonad m
⊢ foldrIdxM f b as = foldrM (uncurry f) b (enum as)
Theorem: LocalHomeomorph.ofSet_trans'
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [ofSet_trans, restr_source_inter]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.73421
δ : Type ?u.73424
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
s : Set α
hs : IsOpen s
⊢ LocalHomeomorph.trans (ofSet s hs) e = LocalHomeomorph.restr e (e.source ∩ s)
Theorem: Set.image_const_sub_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: have := image_comp (fun x => a + x) fun x => -x
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]

tactic: dsimp [Function.comp] at this
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]

tactic: simp [sub_eq_add_neg, this, add_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]
Theorem: nhds_of_nhdsWithin_of_nhds
File: Mathlib/Topology/ContinuousOn.lean

tactic: rcases mem_nhdsWithin_iff_exists_mem_nhds_inter.mp h2 with ⟨_, Hw, hw⟩
state_before: α : Type u_1
β : Type ?u.6425
γ : Type ?u.6428
δ : Type ?u.6431
inst✝ : TopologicalSpace α
s t : Set α
a : α
h1 : s ∈ 𝓝 a
h2 : t ∈ 𝓝[s] a
⊢ t ∈ 𝓝 a

tactic: exact (nhds a).sets_of_superset ((nhds a).inter_sets Hw h1) hw
state_before: case intro.intro
α : Type u_1
β : Type ?u.6425
γ : Type ?u.6428
δ : Type ?u.6431
inst✝ : TopologicalSpace α
s t : Set α
a : α
h1 : s ∈ 𝓝 a
h2 : t ∈ 𝓝[s] a
w✝ : Set α
Hw : w✝ ∈ 𝓝 a
hw : w✝ ∩ s ⊆ t
⊢ t ∈ 𝓝 a
Theorem: Cubic.disc_ne_zero_iff_roots_ne
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [← _root_.map_ne_zero φ, disc_eq_prod_three_roots ha h3, pow_two]
state_before: R : Type ?u.1293662
S : Type ?u.1293665
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ disc P ≠ 0 ↔ x ≠ y ∧ x ≠ z ∧ y ≠ z

tactic: simp_rw [mul_ne_zero_iff, sub_ne_zero, _root_.map_ne_zero, and_self_iff, and_iff_right ha,
  and_assoc]
state_before: R : Type ?u.1293662
S : Type ?u.1293665
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ ↑φ P.a * ↑φ P.a * (x - y) * (x - z) * (y - z) * (↑φ P.a * ↑φ P.a * (x - y) * (x - z) * (y - z)) ≠ 0 ↔
    x ≠ y ∧ x ≠ z ∧ y ≠ z
Theorem: LinearMap.graph_eq_ker_coprod
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext x
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.599912
M₆ : Type ?u.599915
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
⊢ graph g = ker (coprod (-g) id)

tactic: change _ = _ ↔ -g x.1 + x.2 = _
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.599912
M₆ : Type ?u.599915
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
x : M₃ × M₄
⊢ x ∈ graph g ↔ x ∈ ker (coprod (-g) id)

tactic: rw [add_comm, add_neg_eq_zero]
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.599912
M₆ : Type ?u.599915
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
x : M₃ × M₄
⊢ x.snd = ↑g x.fst ↔ -↑g x.fst + x.snd = 0
Theorem: continuousInv_iInf
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [← sInf_range]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
ι' : Sort u_1
inst✝ : Inv G
ts' : ι' → TopologicalSpace G
h' : ∀ (i : ι'), ContinuousInv G
⊢ ContinuousInv G

tactic: exact continuousInv_sInf (Set.forall_range_iff.mpr h')
state_before: α : Type u
β : Type v
G : Type w
H : Type x
ι' : Sort u_1
inst✝ : Inv G
ts' : ι' → TopologicalSpace G
h' : ∀ (i : ι'), ContinuousInv G
⊢ ContinuousInv G
Theorem: Stream'.length_take
File: Mathlib/Data/Stream/Init.lean

tactic: induction n generalizing s <;> simp [*, take_succ]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ List.length (take n s) = n
Theorem: AlgebraicTopology.DoldKan.Compatibility.equivalence₁CounitIso_eq
File: Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean

tactic: ext Y
state_before: A : Type u_4
A' : Type u_5
B : Type ?u.10546
B' : Type u_1
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
⊢ (equivalence₁ hF).counitIso = equivalence₁CounitIso hF

tactic: dsimp [equivalence₁]
state_before: case w.w.h
A : Type u_4
A' : Type u_5
B : Type ?u.10546
B' : Type u_1
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
Y : B'
⊢ (equivalence₁ hF).counitIso.hom.app Y = (equivalence₁CounitIso hF).hom.app Y

tactic: unfold Functor.asEquivalence
state_before: case w.w.h
A : Type u_4
A' : Type u_5
B : Type ?u.10546
B' : Type u_1
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
Y : B'
⊢ (Functor.asEquivalence F).counitIso.hom.app Y = (equivalence₁CounitIso hF).hom.app Y

tactic: dsimp [equivalence₀, IsEquivalence.inverse, IsEquivalence.ofEquivalence]
state_before: case w.w.h
A : Type u_4
A' : Type u_5
B : Type ?u.10546
B' : Type u_1
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
Y : B'
⊢ (Equivalence.mk' F (IsEquivalence.inverse F) IsEquivalence.unitIso IsEquivalence.counitIso).counitIso.hom.app Y =
    (equivalence₁CounitIso hF).hom.app Y

tactic: simp
state_before: case w.w.h
A : Type u_4
A' : Type u_5
B : Type ?u.10546
B' : Type u_1
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
Y : B'
⊢ IsEquivalence.counitIso.hom.app Y = (equivalence₁CounitIso hF).hom.app Y
Theorem: ChartedSpace.secondCountable_of_countable_cover
File: Mathlib/Geometry/Manifold/ChartedSpace.lean

tactic: haveI : ∀ x : M, SecondCountableTopology (chartAt H x).source :=
  fun x ↦ (chartAt (H := H) x).secondCountableTopology_source
state_before: H : Type u
H' : Type ?u.43633
M : Type u_1
M' : Type ?u.43639
M'' : Type ?u.43642
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : (⋃ (x : M) (_ : x ∈ s), (chartAt H x).toLocalEquiv.source) = univ
hsc : Set.Countable s
⊢ SecondCountableTopology M

tactic: haveI := hsc.toEncodable
state_before: H : Type u
H' : Type ?u.43633
M : Type u_1
M' : Type ?u.43639
M'' : Type ?u.43642
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : (⋃ (x : M) (_ : x ∈ s), (chartAt H x).toLocalEquiv.source) = univ
hsc : Set.Countable s
this : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).toLocalEquiv.source
⊢ SecondCountableTopology M

tactic: rw [biUnion_eq_iUnion] at hs
state_before: H : Type u
H' : Type ?u.43633
M : Type u_1
M' : Type ?u.43639
M'' : Type ?u.43642
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : (⋃ (x : M) (_ : x ∈ s), (chartAt H x).toLocalEquiv.source) = univ
hsc : Set.Countable s
this✝ : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).toLocalEquiv.source
this : Encodable ↑s
⊢ SecondCountableTopology M

tactic: exact secondCountableTopology_of_countable_cover (fun x : s ↦ (chartAt H (x : M)).open_source) hs
state_before: H : Type u
H' : Type ?u.43633
M : Type u_1
M' : Type ?u.43639
M'' : Type ?u.43642
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : (⋃ (x : ↑s), (chartAt H ↑x).toLocalEquiv.source) = univ
hsc : Set.Countable s
this✝ : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).toLocalEquiv.source
this : Encodable ↑s
⊢ SecondCountableTopology M
Theorem: Filter.antitone_seq_of_seq
File: Mathlib/Order/Filter/Bases.lean

tactic: use fun n => ⋂ m ≤ n, s m
state_before: α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
⊢ ∃ t, Antitone t ∧ (⨅ (i : ℕ), 𝓟 (s i)) = ⨅ (i : ℕ), 𝓟 (t i)

tactic: constructor
state_before: α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
⊢ (Antitone fun n => ⋂ (m : ℕ) (_ : m ≤ n), s m) ∧
    (⨅ (i : ℕ), 𝓟 (s i)) = ⨅ (i : ℕ), 𝓟 ((fun n => ⋂ (m : ℕ) (_ : m ≤ n), s m) i)

tactic: apply le_antisymm <;> rw [le_iInf_iff] <;> intro i
state_before: case right
α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
⊢ (⨅ (i : ℕ), 𝓟 (s i)) = ⨅ (i : ℕ), 𝓟 ((fun n => ⋂ (m : ℕ) (_ : m ≤ n), s m) i)

tactic: exact fun i j hij => biInter_mono (Iic_subset_Iic.2 hij) fun n _ => Subset.rfl
state_before: case left
α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
⊢ Antitone fun n => ⋂ (m : ℕ) (_ : m ≤ n), s m

tactic: rw [le_principal_iff]
state_before: case right.a
α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
i : ℕ
⊢ (⨅ (i : ℕ), 𝓟 (s i)) ≤ 𝓟 ((fun n => ⋂ (m : ℕ) (_ : m ≤ n), s m) i)

tactic: refine' (biInter_mem (finite_le_nat _)).2 fun j _ => _
state_before: case right.a
α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
i : ℕ
⊢ (fun n => ⋂ (m : ℕ) (_ : m ≤ n), s m) i ∈ ⨅ (i : ℕ), 𝓟 (s i)

tactic: exact mem_iInf_of_mem j (mem_principal_self _)
state_before: case right.a
α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
i j : ℕ
x✝ : j ∈ {i_1 | i_1 ≤ i}
⊢ s j ∈ ⨅ (i : ℕ), 𝓟 (s i)

tactic: refine iInf_le_of_le i (principal_mono.2 <| iInter₂_subset i ?_)
state_before: case right.a
α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
i : ℕ
⊢ (⨅ (i : ℕ), 𝓟 ((fun n => ⋂ (m : ℕ) (_ : m ≤ n), s m) i)) ≤ 𝓟 (s i)

tactic: rfl
state_before: case right.a
α : Type u_1
β : Type ?u.93399
γ : Type ?u.93402
ι : Type ?u.93405
ι' : Sort ?u.93408
s : ℕ → Set α
i : ℕ
⊢ i ≤ i
Theorem: MvPolynomial.support_sdiff_support_subset_support_add
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: intro m hm
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✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ support p \ support q ⊆ support (p + q)

tactic: simp only [Classical.not_not, mem_support_iff, Finset.mem_sdiff, Ne.def] at hm
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✝ : DecidableEq σ
p q : MvPolynomial σ R
m : σ →₀ ℕ
hm : m ∈ support p \ support q
⊢ m ∈ support (p + q)

tactic: simp [hm.2, hm.1]
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✝ : DecidableEq σ
p q : MvPolynomial σ R
m : σ →₀ ℕ
hm : ¬coeff m p = 0 ∧ coeff m q = 0
⊢ m ∈ support (p + q)
Theorem: Finsupp.neLocus_self_sub_right
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: rw [sub_eq_add_neg, neLocus_self_add_right, support_neg]
state_before: α : Type u_1
M : Type ?u.38497
N : Type u_2
P : Type ?u.38503
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus f (f - g) = g.support
Theorem: continuousAt_of_locally_uniform_approx_of_continuousAt
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [← continuousWithinAt_univ]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
L : ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∃ t, t ∈ 𝓝 x ∧ ∃ F, ContinuousAt F x ∧ ∀ (y : α), y ∈ t → (f y, F y) ∈ u
⊢ ContinuousAt f x

tactic: apply continuousWithinAt_of_locally_uniform_approx_of_continuousWithinAt (mem_univ _) _
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
L : ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∃ t, t ∈ 𝓝 x ∧ ∃ F, ContinuousAt F x ∧ ∀ (y : α), y ∈ t → (f y, F y) ∈ u
⊢ ContinuousWithinAt f univ x

tactic: simpa only [exists_prop, nhdsWithin_univ, continuousWithinAt_univ] using L
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
L : ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∃ t, t ∈ 𝓝 x ∧ ∃ F, ContinuousAt F x ∧ ∀ (y : α), y ∈ t → (f y, F y) ∈ u
⊢ ∀ (u : Set (β × β)),
    u ∈ 𝓤 β → ∃ t, t ∈ 𝓝[univ] x ∧ ∃ F, ContinuousWithinAt F univ x ∧ ∀ (y : α), y ∈ t → (f y, F y) ∈ u
Theorem: Nat.Primrec.mul
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: p : ℕ
⊢ unpaired
      (fun z n =>
        Nat.rec 0
          (fun y IH =>
            unpaired (fun x x_1 => x + x_1)
              (Nat.pair (unpair (Nat.pair z (Nat.pair y IH))).fst
                (unpair (unpair (Nat.pair z (Nat.pair y IH))).snd).snd))
          n)
      p =
    unpaired (fun x x_1 => x * x_1) p

tactic: induction p.unpair.2 <;> simp [*, mul_succ, add_comm _ (unpair p).fst]
state_before: p : ℕ
⊢ Nat.rec 0 (fun y IH => (unpair p).fst + IH) (unpair p).snd = (unpair p).fst * (unpair p).snd
Theorem: le_of_toZ_le
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: cases' le_or_lt i0 i with hi hi <;> cases' le_or_lt i0 j with hj hj
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i j : ι
h_le : toZ i0 i ≤ toZ i0 j
⊢ i ≤ j

tactic: rw [← iterate_succ_toZ i hi, ← iterate_succ_toZ j hj]
state_before: case inl.inl
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i j : ι
h_le : toZ i0 i ≤ toZ i0 j
hi : i0 ≤ i
hj : i0 ≤ j
⊢ i ≤ j

tactic: exact Monotone.monotone_iterate_of_le_map succ_mono (le_succ _) (Int.toNat_le_toNat h_le)
state_before: case inl.inl
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i j : ι
h_le : toZ i0 i ≤ toZ i0 j
hi : i0 ≤ i
hj : i0 ≤ j
⊢ (succ^[Int.toNat (toZ i0 i)]) i0 ≤ (succ^[Int.toNat (toZ i0 j)]) i0

tactic: exact absurd ((toZ_neg hj).trans_le (toZ_nonneg hi)) (not_lt.mpr h_le)
state_before: case inl.inr
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i j : ι
h_le : toZ i0 i ≤ toZ i0 j
hi : i0 ≤ i
hj : j < i0
⊢ i ≤ j

tactic: exact hi.le.trans hj
state_before: case inr.inl
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i j : ι
h_le : toZ i0 i ≤ toZ i0 j
hi : i < i0
hj : i0 ≤ j
⊢ i ≤ j

tactic: rw [← iterate_pred_toZ i hi, ← iterate_pred_toZ j hj]
state_before: case inr.inr
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i j : ι
h_le : toZ i0 i ≤ toZ i0 j
hi : i < i0
hj : j < i0
⊢ i ≤ j

tactic: refine' Monotone.antitone_iterate_of_map_le pred_mono (pred_le _) (Int.toNat_le_toNat _)
state_before: case inr.inr
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i j : ι
h_le : toZ i0 i ≤ toZ i0 j
hi : i < i0
hj : j < i0
⊢ (pred^[Int.toNat (-toZ i0 i)]) i0 ≤ (pred^[Int.toNat (-toZ i0 j)]) i0

tactic: exact neg_le_neg h_le
state_before: case inr.inr
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i j : ι
h_le : toZ i0 i ≤ toZ i0 j
hi : i < i0
hj : j < i0
⊢ -toZ i0 j ≤ -toZ i0 i
Theorem: Traversable.foldlm.ofFreeMonoid_comp_of
File: Mathlib/Control/Fold.lean

tactic: ext1 x
state_before: α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : IsLawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
⊢ ↑(foldlM.ofFreeMonoid f) ∘ FreeMonoid.of = foldlM.mk ∘ flip f
Theorem: IsLocalization.AtPrime.to_map_mem_maximal_iff
File: Mathlib/RingTheory/Localization/AtPrime.lean

tactic: simpa only [LocalRing.mem_maximalIdeal, mem_nonunits_iff, Classical.not_not] using
  isUnit_to_map_iff S I x
state_before: R : Type u_2
inst✝⁶ : CommSemiring R
M : Submonoid R
S : Type u_1
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
P : Type ?u.46855
inst✝³ : CommSemiring P
A : Type ?u.46861
inst✝² : CommRing A
inst✝¹ : IsDomain A
I : Ideal R
hI : Ideal.IsPrime I
inst✝ : IsLocalization.AtPrime S I
x : R
h : optParam (LocalRing S) (_ : LocalRing S)
⊢ ¬↑(algebraMap R S) x ∈ LocalRing.maximalIdeal S ↔ ¬x ∈ I