1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.tendsto_lintegral_nn_filter_of_le_const
File: Mathlib/MeasureTheory/Measure/HasOuterApproxClosed.lean

tactic: refine tendsto_lintegral_filter_of_dominated_convergence (fun _ ↦ c)
  (eventually_of_forall fun i ↦ (ENNReal.continuous_coe.comp (fs i).continuous).measurable) ?_
  (@lintegral_const_lt_top _ _ μ _ _ (@ENNReal.coe_ne_top c)).ne ?_
state_before: Ω : Type u_1
inst✝⁴ : TopologicalSpace Ω
inst✝³ : MeasurableSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
inst✝¹ : L.IsCountablyGenerated
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂μ, (fs i) ω ≤ c
f : Ω → ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun i => (fs i) ω) L (𝓝 (f ω))
⊢ Tendsto (fun i => ∫⁻ (ω : Ω), ↑((fs i) ω) ∂μ) L (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂μ))
state_after: case refine_1
Ω : Type u_1
inst✝⁴ : TopologicalSpace Ω
inst✝³ : MeasurableSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
inst✝¹ : L.IsCountablyGenerated
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂μ, (fs i) ω ≤ c
f : Ω → ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun i => (fs i) ω) L (𝓝 (f ω))
⊢ ∀ᶠ (n : ι) in L, ∀ᵐ (a : Ω) ∂μ, ↑((fs n) a) ≤ (fun x => ↑c) a

case refine_2
Ω : Type u_1
inst✝⁴ : TopologicalSpace Ω
inst✝³ : MeasurableSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
inst✝¹ : L.IsCountablyGenerated
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂μ, (fs i) ω ≤ c
f : Ω → ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun i => (fs i) ω) L (𝓝 (f ω))
⊢ ∀ᵐ (a : Ω) ∂μ, Tendsto (fun n => ↑((fs n) a)) L (𝓝 ↑(f a))

tactic: simpa only [Function.comp_apply, ENNReal.coe_le_coe] using fs_le_const
state_before: case refine_1
Ω : Type u_1
inst✝⁴ : TopologicalSpace Ω
inst✝³ : MeasurableSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
inst✝¹ : L.IsCountablyGenerated
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂μ, (fs i) ω ≤ c
f : Ω → ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun i => (fs i) ω) L (𝓝 (f ω))
⊢ ∀ᶠ (n : ι) in L, ∀ᵐ (a : Ω) ∂μ, ↑((fs n) a) ≤ (fun x => ↑c) a
state_after: no goals

tactic: simpa only [Function.comp_apply, ENNReal.tendsto_coe] using fs_lim
state_before: case refine_2
Ω : Type u_1
inst✝⁴ : TopologicalSpace Ω
inst✝³ : MeasurableSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
inst✝¹ : L.IsCountablyGenerated
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂μ, (fs i) ω ≤ c
f : Ω → ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun i => (fs i) ω) L (𝓝 (f ω))
⊢ ∀ᵐ (a : Ω) ∂μ, Tendsto (fun n => ↑((fs n) a)) L (𝓝 ↑(f a))
state_after: no goals
Theorem: Nat.Primrec'.unpair₁
File: Mathlib/Computability/Primrec.lean

tactic: have s := sqrt.comp₁ _ hf
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
⊢ Primrec' fun v => (unpair (f v)).1
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
⊢ Primrec' fun v => (unpair (f v)).1

tactic: have fss := sub.comp₂ _ hf (mul.comp₂ _ s s)
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
⊢ Primrec' fun v => (unpair (f v)).1
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
⊢ Primrec' fun v => (unpair (f v)).1

tactic: refine (if_lt fss s fss s).of_eq fun v => ?_
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
⊢ Primrec' fun v => (unpair (f v)).1
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
v : Vector ℕ n
⊢ (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then f v - (f v).sqrt * (f v).sqrt else (f v).sqrt) = (unpair (f v)).1

tactic: simp [Nat.unpair]
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
v : Vector ℕ n
⊢ (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then f v - (f v).sqrt * (f v).sqrt else (f v).sqrt) = (unpair (f v)).1
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
v : Vector ℕ n
⊢ (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then f v - (f v).sqrt * (f v).sqrt else (f v).sqrt) =
    (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then (f v - (f v).sqrt * (f v).sqrt, (f v).sqrt)
      else ((f v).sqrt, f v - (f v).sqrt * (f v).sqrt - (f v).sqrt)).1

tactic: split_ifs <;> rfl
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
v : Vector ℕ n
⊢ (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then f v - (f v).sqrt * (f v).sqrt else (f v).sqrt) =
    (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then (f v - (f v).sqrt * (f v).sqrt, (f v).sqrt)
      else ((f v).sqrt, f v - (f v).sqrt * (f v).sqrt - (f v).sqrt)).1
state_after: no goals
Theorem: Nat.totient_mul
File: Mathlib/Data/Nat/Totient.lean

tactic: cases' Nat.mul_eq_zero.1 hmn0 with h h <;>
  simp only [totient_zero, mul_zero, zero_mul, h]
state_before: m n : ℕ
h : m.Coprime n
hmn0 : m * n = 0
⊢ φ (m * n) = φ m * φ n
state_after: no goals

tactic: haveI : NeZero (m * n) := ⟨hmn0⟩
state_before: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
⊢ φ (m * n) = φ m * φ n
state_after: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
this : NeZero (m * n)
⊢ φ (m * n) = φ m * φ n

tactic: haveI : NeZero m := ⟨left_ne_zero_of_mul hmn0⟩
state_before: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
this : NeZero (m * n)
⊢ φ (m * n) = φ m * φ n
state_after: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
this✝ : NeZero (m * n)
this : NeZero m
⊢ φ (m * n) = φ m * φ n

tactic: haveI : NeZero n := ⟨right_ne_zero_of_mul hmn0⟩
state_before: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
this✝ : NeZero (m * n)
this : NeZero m
⊢ φ (m * n) = φ m * φ n
state_after: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
this✝¹ : NeZero (m * n)
this✝ : NeZero m
this : NeZero n
⊢ φ (m * n) = φ m * φ n

tactic: simp only [← ZMod.card_units_eq_totient]
state_before: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
this✝¹ : NeZero (m * n)
this✝ : NeZero m
this : NeZero n
⊢ φ (m * n) = φ m * φ n
state_after: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
this✝¹ : NeZero (m * n)
this✝ : NeZero m
this : NeZero n
⊢ Fintype.card (ZMod (m * n))ˣ = Fintype.card (ZMod m)ˣ * Fintype.card (ZMod n)ˣ

tactic: rw [Fintype.card_congr (Units.mapEquiv (ZMod.chineseRemainder h).toMulEquiv).toEquiv,
  Fintype.card_congr (@MulEquiv.prodUnits (ZMod m) (ZMod n) _ _).toEquiv, Fintype.card_prod]
state_before: m n : ℕ
h : m.Coprime n
hmn0 : ¬m * n = 0
this✝¹ : NeZero (m * n)
this✝ : NeZero m
this : NeZero n
⊢ Fintype.card (ZMod (m * n))ˣ = Fintype.card (ZMod m)ˣ * Fintype.card (ZMod n)ˣ
state_after: no goals
Theorem: StrictConvexOn.add
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [smul_add, smul_add, add_add_add_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁵ : OrderedSemiring 𝕜
inst✝⁴ : AddCommMonoid E
inst✝³ : AddCommMonoid F
inst✝² : OrderedCancelAddCommMonoid β
inst✝¹ : SMul 𝕜 E
inst✝ : DistribMulAction 𝕜 β
s : Set E
f g : E → β
hf : StrictConvexOn 𝕜 s f
hg : StrictConvexOn 𝕜 s g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • f x + b • f y + (a • g x + b • g y) = a • (f x + g x) + b • (f y + g y)
state_after: no goals
Theorem: AddSubgroup.dense_or_cyclic
File: Mathlib/Topology/Algebra/Order/Archimedean.lean

tactic: refine (em _).imp (dense_of_not_isolated_zero S) fun h => ?_
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
⊢ Dense ↑S ∨ ∃ a, S = closure {a}
state_after: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
h : ¬∀ ε > 0, ∃ g ∈ S, g ∈ Ioo 0 ε
⊢ ∃ a, S = closure {a}

tactic: push_neg at h
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
h : ¬∀ ε > 0, ∃ g ∈ S, g ∈ Ioo 0 ε
⊢ ∃ a, S = closure {a}
state_after: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
h : ∃ ε > 0, ∀ g ∈ S, g ∉ Ioo 0 ε
⊢ ∃ a, S = closure {a}

tactic: rcases h with ⟨ε, ε0, hε⟩
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
h : ∃ ε > 0, ∀ g ∈ S, g ∉ Ioo 0 ε
⊢ ∃ a, S = closure {a}
state_after: case intro.intro
G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
ε : G
ε0 : ε > 0
hε : ∀ g ∈ S, g ∉ Ioo 0 ε
⊢ ∃ a, S = closure {a}

tactic: exact cyclic_of_isolated_zero ε0 (disjoint_left.2 hε)
state_before: case intro.intro
G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
ε : G
ε0 : ε > 0
hε : ∀ g ∈ S, g ∉ Ioo 0 ε
⊢ ∃ a, S = closure {a}
state_after: no goals
Theorem: CategoryTheory.exact_comp_mono_iff
File: Mathlib/Algebra/Homology/Exact.lean

tactic: refine
  ⟨fun hfg => ⟨zero_of_comp_mono h (by rw [Category.assoc, hfg.1]), ?_⟩, fun h =>
    exact_comp_mono h⟩
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : Mono h
⊢ Exact f (g ≫ h) ↔ Exact f g
state_after: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : Mono h
hfg : Exact f (g ≫ h)
⊢ Epi (imageToKernel f g ⋯)

tactic: rw [← (Iso.eq_comp_inv _).1 (imageToKernel_comp_mono _ _ h hfg.1)]
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : Mono h
hfg : Exact f (g ≫ h)
⊢ Epi (imageToKernel f g ⋯)
state_after: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : Mono h
hfg : Exact f (g ≫ h)
⊢ Epi (imageToKernel f (g ≫ h) ⋯ ≫ ((kernelSubobject (g ≫ h)).isoOfEq (kernelSubobject g) ⋯).hom)

tactic: haveI := hfg.2
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : Mono h
hfg : Exact f (g ≫ h)
⊢ Epi (imageToKernel f (g ≫ h) ⋯ ≫ ((kernelSubobject (g ≫ h)).isoOfEq (kernelSubobject g) ⋯).hom)
state_after: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : Mono h
hfg : Exact f (g ≫ h)
this : Epi (imageToKernel f (g ≫ h) ⋯)
⊢ Epi (imageToKernel f (g ≫ h) ⋯ ≫ ((kernelSubobject (g ≫ h)).isoOfEq (kernelSubobject g) ⋯).hom)

tactic: infer_instance
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : Mono h
hfg : Exact f (g ≫ h)
this : Epi (imageToKernel f (g ≫ h) ⋯)
⊢ Epi (imageToKernel f (g ≫ h) ⋯ ≫ ((kernelSubobject (g ≫ h)).isoOfEq (kernelSubobject g) ⋯).hom)
state_after: no goals

tactic: rw [Category.assoc, hfg.1]
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : Mono h
hfg : Exact f (g ≫ h)
⊢ (f ≫ g) ≫ h = 0
state_after: no goals
Theorem: Polynomial.degree_add_eq_left_of_degree_lt
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [coeff_add, coeff_natDegree_eq_zero_of_degree_lt h, add_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : q.degree < p.degree
⊢ (p + q).coeff p.natDegree ≠ 0
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : q.degree < p.degree
⊢ p.coeff p.natDegree ≠ 0

tactic: exact mt leadingCoeff_eq_zero.1 (ne_zero_of_degree_gt h)
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : q.degree < p.degree
⊢ p.coeff p.natDegree ≠ 0
state_after: no goals
Theorem: Compactum.basic_inter
File: Mathlib/Topology/Category/Compactum.lean

tactic: ext G
state_before: X : Compactum
A B : Set X.A
⊢ Compactum.basic (A ∩ B) = Compactum.basic A ∩ Compactum.basic B
state_after: case h
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic (A ∩ B) ↔ G ∈ Compactum.basic A ∩ Compactum.basic B

tactic: constructor
state_before: case h
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic (A ∩ B) ↔ G ∈ Compactum.basic A ∩ Compactum.basic B
state_after: case h.mp
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic (A ∩ B) → G ∈ Compactum.basic A ∩ Compactum.basic B

case h.mpr
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic A ∩ Compactum.basic B → G ∈ Compactum.basic (A ∩ B)

tactic: intro hG
state_before: case h.mp
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic (A ∩ B) → G ∈ Compactum.basic A ∩ Compactum.basic B
state_after: case h.mp
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
⊢ G ∈ Compactum.basic A ∩ Compactum.basic B

tactic: constructor <;> filter_upwards [hG] with _
state_before: case h.mp
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
⊢ G ∈ Compactum.basic A ∩ Compactum.basic B
state_after: case h
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
a✝ : X.A
⊢ a✝ ∈ A ∩ B → a✝ ∈ A

case h
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
a✝ : X.A
⊢ a✝ ∈ A ∩ B → a✝ ∈ B

tactic: exacts [And.left, And.right]
state_before: case h
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
a✝ : X.A
⊢ a✝ ∈ A ∩ B → a✝ ∈ A

case h
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
a✝ : X.A
⊢ a✝ ∈ A ∩ B → a✝ ∈ B
state_after: no goals

tactic: rintro ⟨h1, h2⟩
state_before: case h.mpr
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic A ∩ Compactum.basic B → G ∈ Compactum.basic (A ∩ B)
state_after: case h.mpr.intro
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
h1 : G ∈ Compactum.basic A
h2 : G ∈ Compactum.basic B
⊢ G ∈ Compactum.basic (A ∩ B)

tactic: exact inter_mem h1 h2
state_before: case h.mpr.intro
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
h1 : G ∈ Compactum.basic A
h2 : G ∈ Compactum.basic B
⊢ G ∈ Compactum.basic (A ∩ B)
state_after: no goals
Theorem: Associates.coe_unit_eq_one
File: Mathlib/Algebra/Associated.lean

tactic: simp [eq_iff_true_of_subsingleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
u : (Associates α)ˣ
⊢ ↑u = 1
state_after: no goals
Theorem: Odd.add_dvd_pow_add_pow
File: Mathlib/Algebra/GeomSum.lean

tactic: have h₁ := geom_sum₂_mul x (-y) n
state_before: α : Type u
inst✝ : CommRing α
x y : α
n : ℕ
h : Odd n
⊢ x + y ∣ x ^ n + y ^ n
state_after: α : Type u
inst✝ : CommRing α
x y : α
n : ℕ
h : Odd n
h₁ : (∑ i ∈ range n, x ^ i * (-y) ^ (n - 1 - i)) * (x - -y) = x ^ n - (-y) ^ n
⊢ x + y ∣ x ^ n + y ^ n

tactic: rw [Odd.neg_pow h y, sub_neg_eq_add, sub_neg_eq_add] at h₁
state_before: α : Type u
inst✝ : CommRing α
x y : α
n : ℕ
h : Odd n
h₁ : (∑ i ∈ range n, x ^ i * (-y) ^ (n - 1 - i)) * (x - -y) = x ^ n - (-y) ^ n
⊢ x + y ∣ x ^ n + y ^ n
state_after: α : Type u
inst✝ : CommRing α
x y : α
n : ℕ
h : Odd n
h₁ : (∑ i ∈ range n, x ^ i * (-y) ^ (n - 1 - i)) * (x + y) = x ^ n + y ^ n
⊢ x + y ∣ x ^ n + y ^ n

tactic: exact Dvd.intro_left _ h₁
state_before: α : Type u
inst✝ : CommRing α
x y : α
n : ℕ
h : Odd n
h₁ : (∑ i ∈ range n, x ^ i * (-y) ^ (n - 1 - i)) * (x + y) = x ^ n + y ^ n
⊢ x + y ∣ x ^ n + y ^ n
state_after: no goals
Theorem: MvPolynomial.constantCoeff_comp_map
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: ext <;> simp
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
f✝ f : R →+* S₁
⊢ constantCoeff.comp (map f) = f.comp constantCoeff
state_after: no goals
Theorem: IsAdjoinRoot.ofEquiv_aequiv
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: ext a
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot U f
e : S ≃ₐ[R] T
⊢ (h.ofEquiv e).aequiv h' = e.symm.trans (h.aequiv h')
state_after: case h
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot U f
e : S ≃ₐ[R] T
a : T
⊢ ((h.ofEquiv e).aequiv h') a = (e.symm.trans (h.aequiv h')) a

tactic: rw [← (h.ofEquiv e).map_repr a, aequiv_map, AlgEquiv.trans_apply, ofEquiv_map_apply,
  e.symm_apply_apply, aequiv_map]
state_before: case h
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot U f
e : S ≃ₐ[R] T
a : T
⊢ ((h.ofEquiv e).aequiv h') a = (e.symm.trans (h.aequiv h')) a
state_after: no goals
Theorem: Encodable.decode_list_succ
File: Mathlib/Logic/Equiv/List.lean

tactic: cases' e : unpair v with v₁ v₂
state_before: α : Type u_1
inst✝ : Encodable α
v : ℕ
⊢ decodeList v.succ = Seq.seq ((fun x x_1 => x :: x_1) <$> decode (unpair v).1) fun x => decode (unpair v).2
state_after: case mk
α : Type u_1
inst✝ : Encodable α
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ decodeList v.succ = Seq.seq ((fun x x_1 => x :: x_1) <$> decode (v₁, v₂).1) fun x => decode (v₁, v₂).2

tactic: simp [decodeList, e]
state_before: case mk
α : Type u_1
inst✝ : Encodable α
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ decodeList v.succ = Seq.seq ((fun x x_1 => x :: x_1) <$> decode (v₁, v₂).1) fun x => decode (v₁, v₂).2
state_after: case mk
α : Type u_1
inst✝ : Encodable α
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ (Seq.seq (Option.map (fun x x_1 => x :: x_1) (decode v₁)) fun x => decodeList v₂) =
    Seq.seq (Option.map (fun x x_1 => x :: x_1) (decode v₁)) fun x => decode v₂

tactic: rfl
state_before: case mk
α : Type u_1
inst✝ : Encodable α
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ (Seq.seq (Option.map (fun x x_1 => x :: x_1) (decode v₁)) fun x => decodeList v₂) =
    Seq.seq (Option.map (fun x x_1 => x :: x_1) (decode v₁)) fun x => decode v₂
state_after: no goals
Theorem: Mathlib.Tactic.ComputeDegree.natDegree_eq_of_le_of_coeff_ne_zero'
File: Mathlib/Tactic/ComputeDegree.lean

tactic: subst coeff_eq deg_eq_deg coeff_eq_deg
state_before: R : Type u_1
inst✝ : Semiring R
deg m o : ℕ
c : R
p : R[X]
h_natDeg_le : p.natDegree ≤ m
coeff_eq : p.coeff o = c
coeff_ne_zero : c ≠ 0
deg_eq_deg : m = deg
coeff_eq_deg : o = deg
⊢ p.natDegree = deg
state_after: R : Type u_1
inst✝ : Semiring R
o : ℕ
p : R[X]
coeff_ne_zero : p.coeff o ≠ 0
h_natDeg_le : p.natDegree ≤ o
⊢ p.natDegree = o

tactic: exact natDegree_eq_of_le_of_coeff_ne_zero ‹_› ‹_›
state_before: R : Type u_1
inst✝ : Semiring R
o : ℕ
p : R[X]
coeff_ne_zero : p.coeff o ≠ 0
h_natDeg_le : p.natDegree ≤ o
⊢ p.natDegree = o
state_after: no goals
Theorem: SeminormedGroup.tendstoUniformlyOn_one
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [tendstoUniformlyOn_iff, Pi.one_apply, dist_one_left]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s✝ : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
f : ι → κ → G
s : Set κ
l : Filter ι
⊢ TendstoUniformlyOn f 1 l s ↔ ∀ ε > 0, ∀ᶠ (i : ι) in l, ∀ x ∈ s, ‖f i x‖ < ε
state_after: no goals
Theorem: Equiv.existsUnique_congr'
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simp [h]
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (b : β), p (e.symm b) ↔ q b
⊢ (∃! b, p (e.symm b)) ↔ ∃! b, q b
state_after: no goals
Theorem: OrderHom.comp_id
File: Mathlib/Order/Hom/Basic.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α →o β
⊢ f.comp id = f
state_after: case h.h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α →o β
x✝ : α
⊢ (f.comp id) x✝ = f x✝

tactic: rfl
state_before: case h.h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α →o β
x✝ : α
⊢ (f.comp id) x✝ = f x✝
state_after: no goals
Theorem: CategoryTheory.Subgroupoid.coe_inv_coe'
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: simp only [← inv_eq_inv, coe_inv_coe]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d : ↑S.objs
p : c ⟶ d
⊢ ↑(inv p) = inv ↑p
state_after: no goals
Theorem: Ordinal.card_eq_one
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa using card_eq_nat (n := 1)
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
⊢ o.card = 1 ↔ o = 1
state_after: no goals
Theorem: Equiv.bijOn_swap
File: Mathlib/Data/Set/Function.lean

tactic: obtain rfl | hxa := eq_or_ne x a <;>
obtain rfl | hxb := eq_or_ne x b <;>
simp [*, swap_apply_of_ne_of_ne]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
e : α ≃ β
s : Set α
t : Set β
inst✝ : DecidableEq α
a b : α
ha : a ∈ s
hb : b ∈ s
x : α
⊢ (swap a b) x ∈ s ↔ x ∈ s
state_after: no goals
Theorem: Set.kernImage_empty
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [kernImage_eq_compl, compl_empty, image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
⊢ kernImage f ∅ = (range f)ᶜ
state_after: no goals