1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.HasBasis.compactConvergenceUniformity
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: rw [← uniformEmbedding_toUniformOnFunIsCompact.comap_uniformity]
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u_1
pi : ι → Prop
s : ι → Set (β × β)
h : (𝓤 β).HasBasis pi s
⊢ (𝓤 C(α, β)).HasBasis (fun p => IsCompact p.1 ∧ pi p.2) fun p => {fg | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ s p.2}
state_after: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u_1
pi : ι → Prop
s : ι → Set (β × β)
h : (𝓤 β).HasBasis pi s
⊢ (Filter.comap (fun x => (x.1.toUniformOnFunIsCompact, x.2.toUniformOnFunIsCompact))
        (𝓤 (α →ᵤ[{K | IsCompact K}] β))).HasBasis
    (fun p => IsCompact p.1 ∧ pi p.2) fun p => {fg | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ s p.2}

tactic: exact .comap _ <| UniformOnFun.hasBasis_uniformity_of_basis _ _ {K | IsCompact K}
  ⟨∅, isCompact_empty⟩ (directedOn_of_sup_mem fun _ _ ↦ IsCompact.union) h
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u_1
pi : ι → Prop
s : ι → Set (β × β)
h : (𝓤 β).HasBasis pi s
⊢ (Filter.comap (fun x => (x.1.toUniformOnFunIsCompact, x.2.toUniformOnFunIsCompact))
        (𝓤 (α →ᵤ[{K | IsCompact K}] β))).HasBasis
    (fun p => IsCompact p.1 ∧ pi p.2) fun p => {fg | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ s p.2}
state_after: no goals
Theorem: imageToKernel_comp_hom_inv_comp
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: simpa using w
state_before: ι : Type u_1
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasEqualizers V
inst✝ : HasImages V
Z : V
i : B ≅ Z
w : (f ≫ i.hom) ≫ i.inv ≫ g = 0
⊢ f ≫ g = 0
state_after: no goals

tactic: ext
state_before: ι : Type u_1
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasEqualizers V
inst✝ : HasImages V
Z : V
i : B ≅ Z
w : (f ≫ i.hom) ≫ i.inv ≫ g = 0
⊢ imageToKernel (f ≫ i.hom) (i.inv ≫ g) w =
    (imageSubobjectCompIso f i.hom).hom ≫ imageToKernel f g ⋯ ≫ (kernelSubobjectIsoComp i.inv g).inv
state_after: case h
ι : Type u_1
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasEqualizers V
inst✝ : HasImages V
Z : V
i : B ≅ Z
w : (f ≫ i.hom) ≫ i.inv ≫ g = 0
⊢ imageToKernel (f ≫ i.hom) (i.inv ≫ g) w ≫ (kernelSubobject (i.inv ≫ g)).arrow =
    ((imageSubobjectCompIso f i.hom).hom ≫ imageToKernel f g ⋯ ≫ (kernelSubobjectIsoComp i.inv g).inv) ≫
      (kernelSubobject (i.inv ≫ g)).arrow

tactic: simp
state_before: case h
ι : Type u_1
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasEqualizers V
inst✝ : HasImages V
Z : V
i : B ≅ Z
w : (f ≫ i.hom) ≫ i.inv ≫ g = 0
⊢ imageToKernel (f ≫ i.hom) (i.inv ≫ g) w ≫ (kernelSubobject (i.inv ≫ g)).arrow =
    ((imageSubobjectCompIso f i.hom).hom ≫ imageToKernel f g ⋯ ≫ (kernelSubobjectIsoComp i.inv g).inv) ≫
      (kernelSubobject (i.inv ≫ g)).arrow
state_after: no goals
Theorem: CategoryTheory.Iso.commRingIsoToRingEquiv_symm_toRingHom
File: Mathlib/Algebra/Category/Ring/Basic.lean

tactic: ext
state_before: X Y : CommRingCat
i : X ≅ Y
⊢ i.commRingCatIsoToRingEquiv.symm.toRingHom = i.inv
state_after: case a
X Y : CommRingCat
i : X ≅ Y
x✝ : ↑Y
⊢ i.commRingCatIsoToRingEquiv.symm.toRingHom x✝ = i.inv x✝

tactic: rfl
state_before: case a
X Y : CommRingCat
i : X ≅ Y
x✝ : ↑Y
⊢ i.commRingCatIsoToRingEquiv.symm.toRingHom x✝ = i.inv x✝
state_after: no goals
Theorem: QuasiconvexOn.convex_lt
File: Mathlib/Analysis/Convex/Quasiconvex.lean

tactic: refine fun x hx y hy a b ha hb hab => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrder β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
hf : QuasiconvexOn 𝕜 s f
r : β
⊢ Convex 𝕜 {x | x ∈ s ∧ f x < r}
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrder β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
hf : QuasiconvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ {x | x ∈ s ∧ f x < r}

tactic: have h := hf _ ⟨hx.1, le_max_left _ _⟩ ⟨hy.1, le_max_right _ _⟩ ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrder β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
hf : QuasiconvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ {x | x ∈ s ∧ f x < r}
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrder β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
hf : QuasiconvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
h : a • x + b • y ∈ {x_1 | x_1 ∈ s ∧ f x_1 ≤ max (f x) (f y)}
⊢ a • x + b • y ∈ {x | x ∈ s ∧ f x < r}

tactic: exact ⟨h.1, h.2.trans_lt <| max_lt hx.2 hy.2⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrder β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
hf : QuasiconvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
h : a • x + b • y ∈ {x_1 | x_1 ∈ s ∧ f x_1 ≤ max (f x) (f y)}
⊢ a • x + b • y ∈ {x | x ∈ s ∧ f x < r}
state_after: no goals
Theorem: Finset.filter_le_lt_eq_Ico
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: ext
state_before: ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j < b
⊢ filter (fun j => a ≤ j ∧ j < b) univ = Ico a b
state_after: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j < b
a✝ : α
⊢ a✝ ∈ filter (fun j => a ≤ j ∧ j < b) univ ↔ a✝ ∈ Ico a b

tactic: simp
state_before: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j < b
a✝ : α
⊢ a✝ ∈ filter (fun j => a ≤ j ∧ j < b) univ ↔ a✝ ∈ Ico a b
state_after: no goals
Theorem: Quiver.hom_cast_eq_of_cons_eq_cons
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [Hom.cast_eq_iff_heq]
state_before: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : p.cons e = p'.cons e'
⊢ Hom.cast ⋯ ⋯ e = e'
state_after: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : p.cons e = p'.cons e'
⊢ HEq e e'

tactic: exact hom_heq_of_cons_eq_cons h
state_before: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : p.cons e = p'.cons e'
⊢ HEq e e'
state_after: no goals
Theorem: Num.ppred_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [ppred, Option.map_some, Nat.ppred_eq_some.2]
state_before: α : Type u_1
p : PosNum
⊢ castNum <$> (pos p).ppred = (↑(pos p)).ppred
state_after: α : Type u_1
p : PosNum
⊢ (↑p.pred').succ = ↑(pos p)

tactic: rw [PosNum.pred'_to_nat, Nat.succ_pred_eq_of_pos (PosNum.to_nat_pos _)]
state_before: α : Type u_1
p : PosNum
⊢ (↑p.pred').succ = ↑(pos p)
state_after: α : Type u_1
p : PosNum
⊢ ↑p = ↑(pos p)

tactic: rfl
state_before: α : Type u_1
p : PosNum
⊢ ↑p = ↑(pos p)
state_after: no goals
Theorem: Polynomial.splits_prod_iff
File: Mathlib/Algebra/Polynomial/Splits.lean

tactic: classical
refine
  Finset.induction_on t (fun _ =>
      ⟨fun _ _ h => by simp only [Finset.not_mem_empty] at h, fun _ => splits_one i⟩)
    fun a t hat ih ht => ?_
rw [Finset.forall_mem_insert] at ht ⊢
rw [Finset.prod_insert hat, splits_mul_iff i ht.1 (Finset.prod_ne_zero_iff.2 ht.2), ih ht.2]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t : Finset ι
⊢ (∀ j ∈ t, s j ≠ 0) → (Splits i (∏ x ∈ t, s x) ↔ ∀ j ∈ t, Splits i (s j))
state_after: no goals

tactic: refine
  Finset.induction_on t (fun _ =>
      ⟨fun _ _ h => by simp only [Finset.not_mem_empty] at h, fun _ => splits_one i⟩)
    fun a t hat ih ht => ?_
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t : Finset ι
⊢ (∀ j ∈ t, s j ≠ 0) → (Splits i (∏ x ∈ t, s x) ↔ ∀ j ∈ t, Splits i (s j))
state_after: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : a ∉ t
ih : (∀ j ∈ t, s j ≠ 0) → (Splits i (∏ x ∈ t, s x) ↔ ∀ j ∈ t, Splits i (s j))
ht : ∀ j ∈ insert a t, s j ≠ 0
⊢ Splits i (∏ x ∈ insert a t, s x) ↔ ∀ j ∈ insert a t, Splits i (s j)

tactic: rw [Finset.forall_mem_insert] at ht ⊢
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : a ∉ t
ih : (∀ j ∈ t, s j ≠ 0) → (Splits i (∏ x ∈ t, s x) ↔ ∀ j ∈ t, Splits i (s j))
ht : ∀ j ∈ insert a t, s j ≠ 0
⊢ Splits i (∏ x ∈ insert a t, s x) ↔ ∀ j ∈ insert a t, Splits i (s j)
state_after: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : a ∉ t
ih : (∀ j ∈ t, s j ≠ 0) → (Splits i (∏ x ∈ t, s x) ↔ ∀ j ∈ t, Splits i (s j))
ht : s a ≠ 0 ∧ ∀ x ∈ t, s x ≠ 0
⊢ Splits i (∏ x ∈ insert a t, s x) ↔ Splits i (s a) ∧ ∀ x ∈ t, Splits i (s x)

tactic: rw [Finset.prod_insert hat, splits_mul_iff i ht.1 (Finset.prod_ne_zero_iff.2 ht.2), ih ht.2]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : a ∉ t
ih : (∀ j ∈ t, s j ≠ 0) → (Splits i (∏ x ∈ t, s x) ↔ ∀ j ∈ t, Splits i (s j))
ht : s a ≠ 0 ∧ ∀ x ∈ t, s x ≠ 0
⊢ Splits i (∏ x ∈ insert a t, s x) ↔ Splits i (s a) ∧ ∀ x ∈ t, Splits i (s x)
state_after: no goals

tactic: simp only [Finset.not_mem_empty] at h
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t : Finset ι
x✝² : ∀ j ∈ ∅, s j ≠ 0
x✝¹ : Splits i (∏ x ∈ ∅, s x)
x✝ : ι
h : x✝ ∈ ∅
⊢ Splits i (s x✝)
state_after: no goals
Theorem: Nat.sub_lt_iff_lt_add
File: Mathlib/Data/Nat/Defs.lean

tactic: omega
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hba : b ≤ a
⊢ a - b < c ↔ a < b + c
state_after: no goals
Theorem: norm_mk_zero
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: erw [quotient_norm_eq_zero_iff]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
⊢ ‖0‖ = 0
state_after: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
⊢ 0 ∈ closure ↑S

tactic: exact subset_closure S.zero_mem
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
⊢ 0 ∈ closure ↑S
state_after: no goals
Theorem: CategoryTheory.Adjunction.homEquiv_apply_eq
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: cases h
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : (adj.homEquiv A B) f = g
⊢ f = (adj.homEquiv A B).symm g
state_after: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
⊢ f = (adj.homEquiv A B).symm ((adj.homEquiv A B) f)

tactic: simp
state_before: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
⊢ f = (adj.homEquiv A B).symm ((adj.homEquiv A B) f)
state_after: no goals

tactic: cases h
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : f = (adj.homEquiv A B).symm g
⊢ (adj.homEquiv A B) f = g
state_after: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
g : A ⟶ G.obj B
⊢ (adj.homEquiv A B) ((adj.homEquiv A B).symm g) = g

tactic: simp
state_before: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
g : A ⟶ G.obj B
⊢ (adj.homEquiv A B) ((adj.homEquiv A B).symm g) = g
state_after: no goals
Theorem: Metric.tendsto_nhdsWithin_nhdsWithin
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: simp only [inter_comm _ s, inter_comm _ t, mem_inter_iff, and_imp, gt_iff_lt, mem_ball]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
inst✝ : PseudoMetricSpace β
t : Set β
f : α → β
a : α
b : β
⊢ (∀ (ib : ℝ), 0 < ib → ∃ ia, 0 < ia ∧ ∀ x ∈ ball a ia ∩ s, f x ∈ ball b ib ∩ t) ↔
    ∀ ε > 0, ∃ δ > 0, ∀ {x : α}, x ∈ s → dist x a < δ → f x ∈ t ∧ dist (f x) b < ε
state_after: no goals
Theorem: Finset.disjoint_of_erase_left
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← erase_insert ha, ← disjoint_erase_comm, disjoint_insert_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ t
hst : _root_.Disjoint (s.erase a) t
⊢ _root_.Disjoint s t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ t
hst : _root_.Disjoint (s.erase a) t
⊢ a ∉ s.erase a ∧ _root_.Disjoint (s.erase a) t

tactic: exact ⟨not_mem_erase _ _, hst⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ t
hst : _root_.Disjoint (s.erase a) t
⊢ a ∉ s.erase a ∧ _root_.Disjoint (s.erase a) t
state_after: no goals
Theorem: Polynomial.natTrailingDegree_eq_zero
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

tactic: simp [natTrailingDegree, or_comm]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.natTrailingDegree = 0 ↔ p = 0 ∨ p.coeff 0 ≠ 0
state_after: no goals
Theorem: FreeLieAlgebra.liftAux_spec
File: Mathlib/Algebra/Lie/Free.lean

tactic: induction h with
| lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
| leibniz_lie a' b' c' =>
  simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
| smul b' _ h₂ => simp only [liftAux_map_smul, h₂]
| add_right c' _ h₂ => simp only [liftAux_map_add, h₂]
| mul_left c' _ h₂ => simp only [liftAux_map_mul, h₂]
| mul_right c' _ h₂ => simp only [liftAux_map_mul, h₂]
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b : lib R X
h : Rel R X a b
⊢ (liftAux R f) a = (liftAux R f) b
state_after: no goals

tactic: simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
state_before: case lie_self
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' : lib R X
⊢ (liftAux R f) (a' * a') = (liftAux R f) 0
state_after: no goals

tactic: simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
state_before: case leibniz_lie
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
⊢ (liftAux R f) (a' * (b' * c')) = (liftAux R f) (a' * b' * c' + b' * (a' * c'))
state_after: no goals

tactic: simp only [liftAux_map_smul, h₂]
state_before: case smul
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b : lib R X
b' : R
a✝¹ b✝ : lib R X
a✝ : Rel R X a✝¹ b✝
h₂ : (liftAux R f) a✝¹ = (liftAux R f) b✝
⊢ (liftAux R f) (b' • a✝¹) = (liftAux R f) (b' • b✝)
state_after: no goals

tactic: simp only [liftAux_map_add, h₂]
state_before: case add_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c' : lib R X
a✝ : Rel R X a✝¹ b✝
h₂ : (liftAux R f) a✝¹ = (liftAux R f) b✝
⊢ (liftAux R f) (a✝¹ + c') = (liftAux R f) (b✝ + c')
state_after: no goals

tactic: simp only [liftAux_map_mul, h₂]
state_before: case mul_left
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b c' b✝ c✝ : lib R X
a✝ : Rel R X b✝ c✝
h₂ : (liftAux R f) b✝ = (liftAux R f) c✝
⊢ (liftAux R f) (c' * b✝) = (liftAux R f) (c' * c✝)
state_after: no goals

tactic: simp only [liftAux_map_mul, h₂]
state_before: case mul_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c' : lib R X
a✝ : Rel R X a✝¹ b✝
h₂ : (liftAux R f) a✝¹ = (liftAux R f) b✝
⊢ (liftAux R f) (a✝¹ * c') = (liftAux R f) (b✝ * c')
state_after: no goals
Theorem: tprod_extend_one
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: have : mulSupport (extend g f 1) ⊆ Set.range g := mulSupport_subset_iff'.2 <| extend_apply' _ _
state_before: α : Type u_1
β : Type u_2
γ✝ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g✝ : β → α
a a₁ a₂ : α
γ : Type u_5
g : γ → β
hg : Injective g
f : γ → α
⊢ ∏' (y : β), extend g f 1 y = ∏' (x : γ), f x
state_after: α : Type u_1
β : Type u_2
γ✝ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g✝ : β → α
a a₁ a₂ : α
γ : Type u_5
g : γ → β
hg : Injective g
f : γ → α
this : mulSupport (extend g f 1) ⊆ Set.range g
⊢ ∏' (y : β), extend g f 1 y = ∏' (x : γ), f x

tactic: simp_rw [← hg.tprod_eq this, hg.extend_apply]
state_before: α : Type u_1
β : Type u_2
γ✝ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g✝ : β → α
a a₁ a₂ : α
γ : Type u_5
g : γ → β
hg : Injective g
f : γ → α
this : mulSupport (extend g f 1) ⊆ Set.range g
⊢ ∏' (y : β), extend g f 1 y = ∏' (x : γ), f x
state_after: no goals
Theorem: Set.finite_prod
File: Mathlib/Data/Set/Finite.lean

tactic: simp only [← not_infinite, Set.infinite_prod, not_or, not_and_or, not_nonempty_iff_eq_empty]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
⊢ (s ×ˢ t).Finite ↔ (s.Finite ∨ t = ∅) ∧ (t.Finite ∨ s = ∅)
state_after: no goals
Theorem: MeasureTheory.Measure.quasiMeasurePreserving_snd
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: refine ⟨measurable_snd, AbsolutelyContinuous.mk fun s hs h2s => ?_⟩
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
⊢ QuasiMeasurePreserving Prod.snd (μ.prod ν) ν
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
s : Set β
hs : MeasurableSet s
h2s : ν s = 0
⊢ (map Prod.snd (μ.prod ν)) s = 0

tactic: rw [map_apply measurable_snd hs, ← univ_prod, prod_prod, h2s, mul_zero]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
s : Set β
hs : MeasurableSet s
h2s : ν s = 0
⊢ (map Prod.snd (μ.prod ν)) s = 0
state_after: no goals
Theorem: Polynomial.eval₂_evalRingHom
File: Mathlib/Algebra/Polynomial/Bivariate.lean

tactic: ext1
state_before: R : Type u_1
S : Type u_2
inst✝ : CommSemiring R
x : R
⊢ eval₂ (evalRingHom x) = evalEval x
state_after: case h
R : Type u_1
S : Type u_2
inst✝ : CommSemiring R
x x✝ : R
⊢ eval₂ (evalRingHom x) x✝ = evalEval x x✝

tactic: rw [← coe_evalEvalRingHom, evalEvalRingHom_eq, coe_eval₂RingHom]
state_before: case h
R : Type u_1
S : Type u_2
inst✝ : CommSemiring R
x x✝ : R
⊢ eval₂ (evalRingHom x) x✝ = evalEval x x✝
state_after: no goals
Theorem: Polynomial.natSepDegree_mul
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: by_cases h : f * g = 0
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f g : F[X]
⊢ (f * g).natSepDegree ≤ f.natSepDegree + g.natSepDegree
state_after: case pos
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f g : F[X]
h : f * g = 0
⊢ (f * g).natSepDegree ≤ f.natSepDegree + g.natSepDegree

case neg
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f g : F[X]
h : ¬f * g = 0
⊢ (f * g).natSepDegree ≤ f.natSepDegree + g.natSepDegree

tactic: simp_rw [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F), aroots_mul h, Multiset.toFinset_add]
state_before: case neg
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f g : F[X]
h : ¬f * g = 0
⊢ (f * g).natSepDegree ≤ f.natSepDegree + g.natSepDegree
state_after: case neg
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f g : F[X]
h : ¬f * g = 0
⊢ ((f.aroots (AlgebraicClosure F)).toFinset ∪ (g.aroots (AlgebraicClosure F)).toFinset).card ≤
    (f.aroots (AlgebraicClosure F)).toFinset.card + (g.aroots (AlgebraicClosure F)).toFinset.card

tactic: exact Finset.card_union_le _ _
state_before: case neg
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f g : F[X]
h : ¬f * g = 0
⊢ ((f.aroots (AlgebraicClosure F)).toFinset ∪ (g.aroots (AlgebraicClosure F)).toFinset).card ≤
    (f.aroots (AlgebraicClosure F)).toFinset.card + (g.aroots (AlgebraicClosure F)).toFinset.card
state_after: no goals

tactic: simp only [h, natSepDegree_zero, zero_le]
state_before: case pos
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f g : F[X]
h : f * g = 0
⊢ (f * g).natSepDegree ≤ f.natSepDegree + g.natSepDegree
state_after: no goals
Theorem: iInf₂_eq_top
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : (i : ι) → κ i → α
⊢ ⨅ i, ⨅ j, f i j = ⊤ ↔ ∀ (i : ι) (j : κ i), f i j = ⊤
state_after: no goals
Theorem: CategoryTheory.Adjunction.leftAdjointUniq_trans
File: Mathlib/CategoryTheory/Adjunction/Unique.lean

tactic: simp [leftAdjointUniq]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
⊢ (adj1.leftAdjointUniq adj2).hom ≫ (adj2.leftAdjointUniq adj3).hom = (adj1.leftAdjointUniq adj3).hom
state_after: no goals