ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.moduleCatLeftHomologyData_K
File: Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ (LinearMap.ker S.g).subtype ≫ S.g = 0
state_after: case h.mk
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
val✝ : ↑S.X₂
hx : val✝ ∈ LinearMap.ker S.g
⊢ ((LinearMap.ker S.g).subtype ≫ S.g) ⟨val✝, hx⟩ = 0 ⟨val✝, hx⟩
tactic: ext ⟨_, hx⟩
state_before: case h.mk
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
val✝ : ↑S.X₂
hx : val✝ ∈ LinearMap.ker S.g
⊢ ((LinearMap.ker S.g).subtype ≫ S.g) ⟨val✝, hx⟩ = 0 ⟨val✝, hx⟩
state_after: no goals
tactic: exact hx
state_before: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ (ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯) ≫ S.moduleCatHomologyπ = 0
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯) ≫ S.moduleCatHomologyπ) x = 0 x
tactic: ext (x : S.X₁)
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯) ≫ S.moduleCatHomologyπ) x = 0 x
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ S.moduleCatHomologyπ (((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x) = 0 x
tactic: dsimp
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ S.moduleCatHomologyπ (((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x) = 0 x
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x ∈ LinearMap.range S.moduleCatToCycles
tactic: erw [Submodule.Quotient.mk_eq_zero]
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x ∈ LinearMap.range S.moduleCatToCycles
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ∃ y, S.moduleCatToCycles y = ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x
tactic: rw [LinearMap.mem_range]
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ∃ y, S.moduleCatToCycles y = ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x
state_after: no goals
tactic: apply exists_apply_eq_apply
Theorem: isUnit_zero_iff
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x✝ : IsUnit 0
a : M₀
a0 : 0 * a = 1
inv_val✝ : a * 0 = 1
⊢ 0 = 1
state_after: no goals
tactic: rwa [zero_mul] at a0
Theorem: FractionalIdeal.coeIdeal_mul
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : Ideal R
⊢ ↑(I * J) = ↑I * ↑J
state_after: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : Ideal R
⊢ ↑(I * J) = ⟨↑↑I * ↑↑J, ⋯⟩
tactic: simp only [mul_def]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : Ideal R
⊢ ↑(I * J) = ⟨↑↑I * ↑↑J, ⋯⟩
state_after: no goals
tactic: exact coeToSubmodule_injective (coeSubmodule_mul _ _ _)
Theorem: ProbabilityTheory.defaultRatCDF_le_one
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
⊢ defaultRatCDF q ≤ 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
⊢ (if q < 0 then 0 else 1) ≤ 1
tactic: unfold defaultRatCDF
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
⊢ (if q < 0 then 0 else 1) ≤ 1
state_after: no goals
tactic: split_ifs <;> simp
Theorem: CategoryTheory.Limits.biproduct.isoProduct_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : Discrete J
⊢ (isoProduct f).hom ≫ limit.π (Discrete.functor f) j = Pi.lift (π f) ≫ limit.π (Discrete.functor f) j
state_after: no goals
tactic: simp [biproduct.isoProduct]
Theorem: GaloisConnection.upperBounds_l_image
File: Mathlib/Order/GaloisConnection.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
l : α → β
u : β → α
gc✝ gc : GaloisConnection l u
s : Set α
b : β
⊢ b ∈ upperBounds (l '' s) ↔ b ∈ u ⁻¹' upperBounds s
state_after: no goals
tactic: simp [upperBounds, gc _ _]
Theorem: ArithmeticFunction.cardDistinctFactors_one
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
⊢ ω 1 = 0
state_after: no goals
tactic: simp [cardDistinctFactors]
Theorem: isBounded_convexHull
File: Mathlib/Analysis/Convex/Normed.lean

Proof steps:
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t s : Set E
⊢ Bornology.IsBounded ((convexHull ℝ) s) ↔ Bornology.IsBounded s
state_after: no goals
tactic: simp only [Metric.isBounded_iff_ediam_ne_top, convexHull_ediam]
Theorem: QuotientGroup.rightRel_eq
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b = (b * a⁻¹ ∈ s)
state_after: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b ↔ b * a⁻¹ ∈ s
tactic: simp only [eq_iff_iff]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b ↔ b * a⁻¹ ∈ s
state_after: no goals
tactic: apply rightRel_apply
Theorem: ModularCyclotomicCharacter.toFun_spec
File: Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean

Proof steps:
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n✝ : ℕ+
g : L ≃+* L
n : ℕ+
t : ↥(rootsOfUnity n L)
⊢ g ↑↑t = ↑(↑t ^ (χ₀ n g).val)
state_after: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n✝ : ℕ+
g : L ≃+* L
n : ℕ+
t : ↥(rootsOfUnity n L)
⊢ ↑↑(t ^ ModularCyclotomicCharacter_aux g n) =
    ↑(↑t ^ (ModularCyclotomicCharacter_aux g n % ↑(Fintype.card ↥(rootsOfUnity n L))))
tactic: rw [ModularCyclotomicCharacter_aux_spec g n t, ← zpow_natCast, ModularCyclotomicCharacter.toFun,
    ZMod.val_intCast, ← Subgroup.coe_zpow]
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n✝ : ℕ+
g : L ≃+* L
n : ℕ+
t : ↥(rootsOfUnity n L)
⊢ ↑↑(t ^ ModularCyclotomicCharacter_aux g n) =
    ↑(↑t ^ (ModularCyclotomicCharacter_aux g n % ↑(Fintype.card ↥(rootsOfUnity n L))))
state_after: no goals
tactic: exact Units.ext_iff.1 <| SetCoe.ext_iff.2 <| zpow_eq_zpow_emod _ pow_card_eq_one
Theorem: AddConstMap.coe_comp
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝² : Add G
inst✝¹ : Add H
a : G
b : H
K : Type u_3
inst✝ : Add K
c : K
g : H →+c[b, c] K
f : G →+c[a, b] H
⊢ ∀ (x : G), (⇑g ∘ ⇑f) (x + a) = (⇑g ∘ ⇑f) x + c
state_after: no goals
tactic: simp
Theorem: IsSimpleModule.annihilator_isMaximal
File: Mathlib/RingTheory/SimpleModule.lean

Proof steps:
state_before: ι : Type u_1
R✝ : Type u_2
S : Type u_3
inst✝⁷ : Ring R✝
inst✝⁶ : Ring S
M : Type u_4
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R✝ M
m : Submodule R✝ M
N : Type u_5
inst✝³ : AddCommGroup N
inst✝² : Module R✝ N
R : Type u_6
inst✝¹ : CommRing R
inst✝ : Module R M
simple : IsSimpleModule R M
⊢ (Module.annihilator R M).IsMaximal
state_after: ι : Type u_1
R✝ : Type u_2
S : Type u_3
inst✝⁷ : Ring R✝
inst✝⁶ : Ring S
M : Type u_4
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R✝ M
m : Submodule R✝ M
N : Type u_5
inst✝³ : AddCommGroup N
inst✝² : Module R✝ N
R : Type u_6
inst✝¹ : CommRing R
inst✝ : Module R M
simple : IsSimpleModule R M
I : Ideal R
max : I.IsMaximal
e : M ≃ₗ[R] R ⧸ I
⊢ (Module.annihilator R M).IsMaximal
tactic: have ⟨I, max, ⟨e⟩⟩ := isSimpleModule_iff_quot_maximal.mp simple
state_before: ι : Type u_1
R✝ : Type u_2
S : Type u_3
inst✝⁷ : Ring R✝
inst✝⁶ : Ring S
M : Type u_4
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R✝ M
m : Submodule R✝ M
N : Type u_5
inst✝³ : AddCommGroup N
inst✝² : Module R✝ N
R : Type u_6
inst✝¹ : CommRing R
inst✝ : Module R M
simple : IsSimpleModule R M
I : Ideal R
max : I.IsMaximal
e : M ≃ₗ[R] R ⧸ I
⊢ (Module.annihilator R M).IsMaximal
state_after: no goals
tactic: rwa [e.annihilator_eq, I.annihilator_quotient]
Theorem: Submonoid.LocalizationMap.mk'_eq_iff_eq_mul
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
y : ↥S
z : N
⊢ f.mk' x y = z ↔ f.toMap x = z * f.toMap ↑y
state_after: no goals
tactic: rw [eq_comm, eq_mk'_iff_mul_eq, eq_comm]
Theorem: IsBoundedBilinearMap.fderivWithin
File: Mathlib/Analysis/Calculus/FDeriv/Bilinear.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
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
hxs : UniqueDiffWithinAt 𝕜 u p
⊢ fderivWithin 𝕜 b u p = h.deriv p
state_after: 𝕜 : 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
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
hxs : UniqueDiffWithinAt 𝕜 u p
⊢ fderiv 𝕜 b p = h.deriv p
tactic: rw [DifferentiableAt.fderivWithin (h.differentiableAt p) hxs]
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
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
hxs : UniqueDiffWithinAt 𝕜 u p
⊢ fderiv 𝕜 b p = h.deriv p
state_after: no goals
tactic: exact h.fderiv p
Theorem: MulChar.ofUnitHom_coe
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
f : Rˣ →* R'ˣ
a : Rˣ
⊢ (ofUnitHom f) ↑a = ↑(f a)
state_after: no goals
tactic: simp [ofUnitHom]
Theorem: IntermediateField.toSubalgebra_eq_iff
File: Mathlib/FieldTheory/IntermediateField.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field L'
inst✝¹ : Algebra K L
inst✝ : Algebra K L'
S F E : IntermediateField K L
⊢ F.toSubalgebra = E.toSubalgebra ↔ F = E
state_after: K : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field L'
inst✝¹ : Algebra K L
inst✝ : Algebra K L'
S F E : IntermediateField K L
⊢ (∀ (x : L), x ∈ F.toSubalgebra ↔ x ∈ E.toSubalgebra) ↔ ∀ (x : L), x ∈ ↑F ↔ x ∈ ↑E
tactic: rw [SetLike.ext_iff, SetLike.ext'_iff, Set.ext_iff]
state_before: K : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field L'
inst✝¹ : Algebra K L
inst✝ : Algebra K L'
S F E : IntermediateField K L
⊢ (∀ (x : L), x ∈ F.toSubalgebra ↔ x ∈ E.toSubalgebra) ↔ ∀ (x : L), x ∈ ↑F ↔ x ∈ ↑E
state_after: no goals
tactic: rfl
Theorem: eq_of_div_eq_one
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
h : a / b = 1
⊢ a * b⁻¹ = 1
state_after: no goals
tactic: rwa [← div_eq_mul_inv]
Theorem: MeasureTheory.Measure.haar.prehaar_empty
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
inst✝ : TopologicalSpace G
K₀ : PositiveCompacts G
U : Set G
⊢ prehaar (↑K₀) U ⊥ = 0
state_after: no goals
tactic: rw [prehaar, Compacts.coe_bot, index_empty, Nat.cast_zero, zero_div]
Theorem: IsGδ.dense_sUnion_interior_of_closed
File: Mathlib/Topology/Baire/Lemmas.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
T : Set (Set X)
s : Set X
hs : IsGδ s
hd : Dense s
hc : T.Countable
hc' : ∀ t ∈ T, IsClosed t
hU : s ⊆ ⋃₀ T
⊢ s ⊆ ⋃ i ∈ T, i
state_after: no goals
tactic: rwa [← sUnion_eq_biUnion]
Theorem: SimpleGraph.Walk.map_snd_darts
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ List.map (fun x => x.toProd.2) p.darts = p.support.tail
state_after: no goals
tactic: simpa using congr_arg List.tail (cons_map_snd_darts p)
Theorem: ConvexOn.pow
File: Mathlib/Analysis/Convex/Mul.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : LinearOrderedCommRing 𝕜
inst✝¹¹ : LinearOrderedCommRing E
inst✝¹⁰ : LinearOrderedAddCommGroup F
inst✝⁹ : Module 𝕜 E
inst✝⁸ : Module 𝕜 F
inst✝⁷ : Module E F
inst✝⁶ : IsScalarTower 𝕜 E F
inst✝⁵ : SMulCommClass 𝕜 E F
inst✝⁴ : OrderedSMul 𝕜 E
inst✝³ : OrderedSMul 𝕜 F
inst✝² : OrderedSMul E F
s : Set 𝕜
f✝ : 𝕜 → E
g✝ : 𝕜 → F
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
f g : 𝕜 → E
hf : ConvexOn 𝕜 s f
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ f x
⊢ ConvexOn 𝕜 s (f ^ 0)
state_after: no goals
tactic: simpa using convexOn_const 1 hf.1
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : LinearOrderedCommRing 𝕜
inst✝¹¹ : LinearOrderedCommRing E
inst✝¹⁰ : LinearOrderedAddCommGroup F
inst✝⁹ : Module 𝕜 E
inst✝⁸ : Module 𝕜 F
inst✝⁷ : Module E F
inst✝⁶ : IsScalarTower 𝕜 E F
inst✝⁵ : SMulCommClass 𝕜 E F
inst✝⁴ : OrderedSMul 𝕜 E
inst✝³ : OrderedSMul 𝕜 F
inst✝² : OrderedSMul E F
s : Set 𝕜
f✝ : 𝕜 → E
g✝ : 𝕜 → F
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
f g : 𝕜 → E
hf : ConvexOn 𝕜 s f
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ f x
n : ℕ
⊢ ConvexOn 𝕜 s (f ^ (n + 1))
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : LinearOrderedCommRing 𝕜
inst✝¹¹ : LinearOrderedCommRing E
inst✝¹⁰ : LinearOrderedAddCommGroup F
inst✝⁹ : Module 𝕜 E
inst✝⁸ : Module 𝕜 F
inst✝⁷ : Module E F
inst✝⁶ : IsScalarTower 𝕜 E F
inst✝⁵ : SMulCommClass 𝕜 E F
inst✝⁴ : OrderedSMul 𝕜 E
inst✝³ : OrderedSMul 𝕜 F
inst✝² : OrderedSMul E F
s : Set 𝕜
f✝ : 𝕜 → E
g✝ : 𝕜 → F
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
f g : 𝕜 → E
hf : ConvexOn 𝕜 s f
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ f x
n : ℕ
⊢ ConvexOn 𝕜 s (f * f ^ n)
tactic: rw [pow_succ']
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : LinearOrderedCommRing 𝕜
inst✝¹¹ : LinearOrderedCommRing E
inst✝¹⁰ : LinearOrderedAddCommGroup F
inst✝⁹ : Module 𝕜 E
inst✝⁸ : Module 𝕜 F
inst✝⁷ : Module E F
inst✝⁶ : IsScalarTower 𝕜 E F
inst✝⁵ : SMulCommClass 𝕜 E F
inst✝⁴ : OrderedSMul 𝕜 E
inst✝³ : OrderedSMul 𝕜 F
inst✝² : OrderedSMul E F
s : Set 𝕜
f✝ : 𝕜 → E
g✝ : 𝕜 → F
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
f g : 𝕜 → E
hf : ConvexOn 𝕜 s f
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ f x
n : ℕ
⊢ ConvexOn 𝕜 s (f * f ^ n)
state_after: no goals
tactic: exact hf.mul (hf.pow hf₀ _) hf₀ (fun x hx ↦ pow_nonneg (hf₀ hx) _) <|
      (monovaryOn_self f s).pow_right₀ hf₀ n
Theorem: iInter_Iio_of_not_bddBelow_range
File: Mathlib/Order/Interval/Set/Disjoint.lean

Proof steps:
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) = ∅
state_after: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) ⊆ ∅
tactic: refine eq_empty_of_subset_empty ?_
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) ⊆ ∅
state_after: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) ⊆ ⋂ i, Iic (f i)
tactic: rw [← iInter_Iic_eq_empty_iff.mpr hf]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
⊢ ⋂ i, Iio (f i) ⊆ ⋂ i, Iic (f i)
state_after: case h
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
i✝ : ι
⊢ Iio (f i✝) ⊆ Iic (f i✝)
tactic: gcongr
state_before: case h
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
hf : ¬BddBelow (range f)
i✝ : ι
⊢ Iio (f i✝) ⊆ Iic (f i✝)
state_after: no goals
tactic: exact Iio_subset_Iic_self
Theorem: Complex.cos_eq_neg_one_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

Proof steps:
state_before: x : ℂ
⊢ cos x = -1 ↔ ∃ k, ↑π + ↑k * (2 * ↑π) = x
state_after: x : ℂ
⊢ (∃ k, ↑k * (2 * ↑π) = x - ↑π) ↔ ∃ k, ↑π + ↑k * (2 * ↑π) = x
tactic: rw [← neg_eq_iff_eq_neg, ← cos_sub_pi, cos_eq_one_iff]
state_before: x : ℂ
⊢ (∃ k, ↑k * (2 * ↑π) = x - ↑π) ↔ ∃ k, ↑π + ↑k * (2 * ↑π) = x
state_after: no goals
tactic: simp only [eq_sub_iff_add_eq']
Theorem: Finsupp.equivFunOnFinite_symm_single
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
a a' : α
b : M
inst✝¹ : DecidableEq α
inst✝ : Finite α
x : α
m : M
⊢ equivFunOnFinite.symm (Pi.single x m) = single x m
state_after: no goals
tactic: rw [← equivFunOnFinite_single, Equiv.symm_apply_apply]
Theorem: iff_left_comm
File: Mathlib/Logic/Lemmas.lean

Proof steps:
state_before: a b c : Prop
⊢ (a ↔ (b ↔ c)) ↔ (b ↔ (a ↔ c))
state_after: no goals
tactic: tauto
Theorem: Nat.toDigitsCore_lens_eq
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b f : ℕ
⊢ ∀ (n : ℕ) (c : Char) (tl : List Char), (b.toDigitsCore f n (c :: tl)).length = (b.toDigitsCore f n tl).length + 1
state_after: no goals
tactic: induction f with (intro n c tl; simp only [Nat.toDigitsCore, List.length])
  | succ f ih =>
    if hnb : (n / b) = 0 then
      simp only [hnb, if_true, List.length]
    else
      generalize hx : Nat.digitChar (n % b) = x
      simp only [hx, hnb, if_false] at ih
      simp only [hnb, if_false]
      specialize ih (n / b) c (x :: tl)
      rw [← ih]
      have lens_eq : (x :: (c :: tl)).length = (c :: x :: tl).length := by simp
      apply toDigitsCore_lens_eq_aux
      exact lens_eq
Theorem: WittVector.discreteValuationRing
File: Mathlib/RingTheory/WittVector/DiscreteValuationRing.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
⊢ DiscreteValuationRing.HasUnitMulPowIrreducibleFactorization (𝕎 k)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
x : 𝕎 k
hx : x ≠ 0
⊢ ∃ n, Associated (↑p ^ n) x
tactic: refine ⟨p, irreducible p, fun {x} hx => ?_⟩
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
x : 𝕎 k
hx : x ≠ 0
⊢ ∃ n, Associated (↑p ^ n) x
state_after: case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
x : 𝕎 k
hx : x ≠ 0
n : ℕ
b : (𝕎 k)ˣ
hb : x = ↑p ^ n * ↑b
⊢ ∃ n, Associated (↑p ^ n) x
tactic: obtain ⟨n, b, hb⟩ := exists_eq_pow_p_mul' x hx
state_before: case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
x : 𝕎 k
hx : x ≠ 0
n : ℕ
b : (𝕎 k)ˣ
hb : x = ↑p ^ n * ↑b
⊢ ∃ n, Associated (↑p ^ n) x
state_after: no goals
tactic: exact ⟨n, b, hb.symm⟩
Theorem: Cycle.Chain.eq_nil_of_irrefl
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsIrrefl α r
h : Chain r s
⊢ s = Cycle.nil
state_after: case H0
α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsIrrefl α r
h : Chain r Cycle.nil
⊢ Cycle.nil = Cycle.nil

case HI
α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsIrrefl α r
a : α
l : List α
a✝ : Chain r ↑l → ↑l = Cycle.nil
h : Chain r ↑(a :: l)
⊢ ↑(a :: l) = Cycle.nil
tactic: induction' s with a l _ h
Theorem: monovary_inv₀
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemifield α
inst✝ : LinearOrderedSemifield β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
hf : StrongLT 0 f
hg : StrongLT 0 g
⊢ Monovary f⁻¹ g⁻¹ ↔ Monovary f g
state_after: no goals
tactic: rw [monovary_inv_left₀ hf, antivary_inv_right₀ hg]
Theorem: CategoryTheory.LaxMonoidalFunctor.left_unitality_inv
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X : C
⊢ (λ_ (F.obj X)).inv ≫ F.ε ▷ F.obj X ≫ F.μ (𝟙_ C) X = F.map (λ_ X).inv
state_after: no goals
tactic: rw [Iso.inv_comp_eq, F.left_unitality, Category.assoc, Category.assoc, ← F.toFunctor.map_comp,
    Iso.hom_inv_id, F.toFunctor.map_id, comp_id]
Theorem: Nat.cast_div
File: Mathlib/Data/Nat/Cast/Field.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DivisionSemiring α
m n : ℕ
n_dvd : n ∣ m
hn : ↑n ≠ 0
⊢ ↑(m / n) = ↑m / ↑n
state_after: case intro
α : Type u_1
inst✝ : DivisionSemiring α
n : ℕ
hn : ↑n ≠ 0
k : ℕ
⊢ ↑(n * k / n) = ↑(n * k) / ↑n
tactic: rcases n_dvd with ⟨k, rfl⟩
state_before: case intro
α : Type u_1
inst✝ : DivisionSemiring α
n : ℕ
hn : ↑n ≠ 0
k : ℕ
⊢ ↑(n * k / n) = ↑(n * k) / ↑n
state_after: case intro
α : Type u_1
inst✝ : DivisionSemiring α
n : ℕ
hn : ↑n ≠ 0
k : ℕ
this : n ≠ 0
⊢ ↑(n * k / n) = ↑(n * k) / ↑n
tactic: have : n ≠ 0 := by rintro rfl; simp at hn
state_before: case intro
α : Type u_1
inst✝ : DivisionSemiring α
n : ℕ
hn : ↑n ≠ 0
k : ℕ
this : n ≠ 0
⊢ ↑(n * k / n) = ↑(n * k) / ↑n
state_after: no goals
tactic: rw [Nat.mul_div_cancel_left _ <| zero_lt_of_ne_zero this, mul_comm n,
    cast_mul, mul_div_cancel_right₀ _ hn]
Theorem: Finset.card_singleton_inter
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
⊢ ({a} ∩ s).card ≤ 1
state_after: case isFalse
α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∉ s
⊢ ({a} ∩ s).card ≤ 1

case isTrue
α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∈ s
⊢ ({a} ∩ s).card ≤ 1
tactic: cases' Finset.decidableMem a s with h h
Theorem: OrderIso.isCoatomic_iff
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderTop α
inst✝ : OrderTop β
f : α ≃o β
⊢ IsCoatomic α ↔ IsCoatomic β
state_after: no goals
tactic: simp only [← isAtomic_dual_iff_isCoatomic, f.dual.isAtomic_iff]
Theorem: Set.isWF_insert
File: Mathlib/Order/WellFoundedSet.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a : α
⊢ (insert a s).IsWF ↔ s.IsWF
state_after: no goals
tactic: simp only [← singleton_union, isWF_union, isWF_singleton, true_and_iff]