ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: stdSimplex_unique
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : Fintype ι
inst✝ : Unique ι
⊢ stdSimplex 𝕜 ι = {fun x => 1}
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : Fintype ι
inst✝ : Unique ι
⊢ ∀ x ∈ stdSimplex 𝕜 ι, x = fun x => 1
tactic: refine eq_singleton_iff_unique_mem.2 ⟨⟨fun _ ↦ zero_le_one, Fintype.sum_unique _⟩, ?_⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : Fintype ι
inst✝ : Unique ι
⊢ ∀ x ∈ stdSimplex 𝕜 ι, x = fun x => 1
state_after: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : Fintype ι
inst✝ : Unique ι
f : ι → 𝕜
hf : ∑ x : ι, f x = 1
⊢ f = fun x => 1
tactic: rintro f ⟨-, hf⟩
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : Fintype ι
inst✝ : Unique ι
f : ι → 𝕜
hf : ∑ x : ι, f x = 1
⊢ f = fun x => 1
state_after: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : Fintype ι
inst✝ : Unique ι
f : ι → 𝕜
hf : f default = 1
⊢ f = fun x => 1
tactic: rw [Fintype.sum_unique] at hf
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : Fintype ι
inst✝ : Unique ι
f : ι → 𝕜
hf : f default = 1
⊢ f = fun x => 1
state_after: no goals
tactic: exact funext (Unique.forall_iff.2 hf)
Theorem: Submodule.IsOrtho.map_iff
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E ≃ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : Submodule.map f U ⟂ Submodule.map f V
⊢ U ⟂ V
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E ≃ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : Submodule.map f U ⟂ Submodule.map f V
hf : ∀ (p : Submodule 𝕜 E), Submodule.comap f.toLinearIsometry (Submodule.map f p) = p
⊢ U ⟂ V
tactic: have hf : ∀ p : Submodule 𝕜 E, (p.map f).comap f.toLinearIsometry = p :=
      comap_map_eq_of_injective f.injective
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E ≃ₗᵢ[𝕜] F
U V : Submodule 𝕜 E
h : Submodule.map f U ⟂ Submodule.map f V
hf : ∀ (p : Submodule 𝕜 E), Submodule.comap f.toLinearIsometry (Submodule.map f p) = p
⊢ U ⟂ V
state_after: no goals
tactic: simpa only [hf] using h.comap f.toLinearIsometry
Theorem: IsLocalizedModule.mk'_one
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
⊢ mk' f m 1 = f m
state_after: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
⊢ (fromLocalizedModule S f) (LocalizedModule.mk m 1) = f m
tactic: delta mk'
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
⊢ (fromLocalizedModule S f) (LocalizedModule.mk m 1) = f m
state_after: no goals
tactic: rw [fromLocalizedModule_mk, Module.End_algebraMap_isUnit_inv_apply_eq_iff, Submonoid.coe_one,
    one_smul]
Theorem: nilpotent_iff_mem_prime
File: Mathlib/RingTheory/Nilpotent/Lemmas.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x✝ y✝ : R
inst✝ : CommSemiring R
x y : R
⊢ IsNilpotent x ↔ ∀ (J : Ideal R), J.IsPrime → x ∈ J
state_after: R : Type u_1
S : Type u_2
x✝ y✝ : R
inst✝ : CommSemiring R
x y : R
⊢ (∀ p ∈ {J | J.IsPrime}, x ∈ p) ↔ ∀ (J : Ideal R), J.IsPrime → x ∈ J
tactic: rw [← mem_nilradical, nilradical_eq_sInf, Submodule.mem_sInf]
state_before: R : Type u_1
S : Type u_2
x✝ y✝ : R
inst✝ : CommSemiring R
x y : R
⊢ (∀ p ∈ {J | J.IsPrime}, x ∈ p) ↔ ∀ (J : Ideal R), J.IsPrime → x ∈ J
state_after: no goals
tactic: rfl
Theorem: Primrec.vector_ofFn
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin n → α → σ
hf : ∀ (i : Fin n), Primrec (f i)
⊢ Primrec fun a => (Vector.ofFn fun i => f i a).toList
state_after: no goals
tactic: simp [list_ofFn hf]
Theorem: Real.negMulLog_zero
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: ⊢ negMulLog 0 = 0
state_after: no goals
tactic: simp [negMulLog]
Theorem: IsPrimitiveRoot.injOn_pow_mul
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
M₀ : Type u_7
inst✝ : CancelCommMonoidWithZero M₀
n : ℕ
ζ : M₀
hζ : IsPrimitiveRoot ζ n
α : M₀
hα : α ≠ 0
i : ℕ
hi : i ∈ ↑(range n)
j : ℕ
hj : j ∈ ↑(range n)
e : (fun x => ζ ^ x * α) i = (fun x => ζ ^ x * α) j
⊢ (fun x => ζ ^ x) i = (fun x => ζ ^ x) j
state_after: no goals
tactic: simpa [mul_eq_mul_right_iff, or_iff_left hα] using e
Theorem: Real.Angle.two_zsmul_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ 2 • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π
state_after: no goals
tactic: rw [← not_or, ← two_zsmul_eq_zero_iff]
Theorem: Real.log_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝ z : ℝ
n : ℕ
x : ℝ
hx : 0 < x
y : ℝ
⊢ log (x ^ y) = y * log x
state_after: case a
x✝ y✝ z : ℝ
n : ℕ
x : ℝ
hx : 0 < x
y : ℝ
⊢ rexp (log (x ^ y)) = rexp (y * log x)
tactic: apply exp_injective
state_before: case a
x✝ y✝ z : ℝ
n : ℕ
x : ℝ
hx : 0 < x
y : ℝ
⊢ rexp (log (x ^ y)) = rexp (y * log x)
state_after: no goals
tactic: rw [exp_log (rpow_pos_of_pos hx y), ← exp_log hx, mul_comm, rpow_def_of_pos (exp_pos (log x)) y]
Theorem: MeasureTheory.IsFundamentalDomain.quotientMeasureEqMeasurePreimage
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace α
ν : Measure α
inst✝³ : Countable G
inst✝² : MeasurableSpace G
inst✝¹ : SMulInvariantMeasure G α ν
inst✝ : MeasurableSMul G α
μ : Measure (Quotient α_mod_G)
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
h : μ = Measure.map (Quotient.mk α_mod_G) (ν.restrict s)
⊢ QuotientMeasureEqMeasurePreimage ν μ
state_after: no goals
tactic: simpa [h] using fund_dom_s.quotientMeasureEqMeasurePreimage_quotientMeasure
Theorem: Option.map₂_map_left
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
f : γ → β → δ
g : α → γ
⊢ map₂ f (Option.map g a) b = map₂ (fun a b => f (g a) b) a b
state_after: no goals
tactic: cases a <;> rfl
Theorem: InnerProductGeometry.angle_zero_right
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
⊢ angle x 0 = π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
⊢ arccos (⟪x, 0⟫_ℝ / (‖x‖ * ‖0‖)) = π / 2
tactic: unfold angle
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
⊢ arccos (⟪x, 0⟫_ℝ / (‖x‖ * ‖0‖)) = π / 2
state_after: no goals
tactic: rw [inner_zero_right, zero_div, Real.arccos_zero]
Theorem: Equiv.Perm.mem_finPairsLT
File: Mathlib/GroupTheory/Perm/Sign.lean

Proof steps:
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a : (_ : Fin n) × Fin n
⊢ a ∈ finPairsLT n ↔ a.snd < a.fst
state_after: no goals
tactic: simp only [finPairsLT, Fin.lt_iff_val_lt_val, true_and_iff, mem_attachFin, mem_range, mem_univ,
    mem_sigma]
Theorem: ENNReal.Ioo_zero_top_eq_iUnion_Ico_zpow
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
⊢ Ioo 0 ⊤ = ⋃ n, Ico (y ^ n) (y ^ (n + 1))
state_after: case h
a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0∞
⊢ x ∈ Ioo 0 ⊤ ↔ x ∈ ⋃ n, Ico (y ^ n) (y ^ (n + 1))
tactic: ext x
state_before: case h
a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0∞
⊢ x ∈ Ioo 0 ⊤ ↔ x ∈ ⋃ n, Ico (y ^ n) (y ^ (n + 1))
state_after: case h
a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0∞
⊢ 0 < x ∧ x < ⊤ ↔ ∃ i, y ^ i ≤ x ∧ x < y ^ (i + 1)
tactic: simp only [mem_iUnion, mem_Ioo, mem_Ico]
state_before: case h
a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0∞
⊢ 0 < x ∧ x < ⊤ ↔ ∃ i, y ^ i ≤ x ∧ x < y ^ (i + 1)
state_after: case h.mp
a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0∞
⊢ 0 < x ∧ x < ⊤ → ∃ i, y ^ i ≤ x ∧ x < y ^ (i + 1)

case h.mpr
a b c d : ℝ≥0∞
r p q : ℝ≥0
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0∞
⊢ (∃ i, y ^ i ≤ x ∧ x < y ^ (i + 1)) → 0 < x ∧ x < ⊤
tactic: constructor
Theorem: ProbabilityTheory.Kernel.withDensity_of_not_measurable
File: Mathlib/Probability/Kernel/WithDensity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf : ¬Measurable (Function.uncurry f)
⊢ κ.withDensity f = 0
state_after: no goals
tactic: classical exact dif_neg hf
Theorem: CategoryTheory.Localization.SmallHom.comp_assoc
File: Mathlib/CategoryTheory/Localization/SmallHom.lean

Proof steps:
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁷ : Category.{v₂, u₂} D
D' : Type u₃
inst✝⁶ : Category.{v₃, u₃} D'
X Y Z T : C
inst✝⁵ : HasSmallLocalizedHom W X Y
inst✝⁴ : HasSmallLocalizedHom W X Z
inst✝³ : HasSmallLocalizedHom W X T
inst✝² : HasSmallLocalizedHom W Y Z
inst✝¹ : HasSmallLocalizedHom W Y T
inst✝ : HasSmallLocalizedHom W Z T
α : SmallHom W X Y
β : SmallHom W Y Z
γ : SmallHom W Z T
⊢ (α.comp β).comp γ = α.comp (β.comp γ)
state_after: case a
C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁷ : Category.{v₂, u₂} D
D' : Type u₃
inst✝⁶ : Category.{v₃, u₃} D'
X Y Z T : C
inst✝⁵ : HasSmallLocalizedHom W X Y
inst✝⁴ : HasSmallLocalizedHom W X Z
inst✝³ : HasSmallLocalizedHom W X T
inst✝² : HasSmallLocalizedHom W Y Z
inst✝¹ : HasSmallLocalizedHom W Y T
inst✝ : HasSmallLocalizedHom W Z T
α : SmallHom W X Y
β : SmallHom W Y Z
γ : SmallHom W Z T
⊢ (equiv W W.Q) ((α.comp β).comp γ) = (equiv W W.Q) (α.comp (β.comp γ))
tactic: apply (equiv W W.Q).injective
state_before: case a
C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁷ : Category.{v₂, u₂} D
D' : Type u₃
inst✝⁶ : Category.{v₃, u₃} D'
X Y Z T : C
inst✝⁵ : HasSmallLocalizedHom W X Y
inst✝⁴ : HasSmallLocalizedHom W X Z
inst✝³ : HasSmallLocalizedHom W X T
inst✝² : HasSmallLocalizedHom W Y Z
inst✝¹ : HasSmallLocalizedHom W Y T
inst✝ : HasSmallLocalizedHom W Z T
α : SmallHom W X Y
β : SmallHom W Y Z
γ : SmallHom W Z T
⊢ (equiv W W.Q) ((α.comp β).comp γ) = (equiv W W.Q) (α.comp (β.comp γ))
state_after: no goals
tactic: simp only [equiv_comp, assoc]
Theorem: Poly.induction
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
C : Poly α → Prop
H1 : ∀ (i : α), C (proj i)
H2 : ∀ (n : ℤ), C (const n)
H3 : ∀ (f g : Poly α), C f → C g → C (f - g)
H4 : ∀ (f g : Poly α), C f → C g → C (f * g)
f : Poly α
⊢ C f
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
C : Poly α → Prop
H1 : ∀ (i : α), C (proj i)
H2 : ∀ (n : ℤ), C (const n)
H3 : ∀ (f g : Poly α), C f → C g → C (f - g)
H4 : ∀ (f g : Poly α), C f → C g → C (f * g)
f : (α → ℕ) → ℤ
pf : IsPoly f
⊢ C ⟨f, pf⟩
tactic: cases' f with f pf
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
C : Poly α → Prop
H1 : ∀ (i : α), C (proj i)
H2 : ∀ (n : ℤ), C (const n)
H3 : ∀ (f g : Poly α), C f → C g → C (f - g)
H4 : ∀ (f g : Poly α), C f → C g → C (f * g)
f : (α → ℕ) → ℤ
pf : IsPoly f
⊢ C ⟨f, pf⟩
state_after: case mk.proj
α : Type u_1
β : Type u_2
γ : Type u_3
C : Poly α → Prop
H1 : ∀ (i : α), C (proj i)
H2 : ∀ (n : ℤ), C (const n)
H3 : ∀ (f g : Poly α), C f → C g → C (f - g)
H4 : ∀ (f g : Poly α), C f → C g → C (f * g)
f : (α → ℕ) → ℤ
i : α
⊢ C ⟨fun x => ↑(x i), ⋯⟩

case mk.const
α : Type u_1
β : Type u_2
γ : Type u_3
C : Poly α → Prop
H1 : ∀ (i : α), C (proj i)
H2 : ∀ (n : ℤ), C (const n)
H3 : ∀ (f g : Poly α), C f → C g → C (f - g)
H4 : ∀ (f g : Poly α), C f → C g → C (f * g)
f : (α → ℕ) → ℤ
n : ℤ
⊢ C ⟨fun x => n, ⋯⟩

case mk.sub
α : Type u_1
β : Type u_2
γ : Type u_3
C : Poly α → Prop
H1 : ∀ (i : α), C (proj i)
H2 : ∀ (n : ℤ), C (const n)
H3 : ∀ (f g : Poly α), C f → C g → C (f - g)
H4 : ∀ (f g : Poly α), C f → C g → C (f * g)
f✝ f g : (α → ℕ) → ℤ
pf : IsPoly f
pg : IsPoly g
ihf : C ⟨f, pf⟩
ihg : C ⟨g, pg⟩
⊢ C ⟨fun x => f x - g x, ⋯⟩

case mk.mul
α : Type u_1
β : Type u_2
γ : Type u_3
C : Poly α → Prop
H1 : ∀ (i : α), C (proj i)
H2 : ∀ (n : ℤ), C (const n)
H3 : ∀ (f g : Poly α), C f → C g → C (f - g)
H4 : ∀ (f g : Poly α), C f → C g → C (f * g)
f✝ f g : (α → ℕ) → ℤ
pf : IsPoly f
pg : IsPoly g
ihf : C ⟨f, pf⟩
ihg : C ⟨g, pg⟩
⊢ C ⟨fun x => f x * g x, ⋯⟩
tactic: induction' pf with i n f g pf pg ihf ihg f g pf pg ihf ihg
Theorem: CategoryTheory.Limits.Pi.map_comp_map
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f g h : α → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
q : (a : α) → f a ⟶ g a
q' : (a : α) → g a ⟶ h a
⊢ map q ≫ map q' = map fun a => q a ≫ q' a
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f g h : α → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
q : (a : α) → f a ⟶ g a
q' : (a : α) → g a ⟶ h a
b✝ : α
⊢ (map q ≫ map q') ≫ π h b✝ = (map fun a => q a ≫ q' a) ≫ π h b✝
tactic: ext
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f g h : α → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
q : (a : α) → f a ⟶ g a
q' : (a : α) → g a ⟶ h a
b✝ : α
⊢ (map q ≫ map q') ≫ π h b✝ = (map fun a => q a ≫ q' a) ≫ π h b✝
state_after: no goals
tactic: simp
Theorem: eVariationOn.constant_on
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : (f '' s).Subsingleton
⊢ eVariationOn f s = 0
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : (f '' s).Subsingleton
⊢ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) = 0
tactic: rw [eq_zero_iff]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : (f '' s).Subsingleton
⊢ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) = 0
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : (f '' s).Subsingleton
x : α
xs : x ∈ s
y : α
ys : y ∈ s
⊢ edist (f x) (f y) = 0
tactic: rintro x xs y ys
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : (f '' s).Subsingleton
x : α
xs : x ∈ s
y : α
ys : y ∈ s
⊢ edist (f x) (f y) = 0
state_after: no goals
tactic: rw [hf ⟨x, xs, rfl⟩ ⟨y, ys, rfl⟩, edist_self]
Theorem: CircleDeg1Lift.tendsto_translation_number₀'
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
⊢ Tendsto (fun n => (f ^ (n + 1)) 0 / (↑n + 1)) atTop (𝓝 (τ f))
state_after: f g : CircleDeg1Lift
n : ℕ
⊢ dist ((f ^ (n + 1)) 0 / (↑n + 1)) (τ f) ≤ ((fun n => 1 / ↑n) ∘ fun a => a + 1) n
tactic: refine
    tendsto_iff_dist_tendsto_zero.2 <|
      squeeze_zero (fun _ => dist_nonneg) (fun n => ?_)
        ((tendsto_const_div_atTop_nhds_zero_nat 1).comp (tendsto_add_atTop_nat 1))
state_before: f g : CircleDeg1Lift
n : ℕ
⊢ dist ((f ^ (n + 1)) 0 / (↑n + 1)) (τ f) ≤ ((fun n => 1 / ↑n) ∘ fun a => a + 1) n
state_after: f g : CircleDeg1Lift
n : ℕ
⊢ dist ((f ^ (n + 1)) 0 / (↑n + 1)) (τ f) ≤ 1 / ↑(n + 1)
tactic: dsimp
state_before: f g : CircleDeg1Lift
n : ℕ
⊢ dist ((f ^ (n + 1)) 0 / (↑n + 1)) (τ f) ≤ 1 / ↑(n + 1)
state_after: f g : CircleDeg1Lift
n : ℕ
this : 0 < ↑n + 1
⊢ dist ((f ^ (n + 1)) 0 / (↑n + 1)) (τ f) ≤ 1 / ↑(n + 1)
tactic: have : (0 : ℝ) < n + 1 := n.cast_add_one_pos
state_before: f g : CircleDeg1Lift
n : ℕ
this : 0 < ↑n + 1
⊢ dist ((f ^ (n + 1)) 0 / (↑n + 1)) (τ f) ≤ 1 / ↑(n + 1)
state_after: f g : CircleDeg1Lift
n : ℕ
this : 0 < ↑n + 1
⊢ dist ((f ^ (n + 1)) 0) (↑(n + 1) * τ f) ≤ 1
tactic: rw [Real.dist_eq, div_sub' _ _ _ (ne_of_gt this), abs_div, ← Real.dist_eq, abs_of_pos this,
    Nat.cast_add_one, div_le_div_right this, ← Nat.cast_add_one]
state_before: f g : CircleDeg1Lift
n : ℕ
this : 0 < ↑n + 1
⊢ dist ((f ^ (n + 1)) 0) (↑(n + 1) * τ f) ≤ 1
state_after: no goals
tactic: apply dist_pow_map_zero_mul_translationNumber_le
Theorem: Int.div_dvd_iff_dvd_mul
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d✝ m n : ℤ
h : b ∣ a
hb : b ≠ 0
d : ℤ
⊢ c = a / b * d ↔ b * c = a * d
state_after: a b c d✝ m n : ℤ
h : b ∣ a
hb : b ≠ 0
d : ℤ
this : b ∣ d * a
⊢ c = a / b * d ↔ b * c = a * d
tactic: have := Int.dvd_trans (Int.dvd_mul_left _ _) (Int.mul_dvd_mul_left d h)
state_before: a b c d✝ m n : ℤ
h : b ∣ a
hb : b ≠ 0
d : ℤ
this : b ∣ d * a
⊢ c = a / b * d ↔ b * c = a * d
state_after: no goals
tactic: rw [eq_comm, Int.mul_comm, ← Int.mul_ediv_assoc d h, Int.ediv_eq_iff_eq_mul_right hb this,
    Int.mul_comm, eq_comm]
Theorem: Multiset.sum_bind
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s✝ t✝ : Multiset α
f g : α → Multiset β
inst✝ : CommMonoid β
s : Multiset α
t : α → Multiset β
⊢ (s.bind t).prod = (map (fun a => (t a).prod) s).prod
state_after: no goals
tactic: simp [bind]
Theorem: Finset.Ioc_subset_Ioo_right
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b₁ < b₂
⊢ Ioc a b₁ ⊆ Ioo a b₂
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b₁ < b₂
⊢ Set.Ioc a b₁ ⊆ Set.Ioo a b₂
tactic: rw [← coe_subset, coe_Ioc, coe_Ioo]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b₁ < b₂
⊢ Set.Ioc a b₁ ⊆ Set.Ioo a b₂
state_after: no goals
tactic: exact Set.Ioc_subset_Ioo_right h
Theorem: AddMonoidAlgebra.lift_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝⁵ : CommSemiring k
inst✝⁴ : AddMonoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type u_3
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : Multiplicative G →* A
f : MonoidAlgebra k G
⊢ ((lift k G A) F) f = sum f fun a b => b • F (Multiplicative.ofAdd a)
state_after: no goals
tactic: simp only [lift_apply', Algebra.smul_def]
Theorem: CategoryTheory.ShortComplex.Splitting.mono_f
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.78745, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
⊢ Mono S.f
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.78745, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
this : IsSplitMono S.f
⊢ Mono S.f
tactic: have := s.isSplitMono_f
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.78745, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
this : IsSplitMono S.f
⊢ Mono S.f
state_after: no goals
tactic: infer_instance
Theorem: Int.le_of_eq
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a✝ b✝ c✝ d m n a b c : ℤ
hab : a = b
⊢ a ≤ b
state_after: a✝ b✝ c✝ d m n a b c : ℤ
hab : a = b
⊢ b ≤ b
tactic: rw [hab]
state_before: a✝ b✝ c✝ d m n a b c : ℤ
hab : a = b
⊢ b ≤ b
state_after: no goals
tactic: exact Int.le_rfl
Theorem: seminormFromBounded_one
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_ne_zero : f ≠ 0
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
⊢ seminormFromBounded' f 1 = 1
state_after: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_ne_zero : f ≠ 0
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
⊢ ⨆ y, f y / f y = 1
tactic: simp_rw [seminormFromBounded', one_mul]
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_ne_zero : f ≠ 0
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
⊢ ⨆ y, f y / f y = 1
state_after: case a
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_ne_zero : f ≠ 0
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
⊢ ⨆ y, f y / f y ≤ 1

case a
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_ne_zero : f ≠ 0
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
⊢ 1 ≤ ⨆ y, f y / f y
tactic: apply le_antisymm
Theorem: pNilradical_eq_bot_of_frobenius_inj
File: Mathlib/FieldTheory/IsPerfectClosure.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
p : ℕ
inst✝ : ExpChar R p
h : Function.Injective ⇑(frobenius R p)
x : R
⊢ x ∈ pNilradical R p → x ∈ ⊥
state_after: R : Type u_1
inst✝¹ : CommRing R
p : ℕ
inst✝ : ExpChar R p
h : Function.Injective ⇑(frobenius R p)
x : R
⊢ (∃ n, x ^ p ^ n = 0) → x = 0
tactic: rw [mem_pNilradical, Ideal.mem_bot]
state_before: R : Type u_1
inst✝¹ : CommRing R
p : ℕ
inst✝ : ExpChar R p
h : Function.Injective ⇑(frobenius R p)
x : R
⊢ (∃ n, x ^ p ^ n = 0) → x = 0
state_after: no goals
tactic: exact fun ⟨n, _⟩ ↦ h.iterate n (by rwa [← coe_iterateFrobenius, map_zero])
Theorem: Metric.hausdorffDist_nonneg
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ 0 ≤ hausdorffDist s t
state_after: no goals
tactic: simp [hausdorffDist]