1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContinuousMap.adjoin_id_eq_span_one_union
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

tactic: ext x
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
𝕜 : Type u_2
inst✝ : RCLike 𝕜
s : Set 𝕜
⊢ ↑(StarAlgebra.adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)}) =
    ↑(span 𝕜 ({1} ∪ ↑(adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)})))
state_after: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
𝕜 : Type u_2
inst✝ : RCLike 𝕜
s : Set 𝕜
x : C(↑s, 𝕜)
⊢ x ∈ ↑(StarAlgebra.adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)}) ↔
    x ∈ ↑(span 𝕜 ({1} ∪ ↑(adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)})))

tactic: rw [SetLike.mem_coe, SetLike.mem_coe, ← StarAlgebra.adjoin_nonUnitalStarSubalgebra,
  ← StarSubalgebra.mem_toSubalgebra, ← Subalgebra.mem_toSubmodule,
  StarAlgebra.adjoin_nonUnitalStarSubalgebra_eq_span, span_union, span_eq_toSubmodule]
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
𝕜 : Type u_2
inst✝ : RCLike 𝕜
s : Set 𝕜
x : C(↑s, 𝕜)
⊢ x ∈ ↑(StarAlgebra.adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)}) ↔
    x ∈ ↑(span 𝕜 ({1} ∪ ↑(adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)})))
state_after: no goals
Theorem: Batteries.RBNode.balance2_All
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: unfold balance2
state_before: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p (l.balance2 v r) ↔ p v ∧ All p l ∧ All p r
state_after: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p
      (match l, v, r with
      | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
      | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b) ↔
    p v ∧ All p l ∧ All p r

tactic: split <;> simp [and_assoc, and_left_comm]
state_before: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p
      (match l, v, r with
      | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
      | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b) ↔
    p v ∧ All p l ∧ All p r
state_after: no goals
Theorem: Real.cauchy_inv
File: Mathlib/Data/Real/Basic.lean

tactic: rw [inv']
state_before: x y : ℝ
f : Cauchy abs
⊢ (Real.inv' { cauchy := f }).cauchy = { cauchy := f }.cauchy⁻¹
state_after: no goals
Theorem: Finset.antidiagonal.fst_le
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

tactic: rw [le_iff_exists_add]
state_before: A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ kl.1 ≤ n
state_after: A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ ∃ c, n = kl.1 + c

tactic: use kl.2
state_before: A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ ∃ c, n = kl.1 + c
state_after: case h
A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ n = kl.1 + kl.2

tactic: rwa [mem_antidiagonal, eq_comm] at hlk
state_before: case h
A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ n = kl.1 + kl.2
state_after: no goals
Theorem: CategoryTheory.Limits.inl_pushoutAssoc_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [Iso.comp_inv_eq, Category.assoc, inl_inl_pushoutAssoc_hom]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv = pushout.inl ≫ pushout.inl
state_after: no goals
Theorem: div_lt_div_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [lt_div_iff d0, div_mul_eq_mul_div, div_lt_iff b0]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
b0 : 0 < b
d0 : 0 < d
⊢ a / b < c / d ↔ a * d < c * b
state_after: no goals
Theorem: disjoint_sdiff_iff_le
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sup_sdiff_cancel_right hx]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y \ x ≤ x ⊔ y \ x
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y \ x ≤ y

tactic: refine le_trans (sup_le_sup_left sdiff_le z) ?_
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y \ x ≤ y
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y ≤ y

tactic: rw [sup_eq_right.2 hz]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y ≤ y
state_after: no goals
Theorem: DirectSum.IsInternal.isCompl
File: Mathlib/Algebra/DirectSum/Module.lean

tactic: rw [← sSup_pair, iSup, ← Set.image_univ, h, Set.image_insert_eq, Set.image_singleton]
state_before: R : Type u
inst✝² : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
A✝ A : ι → Submodule R M
i j : ι
hij : i ≠ j
h : Set.univ = {i, j}
hi : IsInternal A
⊢ iSup A = A i ⊔ A j
state_after: no goals
Theorem: Pi.induced_restrict
File: Mathlib/Topology/Constructions.lean

tactic: simp (config := { unfoldPartialApp := true }) [← iInf_subtype'', ← induced_precomp' ((↑) : S → ι),
  restrict]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
S : Set ι
⊢ induced S.restrict topologicalSpace = ⨅ i ∈ S, induced (eval i) (T i)
state_after: no goals
Theorem: IntermediateField.isSplittingField_iff
File: Mathlib/FieldTheory/Adjoin.lean

tactic: suffices _ → (Algebra.adjoin F (p.rootSet K) = ⊤ ↔ K = adjoin F (p.rootSet E)) by
  exact ⟨fun h ↦ ⟨h.1, (this h.1).mp h.2⟩, fun h ↦ ⟨h.1, (this h.1).mpr h.2⟩⟩
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
p : F[X]
K : IntermediateField F E
⊢ IsSplittingField F (↥K) p ↔ Splits (algebraMap F ↥K) p ∧ K = adjoin F (p.rootSet E)
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
p : F[X]
K : IntermediateField F E
⊢ Splits (algebraMap F ↥K) p → (Algebra.adjoin F (p.rootSet ↥K) = ⊤ ↔ K = adjoin F (p.rootSet E))

tactic: rw [← toSubalgebra_injective.eq_iff,
    adjoin_algebraic_toSubalgebra fun x ↦ isAlgebraic_of_mem_rootSet]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
p : F[X]
K : IntermediateField F E
⊢ Splits (algebraMap F ↥K) p → (Algebra.adjoin F (p.rootSet ↥K) = ⊤ ↔ K = adjoin F (p.rootSet E))
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
p : F[X]
K : IntermediateField F E
⊢ Splits (algebraMap F ↥K) p → (Algebra.adjoin F (p.rootSet ↥K) = ⊤ ↔ K.toSubalgebra = Algebra.adjoin F (p.rootSet E))

tactic: refine fun hp ↦ (adjoin_rootSet_eq_range hp K.val).symm.trans ?_
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
p : F[X]
K : IntermediateField F E
⊢ Splits (algebraMap F ↥K) p → (Algebra.adjoin F (p.rootSet ↥K) = ⊤ ↔ K.toSubalgebra = Algebra.adjoin F (p.rootSet E))
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
p : F[X]
K : IntermediateField F E
hp : Splits (algebraMap F ↥K) p
⊢ Algebra.adjoin F (p.rootSet E) = K.val.range ↔ K.toSubalgebra = Algebra.adjoin F (p.rootSet E)

tactic: rw [← K.range_val, eq_comm]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
p : F[X]
K : IntermediateField F E
hp : Splits (algebraMap F ↥K) p
⊢ Algebra.adjoin F (p.rootSet E) = K.val.range ↔ K.toSubalgebra = Algebra.adjoin F (p.rootSet E)
state_after: no goals

tactic: exact ⟨fun h ↦ ⟨h.1, (this h.1).mp h.2⟩, fun h ↦ ⟨h.1, (this h.1).mpr h.2⟩⟩
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
p : F[X]
K : IntermediateField F E
this : ?m.222109 → (Algebra.adjoin F (p.rootSet ↥K) = ⊤ ↔ K = adjoin F (p.rootSet E))
⊢ IsSplittingField F (↥K) p ↔ Splits (algebraMap F ↥K) p ∧ K = adjoin F (p.rootSet E)
state_after: no goals
Theorem: Complex.log_im
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp [log]
state_before: x : ℂ
⊢ (log x).im = x.arg
state_after: no goals
Theorem: AkraBazziRecurrence.isTheta_deriv_rpow_p_mul_one_sub_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: refine IsTheta.norm_left ?_
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (fun x => ‖deriv (fun z => z ^ p * (1 - ε z)) x‖) =Θ[atTop] fun z => z ^ (p - 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (deriv fun z => z ^ p * (1 - ε z)) =Θ[atTop] fun z => z ^ (p - 1)

tactic: calc (fun x => deriv (fun z => z ^ p * (1 - ε z)) x) =Θ[atTop] fun z => p * z ^ (p-1) :=
          (isEquivalent_deriv_rpow_p_mul_one_sub_smoothingFn hp).isTheta
  _ =Θ[atTop] fun z => z ^ (p-1) :=
          IsTheta.const_mul_left hp <| isTheta_refl _ _
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (deriv fun z => z ^ p * (1 - ε z)) =Θ[atTop] fun z => z ^ (p - 1)
state_after: no goals
Theorem: Real.abs_log_mul_self_lt
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: have : 0 < 1 / x := by simpa only [one_div, inv_pos] using h1
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
⊢ |log x * x| < 1
state_after: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : 0 < 1 / x
⊢ |log x * x| < 1

tactic: replace := log_le_sub_one_of_pos this
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : 0 < 1 / x
⊢ |log x * x| < 1
state_after: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : log (1 / x) ≤ 1 / x - 1
⊢ |log x * x| < 1

tactic: replace : log (1 / x) < 1 / x := by linarith
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : log (1 / x) ≤ 1 / x - 1
⊢ |log x * x| < 1
state_after: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : log (1 / x) < 1 / x
⊢ |log x * x| < 1

tactic: rw [log_div one_ne_zero h1.ne', log_one, zero_sub, lt_div_iff h1] at this
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : log (1 / x) < 1 / x
⊢ |log x * x| < 1
state_after: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ |log x * x| < 1

tactic: have aux : 0 ≤ -log x * x := by
  refine mul_nonneg ?_ h1.le
  rw [← log_inv]
  apply log_nonneg
  rw [← le_inv h1 zero_lt_one, inv_one]
  exact h2
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ |log x * x| < 1
state_after: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
aux : 0 ≤ -log x * x
⊢ |log x * x| < 1

tactic: rw [← abs_of_nonneg aux, neg_mul, abs_neg] at this
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
aux : 0 ≤ -log x * x
⊢ |log x * x| < 1
state_after: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : |log x * x| < 1
aux : 0 ≤ -log x * x
⊢ |log x * x| < 1

tactic: exact this
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : |log x * x| < 1
aux : 0 ≤ -log x * x
⊢ |log x * x| < 1
state_after: no goals

tactic: simpa only [one_div, inv_pos] using h1
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
⊢ 0 < 1 / x
state_after: no goals

tactic: linarith
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : log (1 / x) ≤ 1 / x - 1
⊢ log (1 / x) < 1 / x
state_after: no goals

tactic: refine mul_nonneg ?_ h1.le
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 0 ≤ -log x * x
state_after: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 0 ≤ -log x

tactic: rw [← log_inv]
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 0 ≤ -log x
state_after: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 0 ≤ log x⁻¹

tactic: apply log_nonneg
state_before: x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 0 ≤ log x⁻¹
state_after: case hx
x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 1 ≤ x⁻¹

tactic: rw [← le_inv h1 zero_lt_one, inv_one]
state_before: case hx
x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ 1 ≤ x⁻¹
state_after: case hx
x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ x ≤ 1

tactic: exact h2
state_before: case hx
x✝ y x : ℝ
h1 : 0 < x
h2 : x ≤ 1
this : -log x * x < 1
⊢ x ≤ 1
state_after: no goals
Theorem: Matrix.toMvPolynomial_map
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

tactic: simp only [toMvPolynomial, map_apply, map_sum, map_monomial]
state_before: m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
M : Matrix m n R
i : m
⊢ (M.map ⇑f).toMvPolynomial i = (MvPolynomial.map f) (M.toMvPolynomial i)
state_after: no goals
Theorem: DFinsupp.mk_zero
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp only [mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
i : ι
⊢ (mk s 0) i = 0 i
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
i : ι
⊢ (if H : i ∈ s then 0 ⟨i, H⟩ else 0) = 0 i

tactic: split_ifs <;> rfl
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
i : ι
⊢ (if H : i ∈ s then 0 ⟨i, H⟩ else 0) = 0 i
state_after: no goals
Theorem: Orientation.abs_volumeForm_apply_of_orthonormal
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: simpa [o.volumeForm_robust' v v] using congr_arg abs v.toBasis.det_self
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n : ℕ
_i : Fact (finrank ℝ E = n)
o : Orientation ℝ E (Fin n)
v : OrthonormalBasis (Fin n) ℝ E
⊢ |o.volumeForm ⇑v| = 1
state_after: no goals
Theorem: Set.image_congr
File: Mathlib/Data/Set/Image.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f g : α → β
s : Set α
h : ∀ a ∈ s, f a = g a
⊢ f '' s = g '' s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f g : α → β
s : Set α
h : ∀ a ∈ s, f a = g a
x : β
⊢ x ∈ f '' s ↔ x ∈ g '' s

tactic: exact exists_congr fun a ↦ and_congr_right fun ha ↦ by rw [h a ha]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f g : α → β
s : Set α
h : ∀ a ∈ s, f a = g a
x : β
⊢ x ∈ f '' s ↔ x ∈ g '' s
state_after: no goals

tactic: rw [h a ha]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f g : α → β
s : Set α
h : ∀ a ∈ s, f a = g a
x : β
a : α
ha : a ∈ s
⊢ f a = x ↔ g a = x
state_after: no goals
Theorem: CategoryTheory.Comma.eqToHom_right
File: Mathlib/CategoryTheory/Comma/Basic.lean

tactic: cases H
state_before: A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.18857, u_1} A'
inst✝¹ : Category.{?u.18861, u_2} B'
inst✝ : Category.{?u.18865, u_3} T'
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ X.right = Y.right
state_after: case refl
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.18857, u_1} A'
inst✝¹ : Category.{?u.18861, u_2} B'
inst✝ : Category.{?u.18865, u_3} T'
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ X.right = X.right

tactic: rfl
state_before: case refl
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.18857, u_1} A'
inst✝¹ : Category.{?u.18861, u_2} B'
inst✝ : Category.{?u.18865, u_3} T'
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ X.right = X.right
state_after: no goals

tactic: cases H
state_before: A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.18857, u_1} A'
inst✝¹ : Category.{?u.18861, u_2} B'
inst✝ : Category.{?u.18865, u_3} T'
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ (eqToHom H).right = eqToHom ⋯
state_after: case refl
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.18857, u_1} A'
inst✝¹ : Category.{?u.18861, u_2} B'
inst✝ : Category.{?u.18865, u_3} T'
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ (eqToHom ⋯).right = eqToHom ⋯

tactic: rfl
state_before: case refl
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.18857, u_1} A'
inst✝¹ : Category.{?u.18861, u_2} B'
inst✝ : Category.{?u.18865, u_3} T'
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ (eqToHom ⋯).right = eqToHom ⋯
state_after: no goals
Theorem: IsCompact.closure
File: Mathlib/Topology/Separation.lean

tactic: refine isCompact_of_finite_subcover fun U hUo hKU ↦ ?_
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
⊢ IsCompact (closure K)
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
ι✝ : Type u_1
U : ι✝ → Set X
hUo : ∀ (i : ι✝), IsOpen (U i)
hKU : closure K ⊆ ⋃ i, U i
⊢ ∃ t, closure K ⊆ ⋃ i ∈ t, U i

tactic: rcases hK.elim_finite_subcover U hUo (subset_closure.trans hKU) with ⟨t, ht⟩
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
ι✝ : Type u_1
U : ι✝ → Set X
hUo : ∀ (i : ι✝), IsOpen (U i)
hKU : closure K ⊆ ⋃ i, U i
⊢ ∃ t, closure K ⊆ ⋃ i ∈ t, U i
state_after: case intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
ι✝ : Type u_1
U : ι✝ → Set X
hUo : ∀ (i : ι✝), IsOpen (U i)
hKU : closure K ⊆ ⋃ i, U i
t : Finset ι✝
ht : K ⊆ ⋃ i ∈ t, U i
⊢ ∃ t, closure K ⊆ ⋃ i ∈ t, U i

tactic: exact ⟨t, hK.closure_subset_of_isOpen (isOpen_biUnion fun _ _ ↦ hUo _) ht⟩
state_before: case intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
ι✝ : Type u_1
U : ι✝ → Set X
hUo : ∀ (i : ι✝), IsOpen (U i)
hKU : closure K ⊆ ⋃ i, U i
t : Finset ι✝
ht : K ⊆ ⋃ i ∈ t, U i
⊢ ∃ t, closure K ⊆ ⋃ i ∈ t, U i
state_after: no goals
Theorem: IsAdjoinRootMonic.coeff_apply_lt
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: simp only [coeff, LinearMap.comp_apply, Finsupp.lcoeFun_apply, Finsupp.lmapDomain_apply,
  LinearEquiv.coe_coe, liftPolyₗ_apply, LinearMap.coe_mk, h.basis_repr]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : i < f.natDegree
⊢ h.coeff z i = (h.basis.repr z) ⟨i, hi⟩
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : i < f.natDegree
⊢ { toFun := Polynomial.coeff, map_add' := ⋯ } (h.modByMonicHom z) i = (h.modByMonicHom z).coeff i

tactic: rfl
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : i < f.natDegree
⊢ { toFun := Polynomial.coeff, map_add' := ⋯ } (h.modByMonicHom z) i = (h.modByMonicHom z).coeff i
state_after: no goals
Theorem: Polynomial.natSepDegree_zero
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: rw [← C_0, natSepDegree_C]
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 : F[X]
⊢ natSepDegree 0 = 0
state_after: no goals
Theorem: eq_iff_not_lt_of_le
File: Mathlib/Order/Basic.lean

tactic: rw [lt_iff_le_and_ne, not_and, Classical.not_not, eq_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : PartialOrder α
x y : α
⊢ x ≤ y → y = x ↔ ¬x < y
state_after: no goals
Theorem: Complex.re_eq_add_conj
File: Mathlib/Data/Complex/Basic.lean

tactic: simp only [add_conj, ofReal_mul, ofReal_ofNat, mul_div_cancel_left₀ (z.re : ℂ) two_ne_zero]
state_before: z : ℂ
⊢ ↑z.re = (z + (starRingEnd ℂ) z) / 2
state_after: no goals