tasksource/leandojo huggingface dataset:
Theorem: Set.Nontrivial.infsep_exists_of_finite
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: classical
  cases nonempty_fintype s
  simp_rw [hs.infsep_of_fintype]
  rcases@Finset.exists_mem_eq_inf' _ _ _ s.offDiag.toFinset (by simpa) (uncurry dist) with
    ⟨w, hxy, hed⟩
  simp_rw [mem_toFinset] at hxy
  exact ⟨w.fst, hxy.1, w.snd, hxy.2.1, hxy.2.2, hed⟩
state_before: α : Type u_1
β : Type ?u.77742
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Finite ↑s
hs : Set.Nontrivial s
⊢ ∃ x x_1 y x_2 _hxy, infsep s = dist x y

tactic: cases nonempty_fintype s
state_before: α : Type u_1
β : Type ?u.77742
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Finite ↑s
hs : Set.Nontrivial s
⊢ ∃ x x_1 y x_2 _hxy, infsep s = dist x y

tactic: simp_rw [hs.infsep_of_fintype]
state_before: case intro
α : Type u_1
β : Type ?u.77742
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Finite ↑s
hs : Set.Nontrivial s
val✝ : Fintype ↑s
⊢ ∃ x x_1 y x_2 _hxy, infsep s = dist x y

tactic: rcases@Finset.exists_mem_eq_inf' _ _ _ s.offDiag.toFinset (by simpa) (uncurry dist) with
  ⟨w, hxy, hed⟩
state_before: case intro
α : Type u_1
β : Type ?u.77742
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Finite ↑s
hs : Set.Nontrivial s
val✝ : Fintype ↑s
⊢ ∃ x h y h h, Finset.inf' (toFinset (offDiag s)) (_ : Finset.Nonempty (toFinset (offDiag s))) (uncurry dist) = dist x y

tactic: simp_rw [mem_toFinset] at hxy
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.77742
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Finite ↑s
hs : Set.Nontrivial s
val✝ : Fintype ↑s
w : α × α
hxy : w ∈ toFinset (offDiag s)
hed : Finset.inf' (toFinset (offDiag s)) ?m.80020 (uncurry dist) = uncurry dist w
⊢ ∃ x h y h h, Finset.inf' (toFinset (offDiag s)) (_ : Finset.Nonempty (toFinset (offDiag s))) (uncurry dist) = dist x y

tactic: exact ⟨w.fst, hxy.1, w.snd, hxy.2.1, hxy.2.2, hed⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.77742
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Finite ↑s
hs : Set.Nontrivial s
val✝ : Fintype ↑s
w : α × α
hed : Finset.inf' (toFinset (offDiag s)) ?m.80020 (uncurry dist) = uncurry dist w
hxy : w ∈ offDiag s
⊢ ∃ x h y h h, Finset.inf' (toFinset (offDiag s)) (_ : Finset.Nonempty (toFinset (offDiag s))) (uncurry dist) = dist x y

tactic: simpa
state_before: α : Type u_1
β : Type ?u.77742
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Finite ↑s
hs : Set.Nontrivial s
val✝ : Fintype ↑s
⊢ Finset.Nonempty (toFinset (offDiag s))
Theorem: posMulStrictMono_iff_mulPosStrictMono
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simp only [PosMulStrictMono, MulPosStrictMono, mul_comm]
state_before: α : Type u_1
a b c d : α
inst✝² : CommSemigroup α
inst✝¹ : Zero α
inst✝ : Preorder α
⊢ PosMulStrictMono α ↔ MulPosStrictMono α
Theorem: DenseRange.comp
File: Mathlib/Topology/Basic.lean

tactic: rw [DenseRange, range_comp]
state_before: α : Type ?u.176030
β : Type u_2
γ : Type u_1
δ : Type ?u.176039
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
κ : Type u_3
ι : Type ?u.176054
f✝ : κ → β
g✝ g : β → γ
f : κ → β
hg : DenseRange g
hf : DenseRange f
cg : Continuous g
⊢ DenseRange (g ∘ f)

tactic: exact hg.dense_image cg hf
state_before: α : Type ?u.176030
β : Type u_2
γ : Type u_1
δ : Type ?u.176039
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
κ : Type u_3
ι : Type ?u.176054
f✝ : κ → β
g✝ g : β → γ
f : κ → β
hg : DenseRange g
hf : DenseRange f
cg : Continuous g
⊢ Dense (g '' range f)
Theorem: LieSubmodule.lie_abelian_iff_lie_self_eq_bot
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: simp only [_root_.eq_bot_iff, lieIdeal_oper_eq_span, LieSubmodule.lieSpan_le,
  LieSubmodule.bot_coe, Set.subset_singleton_iff, Set.mem_setOf_eq, exists_imp]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsLieAbelian { x // x ∈ ↑I } ↔ ⁅I, I⁆ = ⊥

tactic: refine'
  ⟨fun h z x y hz =>
    hz.symm.trans
      (((I : LieSubalgebra R L).coe_bracket x y).symm.trans
        ((coe_zero_iff_zero _ _).mpr (by apply h.trivial))),
    fun h => ⟨fun x y => ((I : LieSubalgebra R L).coe_zero_iff_zero _).mp (h _ x y rfl)⟩⟩
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsLieAbelian { x // x ∈ ↑I } ↔ ∀ (y : L) (x : { x // x ∈ I }) (x_1 : { x // x ∈ I }), ⁅↑x, ↑x_1⁆ = y → y = 0

tactic: apply h.trivial
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
h : IsLieAbelian { x // x ∈ ↑I }
z : L
x : { x // x ∈ I }
y : { x // x ∈ I }
hz : ⁅↑x, ↑y⁆ = z
⊢ ⁅x, y⁆ = 0
Theorem: Complex.map_isometryOfOrthonormal
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simp [Complex.isometryOfOrthonormal, LinearIsometryEquiv.trans_assoc, OrthonormalBasis.map]
state_before: ι : Type ?u.1334907
ι' : Type ?u.1334910
𝕜 : Type ?u.1334913
inst✝⁹ : IsROrC 𝕜
E : Type ?u.1334919
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.1334939
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_1
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_2
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : OrthonormalBasis (Fin 2) ℝ F
f : F ≃ₗᵢ[ℝ] F'
⊢ isometryOfOrthonormal (OrthonormalBasis.map v f) = LinearIsometryEquiv.trans (isometryOfOrthonormal v) f

tactic: rw [LinearIsometryEquiv.trans_assoc]
state_before: ι : Type ?u.1334907
ι' : Type ?u.1334910
𝕜 : Type ?u.1334913
inst✝⁹ : IsROrC 𝕜
E : Type ?u.1334919
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.1334939
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_1
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_2
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : OrthonormalBasis (Fin 2) ℝ F
f : F ≃ₗᵢ[ℝ] F'
⊢ LinearIsometryEquiv.trans orthonormalBasisOneI.repr (LinearIsometryEquiv.trans (LinearIsometryEquiv.symm v.repr) f) =
    LinearIsometryEquiv.trans (LinearIsometryEquiv.trans orthonormalBasisOneI.repr (LinearIsometryEquiv.symm v.repr)) f
Theorem: UpperSet.coe_eq_univ
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [SetLike.ext'_iff]
state_before: α : Type u_1
β : Type ?u.45708
γ : Type ?u.45711
ι : Sort ?u.45714
κ : ι → Sort ?u.45719
inst✝ : LE α
S : Set (UpperSet α)
s t : UpperSet α
a : α
⊢ ↑s = univ ↔ s = ⊥
Theorem: HasDerivWithinAt.inv
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

tactic: convert (hasDerivAt_inv hx).comp_hasDerivWithinAt x hc using 1
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
c : 𝕜 → 𝕜
h : E → 𝕜
c' : 𝕜
z : E
S : Set E
hc : HasDerivWithinAt c c' s x
hx : c x ≠ 0
⊢ HasDerivWithinAt (fun y => (c y)⁻¹) (-c' / c x ^ 2) s x

tactic: field_simp
state_before: case h.e'_7
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
c : 𝕜 → 𝕜
h : E → 𝕜
c' : 𝕜
z : E
S : Set E
hc : HasDerivWithinAt c c' s x
hx : c x ≠ 0
⊢ -c' / c x ^ 2 = -(c x ^ 2)⁻¹ * c'
Theorem: mul_lt_mul''
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: classical
exact Decidable.mul_lt_mul''
state_before: α : Type u
β : Type ?u.60876
inst✝ : StrictOrderedSemiring α
a b c d : α
⊢ a < c → b < d → 0 ≤ a → 0 ≤ b → a * b < c * d

tactic: exact Decidable.mul_lt_mul''
state_before: α : Type u
β : Type ?u.60876
inst✝ : StrictOrderedSemiring α
a b c d : α
⊢ a < c → b < d → 0 ≤ a → 0 ≤ b → a * b < c * d
Theorem: IsLocallyConstant.desc
File: Mathlib/Topology/LocallyConstant/Basic.lean

tactic: rw [← preimage_image_eq s inj, preimage_preimage]
state_before: X : Type u_3
Y : Type ?u.7897
Z : Type ?u.7900
α✝ : Type ?u.7903
inst✝ : TopologicalSpace X
α : Type u_1
β : Type u_2
f : X → α
g : α → β
h : IsLocallyConstant (g ∘ f)
inj : Function.Injective g
s : Set α
⊢ IsOpen (f ⁻¹' s)

tactic: exact h (g '' s)
state_before: X : Type u_3
Y : Type ?u.7897
Z : Type ?u.7900
α✝ : Type ?u.7903
inst✝ : TopologicalSpace X
α : Type u_1
β : Type u_2
f : X → α
g : α → β
h : IsLocallyConstant (g ∘ f)
inj : Function.Injective g
s : Set α
⊢ IsOpen ((fun x => g (f x)) ⁻¹' (g '' s))
Theorem: Order.Ioo_pred_left_of_not_isMin
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [← Ioi_inter_Iio, Ioi_pred_of_not_isMin ha, Ici_inter_Iio]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin a
⊢ Ioo (pred a) b = Ico a b
Theorem: List.append_nil
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as with
| nil => rfl
| cons a as ih =>
  simp_all [HAppend.hAppend, Append.append, List.append]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
⊢ as ++ nil = as

tactic: rfl
state_before: case nil
α : Type u
β : Type v
γ : Type w
⊢ nil ++ nil = nil

tactic: simp_all [HAppend.hAppend, Append.append, List.append]
state_before: case cons
α : Type u
β : Type v
γ : Type w
a : α
as : List α
ih : as ++ nil = as
⊢ a :: as ++ nil = a :: as
Theorem: Equiv.Perm.toList_one
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: simp [toList, cycleOf_one]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
⊢ toList 1 x = []
Theorem: List.le_antisymm
File: src/lean/Init/Data/List/BasicAux.lean

tactic: by_cases hab : a < b
state_before: α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁ : a :: as ≤ b :: bs
h₂ : b :: bs ≤ a :: as
⊢ a :: as = b :: bs

tactic: exact False.elim <| h₂ (List.lt.head _ _ hab)
state_before: case inl
α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁ : a :: as ≤ b :: bs
h₂ : b :: bs ≤ a :: as
hab : a < b
⊢ a :: as = b :: bs

tactic: by_cases hba : b < a
state_before: case inr
α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁ : a :: as ≤ b :: bs
h₂ : b :: bs ≤ a :: as
hab : ¬a < b
⊢ a :: as = b :: bs

tactic: exact False.elim <| h₁ (List.lt.head _ _ hba)
state_before: case inr.inl
α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁ : a :: as ≤ b :: bs
h₂ : b :: bs ≤ a :: as
hab : ¬a < b
hba : b < a
⊢ a :: as = b :: bs

tactic: have h₁ : as ≤ bs := fun h => h₁ (List.lt.tail hba hab h)
state_before: case inr.inr
α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁ : a :: as ≤ b :: bs
h₂ : b :: bs ≤ a :: as
hab : ¬a < b
hba : ¬b < a
⊢ a :: as = b :: bs

tactic: have h₂ : bs ≤ as := fun h => h₂ (List.lt.tail hab hba h)
state_before: case inr.inr
α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁✝ : a :: as ≤ b :: bs
h₂ : b :: bs ≤ a :: as
hab : ¬a < b
hba : ¬b < a
h₁ : as ≤ bs
⊢ a :: as = b :: bs

tactic: have ih : as = bs := le_antisymm h₁ h₂
state_before: case inr.inr
α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁✝ : a :: as ≤ b :: bs
h₂✝ : b :: bs ≤ a :: as
hab : ¬a < b
hba : ¬b < a
h₁ : as ≤ bs
h₂ : bs ≤ as
⊢ a :: as = b :: bs

tactic: have : a = b := s.antisymm hab hba
state_before: case inr.inr
α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁✝ : a :: as ≤ b :: bs
h₂✝ : b :: bs ≤ a :: as
hab : ¬a < b
hba : ¬b < a
h₁ : as ≤ bs
h₂ : bs ≤ as
ih : as = bs
⊢ a :: as = b :: bs

tactic: simp [this, ih]
state_before: case inr.inr
α : Type u_1
inst✝ : LT α
s : Antisymm fun x x_1 => ¬x < x_1
as✝ bs✝ : List α
a : α
as : List α
b : α
bs : List α
h₁✝ : a :: as ≤ b :: bs
h₂✝ : b :: bs ≤ a :: as
hab : ¬a < b
hba : ¬b < a
h₁ : as ≤ bs
h₂ : bs ≤ as
ih : as = bs
this : a = b
⊢ a :: as = b :: bs