ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Seminorm.uniformity_eq_of_hasBasis
File: Mathlib/Analysis/Seminorm.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι✝ : Type u_12
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : SeminormedRing 𝕝
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Module 𝕝 E
ι : Sort u_13
inst✝² : UniformSpace E
inst✝¹ : UniformAddGroup E
inst✝ : ContinuousConstSMul 𝕜 E
p' : ι → Prop
s : ι → Set E
p : Seminorm 𝕜 E
hb : (𝓝 0).HasBasis p' s
h₁ : ∃ r, p.closedBall 0 r ∈ 𝓝 0
h₂ : ∀ (i : ι), p' i → ∃ r > 0, p.ball 0 r ⊆ s i
⊢ 𝓤 E = ⨅ r, ⨅ (_ : r > 0), 𝓟 {x | p (x.1 - x.2) < r}
state_after: no goals
tactic: rfl
Theorem: Set.prod_self_eq_iUnion_perm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f : Perm α
s : Set α
hf : f.IsCycleOn s
⊢ s ×ˢ s = ⋃ n, (fun a => (a, (f ^ n) a)) '' s
state_after: case h.mk
ι : Type u_1
α : Type u_2
β : Type u_3
f : Perm α
s : Set α
hf : f.IsCycleOn s
a b : α
⊢ (a, b) ∈ s ×ˢ s ↔ (a, b) ∈ ⋃ n, (fun a => (a, (f ^ n) a)) '' s
tactic: ext ⟨a, b⟩
state_before: case h.mk
ι : Type u_1
α : Type u_2
β : Type u_3
f : Perm α
s : Set α
hf : f.IsCycleOn s
a b : α
⊢ (a, b) ∈ s ×ˢ s ↔ (a, b) ∈ ⋃ n, (fun a => (a, (f ^ n) a)) '' s
state_after: case h.mk
ι : Type u_1
α : Type u_2
β : Type u_3
f : Perm α
s : Set α
hf : f.IsCycleOn s
a b : α
⊢ a ∈ s ∧ b ∈ s ↔ ∃ i, ∃ x ∈ s, (x, (f ^ i) x) = (a, b)
tactic: simp only [Set.mem_prod, Set.mem_iUnion, Set.mem_image]
state_before: case h.mk
ι : Type u_1
α : Type u_2
β : Type u_3
f : Perm α
s : Set α
hf : f.IsCycleOn s
a b : α
⊢ a ∈ s ∧ b ∈ s ↔ ∃ i, ∃ x ∈ s, (x, (f ^ i) x) = (a, b)
state_after: case h.mk.refine_1
ι : Type u_1
α : Type u_2
β : Type u_3
f : Perm α
s : Set α
hf : f.IsCycleOn s
a b : α
hx : a ∈ s ∧ b ∈ s
⊢ ∃ i, ∃ x ∈ s, (x, (f ^ i) x) = (a, b)

case h.mk.refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
f : Perm α
s : Set α
hf : f.IsCycleOn s
a b : α
⊢ (∃ i, ∃ x ∈ s, (x, (f ^ i) x) = (a, b)) → a ∈ s ∧ b ∈ s
tactic: refine ⟨fun hx => ?_, ?_⟩
Theorem: StieltjesFunction.measurableSet_Ioi
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f : StieltjesFunction
c : ℝ
⊢ MeasurableSet (Ioi c)
state_after: f : StieltjesFunction
c : ℝ
t : Set ℝ
⊢ f.length (t ∩ Ioi c) + f.length (t \ Ioi c) ≤ f.length t
tactic: refine OuterMeasure.ofFunction_caratheodory fun t => ?_
state_before: f : StieltjesFunction
c : ℝ
t : Set ℝ
⊢ f.length (t ∩ Ioi c) + f.length (t \ Ioi c) ≤ f.length t
state_after: f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
⊢ f.length (t ∩ Ioi c) + f.length (t \ Ioi c) ≤ ofReal (↑f b - ↑f a)
tactic: refine le_iInf fun a => le_iInf fun b => le_iInf fun h => ?_
state_before: f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
⊢ f.length (t ∩ Ioi c) + f.length (t \ Ioi c) ≤ ofReal (↑f b - ↑f a)
state_after: f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
⊢ f.length (Ioc a b ∩ Ioi c) + f.length (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)
tactic: refine
    le_trans
      (add_le_add (f.length_mono <| inter_subset_inter_left _ h)
        (f.length_mono <| diff_subset_diff_left h)) ?_
state_before: f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
⊢ f.length (Ioc a b ∩ Ioi c) + f.length (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)
state_after: case inl.inl
f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
hac : a ≤ c
hbc : b ≤ c
⊢ f.length (Ioc a b ∩ Ioi c) + f.length (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)

case inl.inr
f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
hac : a ≤ c
hbc : c ≤ b
⊢ f.length (Ioc a b ∩ Ioi c) + f.length (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)

case inr.inl
f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
hac : c ≤ a
hbc : b ≤ c
⊢ f.length (Ioc a b ∩ Ioi c) + f.length (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)

case inr.inr
f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
hac : c ≤ a
hbc : c ≤ b
⊢ f.length (Ioc a b ∩ Ioi c) + f.length (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)
tactic: rcases le_total a c with hac | hac <;> rcases le_total b c with hbc | hbc
Theorem: HomologicalComplex.XIsoOfEq_hom_naturality
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
n n' : ι
h : n = n'
⊢ φ.f n ≫ (L.XIsoOfEq h).hom = (K.XIsoOfEq h).hom ≫ φ.f n'
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
n : ι
⊢ φ.f n ≫ (L.XIsoOfEq ⋯).hom = (K.XIsoOfEq ⋯).hom ≫ φ.f n
tactic: subst h
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
n : ι
⊢ φ.f n ≫ (L.XIsoOfEq ⋯).hom = (K.XIsoOfEq ⋯).hom ≫ φ.f n
state_after: no goals
tactic: simp
Theorem: Complex.hasStrictDerivAt_const_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: x y : ℂ
h : x ≠ 0 ∨ y ≠ 0
⊢ HasStrictDerivAt (fun y => x ^ y) (x ^ y * log x) y
state_after: case inl
y : ℂ
h : 0 ≠ 0 ∨ y ≠ 0
⊢ HasStrictDerivAt (fun y => 0 ^ y) (0 ^ y * log 0) y

case inr
x y : ℂ
h : x ≠ 0 ∨ y ≠ 0
hx : ¬x = 0
⊢ HasStrictDerivAt (fun y => x ^ y) (x ^ y * log x) y
tactic: rcases em (x = 0) with (rfl | hx)
Theorem: skewAdjoint.negISMul_apply_coe
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 : ↥(skewAdjoint A)
⊢ -I • ↑a ∈ selfAdjoint A
state_after: no goals
tactic: simp only [neg_smul, neg_mem_iff, selfAdjoint.mem_iff, star_smul, star_def, conj_I,
        star_val_eq, smul_neg, neg_neg]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a b : ↥(skewAdjoint A)
⊢ (fun a => ⟨-I • ↑a, ⋯⟩) (a + b) = (fun a => ⟨-I • ↑a, ⋯⟩) a + (fun a => ⟨-I • ↑a, ⋯⟩) b
state_after: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a b : ↥(skewAdjoint A)
⊢ ↑((fun a => ⟨-I • ↑a, ⋯⟩) (a + b)) = ↑((fun a => ⟨-I • ↑a, ⋯⟩) a + (fun a => ⟨-I • ↑a, ⋯⟩) b)
tactic: ext
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a b : ↥(skewAdjoint A)
⊢ ↑((fun a => ⟨-I • ↑a, ⋯⟩) (a + b)) = ↑((fun a => ⟨-I • ↑a, ⋯⟩) a + (fun a => ⟨-I • ↑a, ⋯⟩) b)
state_after: no goals
tactic: simp only [AddSubgroup.coe_add, smul_add, AddMemClass.mk_add_mk]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : ℝ
b : ↥(skewAdjoint A)
⊢ { toFun := fun a => ⟨-I • ↑a, ⋯⟩, map_add' := ⋯ }.toFun (a • b) =
    (RingHom.id ℝ) a • { toFun := fun a => ⟨-I • ↑a, ⋯⟩, map_add' := ⋯ }.toFun b
state_after: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : ℝ
b : ↥(skewAdjoint A)
⊢ ↑({ toFun := fun a => ⟨-I • ↑a, ⋯⟩, map_add' := ⋯ }.toFun (a • b)) =
    ↑((RingHom.id ℝ) a • { toFun := fun a => ⟨-I • ↑a, ⋯⟩, map_add' := ⋯ }.toFun b)
tactic: ext
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : ℝ
b : ↥(skewAdjoint A)
⊢ ↑({ toFun := fun a => ⟨-I • ↑a, ⋯⟩, map_add' := ⋯ }.toFun (a • b)) =
    ↑((RingHom.id ℝ) a • { toFun := fun a => ⟨-I • ↑a, ⋯⟩, map_add' := ⋯ }.toFun b)
state_after: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : ℝ
b : ↥(skewAdjoint A)
⊢ I • a • ↑b = a • I • ↑b
tactic: simp only [neg_smul, skewAdjoint.val_smul, AddSubgroup.coe_mk, RingHom.id_apply,
      selfAdjoint.val_smul, smul_neg, neg_inj]
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : ℝ
b : ↥(skewAdjoint A)
⊢ I • a • ↑b = a • I • ↑b
state_after: no goals
tactic: rw [smul_comm]
Theorem: IsLocalization.algHom_subsingleton
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁴ : CommSemiring S
inst✝³ : Algebra R S
P : Type u_3
inst✝² : CommSemiring P
inst✝¹ : IsLocalization M S
g✝ : R →+* P
hg : ∀ (y : ↥M), IsUnit (g✝ ↑y)
inst✝ : Algebra R P
f g : S →ₐ[R] P
⊢ (↑f).comp (algebraMap R S) = (↑g).comp (algebraMap R S)
state_after: no goals
tactic: rw [f.comp_algebraMap, g.comp_algebraMap]
Theorem: HasDerivAtFilter.sum
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

Proof steps:
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 𝕜
ι : Type u_1
u : Finset ι
A : ι → 𝕜 → F
A' : ι → F
h : ∀ i ∈ u, HasDerivAtFilter (A i) (A' i) x L
⊢ HasDerivAtFilter (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x L
state_after: no goals
tactic: simpa [ContinuousLinearMap.sum_apply] using (HasFDerivAtFilter.sum h).hasDerivAtFilter
Theorem: Set.finite_of_forall_not_lt_lt
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : LinearOrder α
s : Set α
h : ∀ x ∈ s, ∀ y ∈ s, ∀ z ∈ s, x < y → y < z → False
⊢ ∀ ⦃x y z : ↑s⦄, x < y → y < z → False
state_after: no goals
tactic: simpa only [SetCoe.forall'] using h
Theorem: CategoryTheory.Limits.IsImage.isoExt_hom_m
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ (hF.isoExt hF').hom ≫ F'.m = F.m
state_after: no goals
tactic: simp
Theorem: AddCommGroup.ModEq.nsmul
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z m : ℤ
hm : b - a = m • p
⊢ n • b - n • a = m • n • p
state_after: no goals
tactic: rw [← smul_sub, hm, smul_comm]
Theorem: AdicCompletion.transitionMap_mk
File: Mathlib/RingTheory/AdicCompletion/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
m n : ℕ
hmn : m ≤ n
x : M
⊢ (transitionMap I M hmn) (Submodule.Quotient.mk x) = Submodule.Quotient.mk x
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.setToFun_smul_left
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
c : ℝ
f : α → E
⊢ setToFun μ (fun s => c • T s) ⋯ f = c • setToFun μ T hT f
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
c : ℝ
f : α → E
hf : Integrable f μ
⊢ setToFun μ (fun s => c • T s) ⋯ f = c • setToFun μ T hT f

case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
c : ℝ
f : α → E
hf : ¬Integrable f μ
⊢ setToFun μ (fun s => c • T s) ⋯ f = c • setToFun μ T hT f
tactic: by_cases hf : Integrable f μ
Theorem: Filter.limsup_compl
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
⊢ (limsup u f)ᶜ = liminf (compl ∘ u) f
state_after: no goals
tactic: simp only [limsup_eq_iInf_iSup, compl_iInf, compl_iSup, liminf_eq_iSup_iInf, Function.comp_apply]
Theorem: CategoryTheory.Functor.sheafAdjunctionCocontinuous_counit_app_val
File: Mathlib/CategoryTheory/Sites/CoverLifting.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{u_4, u_2} D
G : C ⥤ D
A : Type w
inst✝⁴ : Category.{w', w} A
J : GrothendieckTopology C
K : GrothendieckTopology D
inst✝³ : G.IsCocontinuous J K
inst✝² : ∀ (F : Cᵒᵖ ⥤ A), G.op.HasPointwiseRightKanExtension F
inst✝¹ : G.IsCocontinuous J K
inst✝ : G.IsContinuous J K
F : Sheaf J A
⊢ (G.sheafPushforwardContinuousCompSheafToPresheafIso A J K).symm.inv.app
        ((G.sheafPushforwardCocontinuous A J K).obj F) ≫
      ((whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj G.op).map
          ((G.sheafPushforwardCocontinuousCompSheafToPresheafIso A J K).symm.inv.app F) ≫
        (G.op.ranAdjunction A).counit.app ((sheafToPresheaf J A).obj F) =
    (G.op.ranAdjunction A).counit.app F.val
state_after: no goals
tactic: aesop_cat
Theorem: MeasureTheory.Martingale.add
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
hf : Martingale f ℱ μ
hg : Martingale g ℱ μ
⊢ Martingale (f + g) ℱ μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
hf : Martingale f ℱ μ
hg : Martingale g ℱ μ
i j : ι
hij : i ≤ j
⊢ μ[(f + g) j|↑ℱ i] =ᶠ[ae μ] (f + g) i
tactic: refine ⟨hf.adapted.add hg.adapted, fun i j hij => ?_⟩
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
hf : Martingale f ℱ μ
hg : Martingale g ℱ μ
i j : ι
hij : i ≤ j
⊢ μ[(f + g) j|↑ℱ i] =ᶠ[ae μ] (f + g) i
state_after: no goals
tactic: exact (condexp_add (hf.integrable j) (hg.integrable j)).trans ((hf.2 i j hij).add (hg.2 i j hij))
Theorem: selfZPow_of_nonpos
File: Mathlib/RingTheory/Localization/Away/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
x : R
B : Type u_2
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
n : ℤ
hn : n ≤ 0
⊢ selfZPow x B n = mk' B 1 (Submonoid.pow x n.natAbs)
state_after: case pos
R : Type u_1
inst✝³ : CommRing R
x : R
B : Type u_2
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
n : ℤ
hn : n ≤ 0
hn0 : n = 0
⊢ selfZPow x B n = mk' B 1 (Submonoid.pow x n.natAbs)

case neg
R : Type u_1
inst✝³ : CommRing R
x : R
B : Type u_2
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
n : ℤ
hn : n ≤ 0
hn0 : ¬n = 0
⊢ selfZPow x B n = mk' B 1 (Submonoid.pow x n.natAbs)
tactic: by_cases hn0 : n = 0
Theorem: UniqueMul.set_subsingleton
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
⊢ {ab | ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0}.Subsingleton
state_after: case mk.mk
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x1 y1 : G
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0
x2 y2 : G
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0
⊢ (x1, y1) = (x2, y2)
tactic: rintro ⟨x1, y1⟩ (hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0) ⟨x2, y2⟩
    (hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0)
state_before: case mk.mk
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x1 y1 : G
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0
x2 y2 : G
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0
⊢ (x1, y1) = (x2, y2)
state_after: case mk.mk.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
x1 y1 x2 y2 : G
h : UniqueMul A B x1 y1
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = x1 * y1
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x1 * y1
⊢ (x1, y1) = (x2, y2)
tactic: rcases h hx.1 hx.2.1 hx.2.2 with ⟨rfl, rfl⟩
state_before: case mk.mk.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
x1 y1 x2 y2 : G
h : UniqueMul A B x1 y1
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = x1 * y1
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x1 * y1
⊢ (x1, y1) = (x2, y2)
state_after: case mk.mk.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
x2 y2 : G
h : UniqueMul A B x2 y2
hx hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x2 * y2
⊢ (x2, y2) = (x2, y2)
tactic: rcases h hy.1 hy.2.1 hy.2.2 with ⟨rfl, rfl⟩
state_before: case mk.mk.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
x2 y2 : G
h : UniqueMul A B x2 y2
hx hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x2 * y2
⊢ (x2, y2) = (x2, y2)
state_after: no goals
tactic: rfl
Theorem: let_eq
File: Mathlib/Init/Logic.lean

Proof steps:
state_before: α✝ : Sort u
a b c d : Prop
p : ?m.12464
α : Sort v
β : Sort u
a₁ a₂ : α
b₁ b₂ : α → β
h₁ : a₁ = a₂
h₂ : ∀ (x : α), b₁ x = b₂ x
⊢ (let x := a₁;
    b₁ x) =
    let x := a₂;
    b₂ x
state_after: no goals
tactic: simp [h₁, h₂]
Theorem: Real.log_lt_log_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
hx : 0 < x
hy : 0 < y
⊢ log x < log y ↔ x < y
state_after: no goals
tactic: rw [← exp_lt_exp, exp_log hx, exp_log hy]
Theorem: Pell.Solution₁.x_mul_pos
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ 0 < (a * b).x
state_after: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ 0 < a.x * b.x + d * (a.y * b.y)
tactic: simp only [x_mul]
state_before: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ 0 < a.x * b.x + d * (a.y * b.y)
state_after: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ |d * (a.y * b.y)| < a.x * b.x
tactic: refine neg_lt_iff_pos_add'.mp (abs_lt.mp ?_).1
state_before: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ |d * (a.y * b.y)| < a.x * b.x
state_after: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ 0 < (1 + d * a.y ^ 2) * (1 + d * b.y ^ 2) - (d * (a.y * b.y)) ^ 2
tactic: rw [← abs_of_pos ha, ← abs_of_pos hb, ← abs_mul, ← sq_lt_sq, mul_pow a.x, a.prop_x, b.prop_x, ←
    sub_pos]
state_before: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ 0 < (1 + d * a.y ^ 2) * (1 + d * b.y ^ 2) - (d * (a.y * b.y)) ^ 2
state_after: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ 0 < 1 + d * a.y ^ 2 + d * b.y ^ 2
tactic: ring_nf
state_before: d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
⊢ 0 < 1 + d * a.y ^ 2 + d * b.y ^ 2
state_after: case inl
d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
h : 0 ≤ d
⊢ 0 < 1 + d * a.y ^ 2 + d * b.y ^ 2

case inr
d : ℤ
a b : Solution₁ d
ha : 0 < a.x
hb : 0 < b.x
h : d < 0
⊢ 0 < 1 + d * a.y ^ 2 + d * b.y ^ 2
tactic: rcases le_or_lt 0 d with h | h
Theorem: linearIndependent_iff_card_eq_finrank_span
File: Mathlib/LinearAlgebra/Dimension/DivisionRing.lean

Proof steps:
state_before: K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_2
inst✝ : Fintype ι
b : ι → V
⊢ LinearIndependent K b ↔ Fintype.card ι = Set.finrank K (range b)
state_after: case mp
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_2
inst✝ : Fintype ι
b : ι → V
⊢ LinearIndependent K b → Fintype.card ι = Set.finrank K (range b)

case mpr
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_2
inst✝ : Fintype ι
b : ι → V
⊢ Fintype.card ι = Set.finrank K (range b) → LinearIndependent K b
tactic: constructor
Theorem: AddAction.stabilizer_vadd_eq_left
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : IsScalarTower G α β
a : α
b : β
h : Injective fun x => x • b
⊢ stabilizer G (a • b) = stabilizer G a
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : IsScalarTower G α β
a✝ : α
b : β
h : Injective fun x => x • b
a : G
ha : a ∈ stabilizer G (a✝ • b)
⊢ a ∈ stabilizer G a✝
tactic: refine (le_stabilizer_smul_left _ _).antisymm' fun a ha ↦ ?_
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : IsScalarTower G α β
a✝ : α
b : β
h : Injective fun x => x • b
a : G
ha : a ∈ stabilizer G (a✝ • b)
⊢ a ∈ stabilizer G a✝
state_after: no goals
tactic: simpa only [mem_stabilizer_iff, ← smul_assoc, h.eq_iff] using ha
Theorem: rightAddCoset_zero
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
s : Set α
⊢ ∀ (x : α), x ∈ op 1 • s ↔ x ∈ s
state_after: no goals
tactic: simp [← image_smul]