ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Multiplicative.isSubgroup_iff
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set A
⊢ IsSubgroup s → IsAddSubgroup s
state_after: case mk.mk
G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set A
h₃ : ∀ {a : Multiplicative A}, a ∈ s → a⁻¹ ∈ s
h₁ : 1 ∈ s
h₂ : ∀ {a b : Multiplicative A}, a ∈ s → b ∈ s → a * b ∈ s
⊢ IsAddSubgroup s
tactic: rintro ⟨⟨h₁, h₂⟩, h₃⟩
state_before: case mk.mk
G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set A
h₃ : ∀ {a : Multiplicative A}, a ∈ s → a⁻¹ ∈ s
h₁ : 1 ∈ s
h₂ : ∀ {a b : Multiplicative A}, a ∈ s → b ∈ s → a * b ∈ s
⊢ IsAddSubgroup s
state_after: no goals
tactic: exact @IsAddSubgroup.mk A _ _ ⟨h₁, @h₂⟩ @h₃
Theorem: HurwitzZeta.hasSum_int_sinKernel
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a t : ℝ
ht : 0 < t
⊢ HasSum (fun n => -I * ↑n * cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t))) ↑(sinKernel (↑a) t)
state_after: a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
⊢ HasSum (fun n => -I * ↑n * cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t))) ↑(sinKernel (↑a) t)
tactic: have h : -2 * (π : ℂ) ≠ (0 : ℂ) := by
    simp only [neg_mul, ne_eq, neg_eq_zero, mul_eq_zero,
      OfNat.ofNat_ne_zero, ofReal_eq_zero, pi_ne_zero, or_self, not_false_eq_true]
state_before: a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
⊢ HasSum (fun n => -I * ↑n * cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t))) ↑(sinKernel (↑a) t)
state_after: a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
⊢ HasSum (fun n => -I * ↑n * cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)))
    (jacobiTheta₂' (↑a) (I * ↑t) / (-2 * ↑π))
tactic: rw [sinKernel_def]
state_before: a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
⊢ HasSum (fun n => -I * ↑n * cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)))
    (jacobiTheta₂' (↑a) (I * ↑t) / (-2 * ↑π))
state_after: a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
n : ℤ
⊢ -I * ↑n * cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)) = jacobiTheta₂'_term n (↑a) (I * ↑t) / (-2 * ↑π)
tactic: refine ((hasSum_jacobiTheta₂'_term a
    (by rwa [I_mul_im, ofReal_re])).div_const _).congr_fun fun n ↦ ?_
state_before: a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
n : ℤ
⊢ -I * ↑n * cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)) = jacobiTheta₂'_term n (↑a) (I * ↑t) / (-2 * ↑π)
state_after: a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
n : ℤ
⊢ -2 * ↑π * (-I * ↑n) * cexp (2 * ↑π * I * ↑a * ↑n + -↑π * ↑n ^ 2 * ↑t) =
    2 * ↑π * I * ↑n * cexp (2 * ↑π * I * ↑n * ↑a + ↑π * I * ↑n ^ 2 * (I * ↑t))
tactic: rw [jacobiTheta₂'_term, jacobiTheta₂_term, ofReal_exp, mul_assoc (-I * n), ← Complex.exp_add,
    eq_div_iff h, ofReal_mul, ofReal_mul, ofReal_pow, ofReal_neg, ofReal_intCast,
    mul_comm _ (-2 * π : ℂ), ← mul_assoc]
state_before: a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
n : ℤ
⊢ -2 * ↑π * (-I * ↑n) * cexp (2 * ↑π * I * ↑a * ↑n + -↑π * ↑n ^ 2 * ↑t) =
    2 * ↑π * I * ↑n * cexp (2 * ↑π * I * ↑n * ↑a + ↑π * I * ↑n ^ 2 * (I * ↑t))
state_after: case refine_1
a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
n : ℤ
⊢ -2 * ↑π * (-I * ↑n) = 2 * ↑π * I * ↑n

case refine_2
a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
n : ℤ
⊢ 2 * ↑π * I * ↑a * ↑n = 2 * ↑π * I * ↑n * ↑a

case refine_3
a t : ℝ
ht : 0 < t
h : -2 * ↑π ≠ 0
n : ℤ
⊢ -↑π * ↑n ^ 2 * ↑t = ↑π * I * ↑n ^ 2 * (I * ↑t)
tactic: congrm ?_ * cexp (?_ + ?_)
Theorem: MvPolynomial.isWeightedHomogeneous_zero_iff_weightedTotalDegree_eq_zero
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : CanonicallyLinearOrderedAddCommMonoid M
w : σ → M
φ p : MvPolynomial σ R
⊢ IsWeightedHomogeneous w p 0 ↔ weightedTotalDegree w p = 0
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : CanonicallyLinearOrderedAddCommMonoid M
w : σ → M
φ p : MvPolynomial σ R
⊢ (∀ ⦃d : σ →₀ ℕ⦄, coeff d p ≠ 0 → (weight w) d = 0) ↔ ∀ s ∈ p.support, (weight w) s = 0
tactic: rw [weightedTotalDegree, ← bot_eq_zero, Finset.sup_eq_bot_iff, bot_eq_zero, IsWeightedHomogeneous]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : CanonicallyLinearOrderedAddCommMonoid M
w : σ → M
φ p : MvPolynomial σ R
⊢ (∀ ⦃d : σ →₀ ℕ⦄, coeff d p ≠ 0 → (weight w) d = 0) ↔ ∀ s ∈ p.support, (weight w) s = 0
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : CanonicallyLinearOrderedAddCommMonoid M
w : σ → M
φ p : MvPolynomial σ R
⊢ ∀ (a : σ →₀ ℕ), coeff a p ≠ 0 → (weight w) a = 0 ↔ a ∈ p.support → (weight w) a = 0
tactic: apply forall_congr'
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : CanonicallyLinearOrderedAddCommMonoid M
w : σ → M
φ p : MvPolynomial σ R
⊢ ∀ (a : σ →₀ ℕ), coeff a p ≠ 0 → (weight w) a = 0 ↔ a ∈ p.support → (weight w) a = 0
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : CanonicallyLinearOrderedAddCommMonoid M
w : σ → M
φ p : MvPolynomial σ R
m : σ →₀ ℕ
⊢ coeff m p ≠ 0 → (weight w) m = 0 ↔ m ∈ p.support → (weight w) m = 0
tactic: intro m
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : CanonicallyLinearOrderedAddCommMonoid M
w : σ → M
φ p : MvPolynomial σ R
m : σ →₀ ℕ
⊢ coeff m p ≠ 0 → (weight w) m = 0 ↔ m ∈ p.support → (weight w) m = 0
state_after: no goals
tactic: rw [mem_support_iff]
Theorem: DiscreteQuotient.comap_mono
File: Mathlib/Topology/DiscreteQuotient.lean

Proof steps:
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
g : C(Y, Z)
f : C(X, Y)
A B : DiscreteQuotient Y
h : A ≤ B
⊢ comap f A ≤ comap f B
state_after: no goals
tactic: tauto
Theorem: Set.unit_coe
File: Mathlib/RingTheory/DedekindDomain/SInteger.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
S : Set (HeightOneSpectrum R)
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x✝ : Kˣ
⊢ x✝ ∈ {x | ∀ v ∉ S, v.valuation ↑x = 1} ↔ x✝ ∈ ↑(⨅ v, ⨅ (_ : v ∉ S), v.valuation.valuationSubring.unitGroup)
state_after: no goals
tactic: simp only [mem_setOf, SetLike.mem_coe, Subgroup.mem_iInf, Valuation.mem_unitGroup_iff]
Theorem: isClopen_iff_frontier_eq_empty
File: Mathlib/Topology/Clopen.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ IsClopen s ↔ frontier s = ∅
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ closure s = s ∧ interior s = s ↔ closure s ⊆ interior s
tactic: rw [IsClopen, ← closure_eq_iff_isClosed, ← interior_eq_iff_isOpen, frontier, diff_eq_empty]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ closure s = s ∧ interior s = s ↔ closure s ⊆ interior s
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
h : closure s ⊆ interior s
⊢ closure s = s ∧ interior s = s
tactic: refine ⟨fun h => (h.1.trans h.2.symm).subset, fun h => ?_⟩
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
h : closure s ⊆ interior s
⊢ closure s = s ∧ interior s = s
state_after: no goals
tactic: exact ⟨(h.trans interior_subset).antisymm subset_closure,
    interior_subset.antisymm (subset_closure.trans h)⟩
Theorem: Subalgebra.centralizer_centralizer_centralizer
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

Proof steps:
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
s : Set A
⊢ centralizer R s.centralizer.centralizer = centralizer R s
state_after: case a
R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
s : Set A
⊢ ↑(centralizer R s.centralizer.centralizer) = ↑(centralizer R s)
tactic: apply SetLike.coe_injective
state_before: case a
R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
s : Set A
⊢ ↑(centralizer R s.centralizer.centralizer) = ↑(centralizer R s)
state_after: no goals
tactic: simp only [coe_centralizer, Set.centralizer_centralizer_centralizer]
Theorem: SimpleGraph.IsNClique.insert
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
hs : G.IsNClique n s
h : ∀ b ∈ s, G.Adj a b
⊢ G.IsNClique (n + 1) (Insert.insert a s)
state_after: case clique
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
hs : G.IsNClique n s
h : ∀ b ∈ s, G.Adj a b
⊢ G.IsClique ↑(Insert.insert a s)

case card_eq
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
hs : G.IsNClique n s
h : ∀ b ∈ s, G.Adj a b
⊢ (Insert.insert a s).card = n + 1
tactic: constructor
Theorem: Differentiable.sub_iff_left
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hg : Differentiable 𝕜 g
⊢ (Differentiable 𝕜 fun y => f y - g y) ↔ Differentiable 𝕜 f
state_after: no goals
tactic: simp only [sub_eq_add_neg, differentiable_neg_iff, hg, add_iff_left]
Theorem: CategoryTheory.Limits.biprod.lift_desc
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
X Y : C
inst✝ : HasBinaryBiproduct X Y
T U : C
f : T ⟶ X
g : T ⟶ Y
h : X ⟶ U
i : Y ⟶ U
⊢ lift f g ≫ desc h i = f ≫ h + g ≫ i
state_after: no goals
tactic: simp [biprod.lift_eq, biprod.desc_eq]
Theorem: toIcoMod_add_zsmul'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoMod hp (a + m • p) b = toIcoMod hp a b + m • p
state_after: no goals
tactic: simp only [toIcoMod, toIcoDiv_add_zsmul', sub_smul, sub_add]
Theorem: Rat.zero_add
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q a b c : ℚ
⊢ 0 + a = a
state_after: no goals
tactic: simp [add_def, normalize_eq_mkRat]
Theorem: realPart_I_smul
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ℜ (I • a) = -ℑ a
state_after: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(ℜ (I • a)) = ↑(-ℑ a)
tactic: ext
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(ℜ (I • a)) = ↑(-ℑ a)
state_after: no goals
tactic: rw [realPart_apply_coe, NegMemClass.coe_neg, imaginaryPart_apply_coe, neg_smul, neg_neg,
    smul_comm I, star_smul, star_def, conj_I, smul_sub, neg_smul, sub_eq_add_neg]
Theorem: Sum.LiftRel.isLeft_right
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
h : LiftRel r s (inl a) y
⊢ y.isLeft = true
state_after: case inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
a : α
b : β
c : γ
d : δ
c✝ : γ
a✝ : r a c✝
⊢ (inl c✝).isLeft = true
tactic: cases h
state_before: case inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
a : α
b : β
c : γ
d : δ
c✝ : γ
a✝ : r a c✝
⊢ (inl c✝).isLeft = true
state_after: no goals
tactic: rfl
Theorem: List.get?_pmap
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
h : ∀ (a : α), a ∈ l → p a
n : ℕ
⊢ (pmap f l h).get? n = Option.pmap f (l.get? n) ⋯
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
h : ∀ (a : α), a ∈ l → p a
n : ℕ
⊢ (pmap f l h)[n]? = Option.pmap f l[n]? ⋯
tactic: simp only [get?_eq_getElem?]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
h : ∀ (a : α), a ∈ l → p a
n : ℕ
⊢ (pmap f l h)[n]? = Option.pmap f l[n]? ⋯
state_after: no goals
tactic: simp [getElem?_pmap, h]
Theorem: PEquiv.single_subsingleton_eq_refl
File: Mathlib/Data/PEquiv.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DecidableEq γ
inst✝ : Subsingleton α
a b : α
⊢ single a b = PEquiv.refl α
state_after: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DecidableEq γ
inst✝ : Subsingleton α
a b i j : α
⊢ j ∈ (single a b) i ↔ j ∈ (PEquiv.refl α) i
tactic: ext i j
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DecidableEq γ
inst✝ : Subsingleton α
a b i j : α
⊢ j ∈ (single a b) i ↔ j ∈ (PEquiv.refl α) i
state_after: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DecidableEq γ
inst✝ : Subsingleton α
a b i j : α
⊢ (j ∈ if i = a then some b else none) ↔ j ∈ some i
tactic: dsimp [single]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DecidableEq γ
inst✝ : Subsingleton α
a b i j : α
⊢ (j ∈ if i = a then some b else none) ↔ j ∈ some i
state_after: no goals
tactic: rw [if_pos (Subsingleton.elim i a), Subsingleton.elim i j, Subsingleton.elim b j]
Theorem: NumberField.mixedEmbedding.norm_smul
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
c : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ mixedEmbedding.norm (c • x) = |c| ^ finrank ℚ K * mixedEmbedding.norm x
state_after: no goals
tactic: simp_rw [mixedEmbedding.norm_apply, normAtPlace_smul, mul_pow, prod_mul_distrib,
    prod_pow_eq_pow_sum, sum_mult_eq]
Theorem: FastSubsingleton.helim
File: Mathlib/Tactic/CongrExclamation.lean

Proof steps:
state_before: α β : Sort u
inst✝ : FastSubsingleton α
h₂ : α = β
a : α
b : β
⊢ HEq a b
state_after: α β : Sort u
inst✝ : FastSubsingleton α
h₂ : α = β
a : α
b : β
this : Subsingleton α
⊢ HEq a b
tactic: have : Subsingleton α := FastSubsingleton.inst
state_before: α β : Sort u
inst✝ : FastSubsingleton α
h₂ : α = β
a : α
b : β
this : Subsingleton α
⊢ HEq a b
state_after: no goals
tactic: exact Subsingleton.helim h₂ a b
Theorem: CocompactMap.tendsto_of_forall_preimage
File: Mathlib/Topology/ContinuousFunction/CocompactMap.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
h : ∀ (s : Set β), IsCompact s → IsCompact (f ⁻¹' s)
s : Set β
hs : s ∈ cocompact β
t : Set β
ht : IsCompact t
hts : tᶜ ⊆ s
⊢ (f ⁻¹' t)ᶜ ⊆ f ⁻¹' s
state_after: no goals
tactic: simpa using preimage_mono hts
Theorem: HasGradientAt.hasDerivAt
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
g : 𝕜 → 𝕜
g' u : 𝕜
L' : Filter 𝕜
h : HasGradientAt g g' u
⊢ HasDerivAt g ((starRingEnd 𝕜) g') u
state_after: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
g : 𝕜 → 𝕜
g' u : 𝕜
L' : Filter 𝕜
h : HasDerivAt g (((toDual 𝕜 𝕜) g') 1) u
⊢ HasDerivAt g ((starRingEnd 𝕜) g') u
tactic: rw [hasGradientAt_iff_hasFDerivAt, hasFDerivAt_iff_hasDerivAt] at h
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
g : 𝕜 → 𝕜
g' u : 𝕜
L' : Filter 𝕜
h : HasDerivAt g (((toDual 𝕜 𝕜) g') 1) u
⊢ HasDerivAt g ((starRingEnd 𝕜) g') u
state_after: no goals
tactic: simpa using h
Theorem: CategoryTheory.Discrete.natIso_app
File: Mathlib/CategoryTheory/DiscreteCategory.lean

Proof steps:
state_before: α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
i : Discrete I
⊢ (natIso f).app i = f i
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.SimplicialObject.Augmented.toArrow_obj_right
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 C).map ((drop.map η).app (op [0])) ≫
      ((fun X => { left := drop.obj X _[0], right := point.obj X, hom := X.hom.app (op [0]) }) Y✝).hom =
    ((fun X => { left := drop.obj X _[0], right := point.obj X, hom := X.hom.app (op [0]) }) X✝).hom ≫
      (𝟭 C).map (point.map η)
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left.app (op [0]) ≫ Y✝.hom.app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left.app (op [0]) ≫ Y✝.hom.app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (η.left ≫ Y✝.hom).app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
tactic: rw [← NatTrans.comp_app]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (η.left ≫ Y✝.hom).app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (X✝.hom ≫ (const C).map η.right).app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
tactic: erw [η.w]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (X✝.hom ≫ (const C).map η.right).app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
state_after: no goals
tactic: rfl
Theorem: Real.sInf_nonneg
File: Mathlib/Data/Real/Archimedean.lean

Proof steps:
state_before: S : Set ℝ
hS : ∀ x ∈ S, 0 ≤ x
⊢ 0 ≤ sInf S
state_after: case inl
hS : ∀ x ∈ ∅, 0 ≤ x
⊢ 0 ≤ sInf ∅

case inr
S : Set ℝ
hS : ∀ x ∈ S, 0 ≤ x
hS₂ : S.Nonempty
⊢ 0 ≤ sInf S
tactic: rcases S.eq_empty_or_nonempty with (rfl | hS₂)
state_before: case inl
hS : ∀ x ∈ ∅, 0 ≤ x
⊢ 0 ≤ sInf ∅

case inr
S : Set ℝ
hS : ∀ x ∈ S, 0 ≤ x
hS₂ : S.Nonempty
⊢ 0 ≤ sInf S
state_after: no goals
tactic: exacts [sInf_empty.ge, le_csInf hS₂ hS]
Theorem: exists_nhds_split_inv
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x : α
s : Set G
hs : s ∈ 𝓝 1
⊢ ∃ V ∈ 𝓝 1, ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x : α
s : Set G
hs : s ∈ 𝓝 1
this : (fun p => p.1 * p.2⁻¹) ⁻¹' s ∈ 𝓝 (1, 1)
⊢ ∃ V ∈ 𝓝 1, ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s
tactic: have : (fun p : G × G => p.1 * p.2⁻¹) ⁻¹' s ∈ 𝓝 ((1, 1) : G × G) :=
    continuousAt_fst.mul continuousAt_snd.inv (by simpa)
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x : α
s : Set G
hs : s ∈ 𝓝 1
this : (fun p => p.1 * p.2⁻¹) ⁻¹' s ∈ 𝓝 (1, 1)
⊢ ∃ V ∈ 𝓝 1, ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s
state_after: no goals
tactic: simpa only [div_eq_mul_inv, nhds_prod_eq, mem_prod_self_iff, prod_subset_iff, mem_preimage] using
    this
Theorem: PNat.Coprime.gcd_mul_left_cancel
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: m n k : ℕ+
⊢ k.Coprime n → (k * m).gcd n = m.gcd n
state_after: m n k : ℕ+
h : k.Coprime n
⊢ (k * m).gcd n = m.gcd n
tactic: intro h
state_before: m n k : ℕ+
h : k.Coprime n
⊢ (k * m).gcd n = m.gcd n
state_after: case a
m n k : ℕ+
h : k.Coprime n
⊢ ↑((k * m).gcd n) = ↑(m.gcd n)
tactic: apply eq
state_before: case a
m n k : ℕ+
h : k.Coprime n
⊢ ↑((k * m).gcd n) = ↑(m.gcd n)
state_after: case a
m n k : ℕ+
h : k.Coprime n
⊢ (↑k * ↑m).gcd ↑n = (↑m).gcd ↑n
tactic: simp only [gcd_coe, mul_coe]
state_before: case a
m n k : ℕ+
h : k.Coprime n
⊢ (↑k * ↑m).gcd ↑n = (↑m).gcd ↑n
state_after: case a.H
m n k : ℕ+
h : k.Coprime n
⊢ (↑k).Coprime ↑n
tactic: apply Nat.Coprime.gcd_mul_left_cancel
state_before: case a.H
m n k : ℕ+
h : k.Coprime n
⊢ (↑k).Coprime ↑n
state_after: no goals
tactic: simpa
Theorem: sub_lt_sub_iff_right
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c✝ d c : α
⊢ a / c < b / c ↔ a < b
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using mul_lt_mul_iff_right _
Theorem: Monoid.le_minOrder
File: Mathlib/GroupTheory/Order/Min.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a : α
n : ℕ∞
⊢ n ≤ minOrder α ↔ ∀ ⦃a : α⦄, a ≠ 1 → IsOfFinOrder a → n ≤ ↑(orderOf a)
state_after: no goals
tactic: simp [minOrder]