ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PartialHomeomorph.extend_target'
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
⊢ (f.extend I).target = ↑I '' f.target
state_after: no goals
tactic: rw [extend, PartialEquiv.trans_target'', I.source_eq, univ_inter, I.toPartialEquiv_coe]
Theorem: Partrec.dom_re
File: Mathlib/Computability/Halting.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
f : α →. β
h : Partrec f
n : α
x✝ : Unit
⊢ x✝ ∈ Part.map (fun b => ()) (f n) ↔ x✝ ∈ Part.assert ((fun a => (f a).Dom) n) fun x => Part.some ()
state_after: no goals
tactic: simp [Part.dom_iff_mem]
Theorem: Finset.sum_add_distrib
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
⊢ ∏ x ∈ s, f x * g x = fold (fun x x_1 => x * x_1) (1 * 1) (fun x => f x * g x) s
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
⊢ ∏ x ∈ s, f x * g x = fold (fun x x_1 => x * x_1) 1 (fun x => f x * g x) s
tactic: rw [one_mul]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
⊢ ∏ x ∈ s, f x * g x = fold (fun x x_1 => x * x_1) 1 (fun x => f x * g x) s
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.Memℒp.inner_const
File: Mathlib/MeasureTheory/Function/L2Space.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
E : Type u_2
𝕜 : Type u_3
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
f : α → E
hf : Memℒp f p μ
c : E
x : α
⊢ ‖⟪f x, c⟫_𝕜‖ ≤ ?m.10083 * ‖f x‖
state_after: α : Type u_1
m : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
E : Type u_2
𝕜 : Type u_3
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
f : α → E
hf : Memℒp f p μ
c : E
x : α
⊢ ‖⟪f x, c⟫_𝕜‖ ≤ ‖f x‖ * ?m.10603
tactic: rw [mul_comm]
state_before: α : Type u_1
m : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
E : Type u_2
𝕜 : Type u_3
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
f : α → E
hf : Memℒp f p μ
c : E
x : α
⊢ ‖⟪f x, c⟫_𝕜‖ ≤ ‖f x‖ * ?m.10603
state_after: no goals
tactic: exact norm_inner_le_norm _ _
Theorem: Finset.nsmul_subset_nsmul_of_zero_mem
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n : ℕ
hs : 1 ∈ s
⊢ m ≤ n → s ^ m ⊆ s ^ n
state_after: case base
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n : ℕ
hs : 1 ∈ s
⊢ s ^ m ⊆ s ^ m

case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n : ℕ
hs : 1 ∈ s
⊢ ∀ (n : ℕ), m ≤ n → s ^ m ⊆ s ^ n → s ^ m ⊆ s ^ (n + 1)
tactic: apply Nat.le_induction
Theorem: Valued.cauchy_iff
File: Mathlib/Topology/Algebra/Valued/ValuationTopology.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ Cauchy F ↔ F.NeBot ∧ ∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ
state_after: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (F.NeBot ∧ ∀ U ∈ RingFilterBasis.toAddGroupFilterBasis, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U) ↔
    F.NeBot ∧ ∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ
tactic: rw [toUniformSpace_eq, AddGroupFilterBasis.cauchy_iff]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (F.NeBot ∧ ∀ U ∈ RingFilterBasis.toAddGroupFilterBasis, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U) ↔
    F.NeBot ∧ ∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ
state_after: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ U ∈ RingFilterBasis.toAddGroupFilterBasis, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U) ↔
    ∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ
tactic: apply and_congr Iff.rfl
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ U ∈ RingFilterBasis.toAddGroupFilterBasis, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U) ↔
    ∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ
state_after: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ (U : Set R), (∃ i, U = ↑(v.ltAddSubgroup i)) → ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U) ↔
    ∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ
tactic: simp_rw [Valued.v.subgroups_basis.mem_addGroupFilterBasis_iff]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ (U : Set R), (∃ i, U = ↑(v.ltAddSubgroup i)) → ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U) ↔
    ∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ
state_after: case mp
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ (U : Set R), (∃ i, U = ↑(v.ltAddSubgroup i)) → ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U) →
    ∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ

case mpr
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ (γ : Γ₀ˣ), ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, v (y - x) < ↑γ) →
    ∀ (U : Set R), (∃ i, U = ↑(v.ltAddSubgroup i)) → ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
tactic: constructor
Theorem: Nat.cond_decide_mod_two
File: Mathlib/Init/Data/Nat/Lemmas.lean

Proof steps:
state_before: x : ℕ
d : Decidable (x % 2 = 1)
⊢ (bif decide (x % 2 = 1) then 1 else 0) = x % 2
state_after: case pos
x : ℕ
d : Decidable (x % 2 = 1)
h : x % 2 = 1
⊢ (bif decide (x % 2 = 1) then 1 else 0) = x % 2

case neg
x : ℕ
d : Decidable (x % 2 = 1)
h : ¬x % 2 = 1
⊢ (bif decide (x % 2 = 1) then 1 else 0) = x % 2
tactic: by_cases h : x % 2 = 1
Theorem: WittVector.frobenius_frobeniusRotation
File: Mathlib/RingTheory/WittVector/FrobeniusFractionField.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : IsAlgClosed k
a₁ a₂ : 𝕎 k
ha₁ : a₁.coeff 0 ≠ 0
ha₂ : a₂.coeff 0 ≠ 0
⊢ frobenius (frobeniusRotation p ha₁ ha₂) * a₁ = frobeniusRotation p ha₁ ha₂ * a₂
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : IsAlgClosed k
a₁ a₂ : 𝕎 k
ha₁ : a₁.coeff 0 ≠ 0
ha₂ : a₂.coeff 0 ≠ 0
n : ℕ
⊢ (frobenius (frobeniusRotation p ha₁ ha₂) * a₁).coeff n = (frobeniusRotation p ha₁ ha₂ * a₂).coeff n
tactic: ext n
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : IsAlgClosed k
a₁ a₂ : 𝕎 k
ha₁ : a₁.coeff 0 ≠ 0
ha₂ : a₂.coeff 0 ≠ 0
n : ℕ
⊢ (frobenius (frobeniusRotation p ha₁ ha₂) * a₁).coeff n = (frobeniusRotation p ha₁ ha₂ * a₂).coeff n
state_after: case h.zero
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : IsAlgClosed k
a₁ a₂ : 𝕎 k
ha₁ : a₁.coeff 0 ≠ 0
ha₂ : a₂.coeff 0 ≠ 0
⊢ (frobenius (frobeniusRotation p ha₁ ha₂) * a₁).coeff 0 = (frobeniusRotation p ha₁ ha₂ * a₂).coeff 0

case h.succ
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : IsAlgClosed k
a₁ a₂ : 𝕎 k
ha₁ : a₁.coeff 0 ≠ 0
ha₂ : a₂.coeff 0 ≠ 0
n : ℕ
⊢ (frobenius (frobeniusRotation p ha₁ ha₂) * a₁).coeff (n + 1) = (frobeniusRotation p ha₁ ha₂ * a₂).coeff (n + 1)
tactic: cases' n with n
Theorem: MeasureTheory.SimpleFunc.lintegral_eq_of_subset
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
s : Finset ℝ≥0∞
hs : ∀ (x : α), ↑f x ≠ 0 → μ (↑f ⁻¹' {↑f x}) ≠ 0 → ↑f x ∈ s
⊢ f.lintegral μ = ∑ x ∈ s, x * μ (↑f ⁻¹' {x})
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
s : Finset ℝ≥0∞
hs : ∀ (x : α), ↑f x ≠ 0 → μ (↑f ⁻¹' {↑f x}) ≠ 0 → ↑f x ∈ s
⊢ ∀ (a : ℝ≥0∞) (h₁ : a ∈ f.range) (h₂ : a * μ (↑f ⁻¹' {a}) ≠ 0), (fun r x x => r) a h₁ h₂ ∈ s

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
s : Finset ℝ≥0∞
hs : ∀ (x : α), ↑f x ≠ 0 → μ (↑f ⁻¹' {↑f x}) ≠ 0 → ↑f x ∈ s
⊢ ∀ (a₁ : ℝ≥0∞) (h₁₁ : a₁ ∈ f.range) (h₁₂ : a₁ * μ (↑f ⁻¹' {a₁}) ≠ 0) (a₂ : ℝ≥0∞) (h₂₁ : a₂ ∈ f.range)
    (h₂₂ : a₂ * μ (↑f ⁻¹' {a₂}) ≠ 0), (fun r x x => r) a₁ h₁₁ h₁₂ = (fun r x x => r) a₂ h₂₁ h₂₂ → a₁ = a₂

case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
s : Finset ℝ≥0∞
hs : ∀ (x : α), ↑f x ≠ 0 → μ (↑f ⁻¹' {↑f x}) ≠ 0 → ↑f x ∈ s
⊢ ∀ b ∈ s,
    b * μ (↑f ⁻¹' {b}) ≠ 0 → ∃ a, ∃ (h₁ : a ∈ f.range) (h₂ : a * μ (↑f ⁻¹' {a}) ≠ 0), (fun r x x => r) a h₁ h₂ = b

case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
s : Finset ℝ≥0∞
hs : ∀ (x : α), ↑f x ≠ 0 → μ (↑f ⁻¹' {↑f x}) ≠ 0 → ↑f x ∈ s
⊢ ∀ (a : ℝ≥0∞) (h₁ : a ∈ f.range) (h₂ : a * μ (↑f ⁻¹' {a}) ≠ 0),
    a * μ (↑f ⁻¹' {a}) = (fun r x x => r) a h₁ h₂ * μ (↑f ⁻¹' {(fun r x x => r) a h₁ h₂})
tactic: refine Finset.sum_bij_ne_zero (fun r _ _ => r) ?_ ?_ ?_ ?_
Theorem: Nat.mem_primeFactorsList'
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: n p : ℕ
⊢ p ∈ n.primeFactorsList ↔ Prime p ∧ p ∣ n ∧ n ≠ 0
state_after: no goals
tactic: cases n <;> simp [mem_primeFactorsList, *]
Theorem: ProbabilityTheory.Kernel.integral_density
File: Mathlib/Probability/Kernel/Disintegration/Density.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
⊢ ∫ (x : γ), κ.density ν a x s ∂ν a = ((κ a) (univ ×ˢ s)).toReal
state_after: no goals
tactic: rw [← integral_univ, setIntegral_density_of_measurableSet hκν 0 a hs MeasurableSet.univ]
Theorem: CategoryTheory.StructuredArrow.homMk'_mk_id
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : S ⟶ T.obj Y
⊢ mk f = mk ((mk f).hom ≫ T.map (𝟙 Y))
state_after: no goals
tactic: aesop_cat
Theorem: Mathlib.Vector.get_cons_succ
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
a : α
v : Vector α n
i : Fin n
⊢ (a ::ᵥ v).get i.succ = v.get i
state_after: no goals
tactic: rw [← get_tail_succ, tail_cons]
Theorem: AlgebraicIndependent.option_iff
File: Mathlib/RingTheory/AlgebraicIndependent.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a✝ b : R
hx : AlgebraicIndependent R x
a : A
⊢ (AlgebraicIndependent R fun o => o.elim a x) ↔ ¬_root_.IsAlgebraic (↥(adjoin R (range x))) a
state_after: ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a✝ b : R
hx : AlgebraicIndependent R x
a : A
⊢ Injective (⇑↑(Polynomial.aeval a) ∘ ⇑hx.mvPolynomialOptionEquivPolynomialAdjoin.toRingHom) ↔
    Injective ⇑(Polynomial.aeval a)
tactic: rw [algebraicIndependent_iff_injective_aeval, isAlgebraic_iff_not_injective, Classical.not_not, ←
    AlgHom.coe_toRingHom, ← hx.aeval_comp_mvPolynomialOptionEquivPolynomialAdjoin,
    RingHom.coe_comp]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a✝ b : R
hx : AlgebraicIndependent R x
a : A
⊢ Injective (⇑↑(Polynomial.aeval a) ∘ ⇑hx.mvPolynomialOptionEquivPolynomialAdjoin.toRingHom) ↔
    Injective ⇑(Polynomial.aeval a)
state_after: no goals
tactic: exact Injective.of_comp_iff' (Polynomial.aeval a)
    (mvPolynomialOptionEquivPolynomialAdjoin hx).bijective
Theorem: AddOreLocalization.universalAddHom_unique
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type ?u.138430
inst✝¹ : MulAction R X
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : ↥S →* Tˣ
hf : ∀ (s : ↥S), f ↑s = ↑(fS s)
φ : OreLocalization S R →* T
huniv : ∀ (r : R), φ (numeratorHom r) = f r
⊢ φ = universalMulHom f fS hf
state_after: case h
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type ?u.138430
inst✝¹ : MulAction R X
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : ↥S →* Tˣ
hf : ∀ (s : ↥S), f ↑s = ↑(fS s)
φ : OreLocalization S R →* T
huniv : ∀ (r : R), φ (numeratorHom r) = f r
x : OreLocalization S R
⊢ φ x = (universalMulHom f fS hf) x
tactic: ext x
state_before: case h
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type ?u.138430
inst✝¹ : MulAction R X
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : ↥S →* Tˣ
hf : ∀ (s : ↥S), f ↑s = ↑(fS s)
φ : OreLocalization S R →* T
huniv : ∀ (r : R), φ (numeratorHom r) = f r
x : OreLocalization S R
⊢ φ x = (universalMulHom f fS hf) x
state_after: case h.c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type ?u.138430
inst✝¹ : MulAction R X
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : ↥S →* Tˣ
hf : ∀ (s : ↥S), f ↑s = ↑(fS s)
φ : OreLocalization S R →* T
huniv : ∀ (r : R), φ (numeratorHom r) = f r
r : R
s : ↥S
⊢ φ (r /ₒ s) = (universalMulHom f fS hf) (r /ₒ s)
tactic: induction' x with r s
state_before: case h.c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type ?u.138430
inst✝¹ : MulAction R X
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : ↥S →* Tˣ
hf : ∀ (s : ↥S), f ↑s = ↑(fS s)
φ : OreLocalization S R →* T
huniv : ∀ (r : R), φ (numeratorHom r) = f r
r : R
s : ↥S
⊢ φ (r /ₒ s) = (universalMulHom f fS hf) (r /ₒ s)
state_after: no goals
tactic: rw [universalMulHom_apply, ← huniv r, numeratorHom_apply, ← one_mul (φ (r /ₒ s)), ←
    Units.val_one, ← mul_left_inv (fS s), Units.val_mul, mul_assoc, ← hf, ← huniv, ← φ.map_mul,
    numeratorHom_apply, OreLocalization.mul_cancel]
Theorem: MvPowerSeries.inv_eq_zero
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
h : φ⁻¹ = 0
⊢ (constantCoeff σ k) φ = 0
state_after: no goals
tactic: simpa using congr_arg (constantCoeff σ k) h
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
h : (constantCoeff σ k) φ = 0
n : σ →₀ ℕ
⊢ (coeff k n) φ⁻¹ = (coeff k n) 0
state_after: no goals
tactic: classical
      rw [coeff_inv]
      split_ifs <;>
        simp only [h, map_zero, zero_mul, inv_zero, neg_zero]
Theorem: ContinuousMultilinearMap.continuous_eval_const
File: Mathlib/Topology/Algebra/Module/Multilinear/Topology.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
E : ι → Type u_3
F : Type u_4
inst✝⁸ : NormedField 𝕜
inst✝⁷ : (i : ι) → TopologicalSpace (E i)
inst✝⁶ : (i : ι) → AddCommGroup (E i)
inst✝⁵ : (i : ι) → Module 𝕜 (E i)
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ∀ (i : ι), ContinuousSMul 𝕜 (E i)
x : (i : ι) → E i
⊢ Continuous fun p => p x
state_after: 𝕜 : Type u_1
ι : Type u_2
E : ι → Type u_3
F : Type u_4
inst✝⁸ : NormedField 𝕜
inst✝⁷ : (i : ι) → TopologicalSpace (E i)
inst✝⁶ : (i : ι) → AddCommGroup (E i)
inst✝⁵ : (i : ι) → Module 𝕜 (E i)
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ∀ (i : ι), ContinuousSMul 𝕜 (E i)
x : (i : ι) → E i
this : UniformSpace F := TopologicalAddGroup.toUniformSpace F
⊢ Continuous fun p => p x
tactic: letI := TopologicalAddGroup.toUniformSpace F
state_before: 𝕜 : Type u_1
ι : Type u_2
E : ι → Type u_3
F : Type u_4
inst✝⁸ : NormedField 𝕜
inst✝⁷ : (i : ι) → TopologicalSpace (E i)
inst✝⁶ : (i : ι) → AddCommGroup (E i)
inst✝⁵ : (i : ι) → Module 𝕜 (E i)
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ∀ (i : ι), ContinuousSMul 𝕜 (E i)
x : (i : ι) → E i
this : UniformSpace F := TopologicalAddGroup.toUniformSpace F
⊢ Continuous fun p => p x
state_after: 𝕜 : Type u_1
ι : Type u_2
E : ι → Type u_3
F : Type u_4
inst✝⁸ : NormedField 𝕜
inst✝⁷ : (i : ι) → TopologicalSpace (E i)
inst✝⁶ : (i : ι) → AddCommGroup (E i)
inst✝⁵ : (i : ι) → Module 𝕜 (E i)
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ∀ (i : ι), ContinuousSMul 𝕜 (E i)
x : (i : ι) → E i
this✝ : UniformSpace F := TopologicalAddGroup.toUniformSpace F
this : UniformAddGroup F
⊢ Continuous fun p => p x
tactic: haveI := comm_topologicalAddGroup_is_uniform (G := F)
state_before: 𝕜 : Type u_1
ι : Type u_2
E : ι → Type u_3
F : Type u_4
inst✝⁸ : NormedField 𝕜
inst✝⁷ : (i : ι) → TopologicalSpace (E i)
inst✝⁶ : (i : ι) → AddCommGroup (E i)
inst✝⁵ : (i : ι) → Module 𝕜 (E i)
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ∀ (i : ι), ContinuousSMul 𝕜 (E i)
x : (i : ι) → E i
this✝ : UniformSpace F := TopologicalAddGroup.toUniformSpace F
this : UniformAddGroup F
⊢ Continuous fun p => p x
state_after: no goals
tactic: exact (uniformContinuous_eval_const x).continuous
Theorem: Subalgebra.mulMap_range
File: Mathlib/LinearAlgebra/TensorProduct/Subalgebra.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : Algebra R S
A B : Subalgebra R S
⊢ (A.mulMap B).range = A ⊔ B
state_after: no goals
tactic: simp_rw [mulMap, Algebra.TensorProduct.productMap_range, Subalgebra.range_val]
Theorem: CategoryTheory.finallySmall_of_small_weakly_terminal_set
File: Mathlib/CategoryTheory/Limits/FinallySmall.lean

Proof steps:
state_before: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
⊢ (fullSubcategoryInclusion fun x => x ∈ s).Final
state_after: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
i : J
⊢ ∃ c, Nonempty (i ⟶ (fullSubcategoryInclusion fun x => x ∈ s).obj c)
tactic: refine Functor.final_of_exists_of_isFiltered_of_fullyFaithful _ (fun i => ?_)
state_before: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
i : J
⊢ ∃ c, Nonempty (i ⟶ (fullSubcategoryInclusion fun x => x ∈ s).obj c)
state_after: case intro.intro
J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
i j : J
hj₁ : j ∈ s
hj₂ : Nonempty (i ⟶ j)
⊢ ∃ c, Nonempty (i ⟶ (fullSubcategoryInclusion fun x => x ∈ s).obj c)
tactic: obtain ⟨j, hj₁, hj₂⟩ := hs i
state_before: case intro.intro
J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
i j : J
hj₁ : j ∈ s
hj₂ : Nonempty (i ⟶ j)
⊢ ∃ c, Nonempty (i ⟶ (fullSubcategoryInclusion fun x => x ∈ s).obj c)
state_after: no goals
tactic: exact ⟨⟨j, hj₁⟩, hj₂⟩
Theorem: NNRat.cast_inv_of_ne_zero
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionSemiring α
q r : ℚ≥0
hq : ↑q.num ≠ 0
⊢ ↑q⁻¹ = (↑q)⁻¹
state_after: no goals
tactic: rw [inv_def, cast_divNat_of_ne_zero _ hq, cast_def, inv_div]
Theorem: Sym2.inf_le_sup
File: Mathlib/Data/Sym/Sym2/Order.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Lattice α
s : Sym2 α
⊢ s.inf ≤ s.sup
state_after: case h
α : Type u_1
inst✝ : Lattice α
x✝ y✝ : α
⊢ s(x✝, y✝).inf ≤ s(x✝, y✝).sup
tactic: cases s using Sym2.ind
state_before: case h
α : Type u_1
inst✝ : Lattice α
x✝ y✝ : α
⊢ s(x✝, y✝).inf ≤ s(x✝, y✝).sup
state_after: no goals
tactic: simp [_root_.inf_le_sup]
Theorem: not_addDissociated
File: Mathlib/Combinatorics/Additive/Dissociation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CommGroup α
inst✝ : CommGroup β
s : Set α
t u : Finset α
d : ℕ
a : α
⊢ ¬MulDissociated s ↔ ∃ t, ↑t ⊆ s ∧ ∃ u, ↑u ⊆ s ∧ t ≠ u ∧ ∏ x ∈ t, x = ∏ x ∈ u, x
state_after: α : Type u_1
β : Type u_2
inst✝¹ : CommGroup α
inst✝ : CommGroup β
s : Set α
t u : Finset α
d : ℕ
a : α
⊢ (∃ x, ↑x ⊆ s ∧ ∃ x_1, ↑x_1 ⊆ s ∧ ∏ x ∈ x, x = ∏ x ∈ x_1, x ∧ ¬x = x_1) ↔
    ∃ t, ↑t ⊆ s ∧ ∃ u, ↑u ⊆ s ∧ ¬t = u ∧ ∏ x ∈ t, x = ∏ x ∈ u, x
tactic: simp [MulDissociated, InjOn]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CommGroup α
inst✝ : CommGroup β
s : Set α
t u : Finset α
d : ℕ
a : α
⊢ (∃ x, ↑x ⊆ s ∧ ∃ x_1, ↑x_1 ⊆ s ∧ ∏ x ∈ x, x = ∏ x ∈ x_1, x ∧ ¬x = x_1) ↔
    ∃ t, ↑t ⊆ s ∧ ∃ u, ↑u ⊆ s ∧ ¬t = u ∧ ∏ x ∈ t, x = ∏ x ∈ u, x
state_after: no goals
tactic: aesop
Theorem: Linarith.mul_neg
File: Mathlib/Tactic/Linarith/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : StrictOrderedRing α
a b : α
ha : a < 0
hb : 0 < b
this : -b * a > 0
⊢ 0 < -(b * a)
state_after: no goals
tactic: simpa
Theorem: Finset.centerMass_neg_left
File: Mathlib/Analysis/Convex/Combination.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
⊢ t.centerMass (-w) z = t.centerMass w z
state_after: no goals
tactic: simp [centerMass, inv_neg]
Theorem: Int.succ_natCast_pos
File: Mathlib/Data/Int/Lemmas.lean

Proof steps:
state_before: n : ℕ
⊢ 0 ≤ ↑n
state_after: no goals
tactic: simp
Theorem: Finset.addETransformRight.card
File: Mathlib/Combinatorics/Additive/ETransform.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ x.2.card + (e⁻¹ • x.2).card = 2 * x.2.card
state_after: no goals
tactic: rw [card_smul_finset, two_mul]
Theorem: RatFunc.denom_div
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).denom =
    C (q / gcd p q).leadingCoeff⁻¹ * (q / gcd p q)
state_after: no goals
tactic: rw [denom, numDenom_div _ hq]
Theorem: MvPolynomial.rank_mvPolynomial
File: Mathlib/FieldTheory/MvPolynomial.lean

Proof steps:
state_before: σ K : Type u
inst✝ : Field K
⊢ Module.rank K (MvPolynomial σ K) = Cardinal.mk (σ →₀ ℕ)
state_after: no goals
tactic: rw [← Cardinal.lift_inj, ← (basisMonomials σ K).mk_eq_rank]