ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ValuationSubring.primeSpectrumEquiv_apply_coe
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
P : PrimeSpectrum ↥A
⊢ (fun S => { asIdeal := A.idealOfLE ↑S ⋯, isPrime := ⋯ }) ((fun P => ⟨A.ofPrime P.asIdeal, ⋯⟩) P) = P
state_after: case asIdeal
K : Type u
inst✝ : Field K
A : ValuationSubring K
P : PrimeSpectrum ↥A
⊢ ((fun S => { asIdeal := A.idealOfLE ↑S ⋯, isPrime := ⋯ }) ((fun P => ⟨A.ofPrime P.asIdeal, ⋯⟩) P)).asIdeal = P.asIdeal
tactic: ext1
state_before: case asIdeal
K : Type u
inst✝ : Field K
A : ValuationSubring K
P : PrimeSpectrum ↥A
⊢ ((fun S => { asIdeal := A.idealOfLE ↑S ⋯, isPrime := ⋯ }) ((fun P => ⟨A.ofPrime P.asIdeal, ⋯⟩) P)).asIdeal = P.asIdeal
state_after: no goals
tactic: simp
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
S : { S // A ≤ S }
⊢ (fun P => ⟨A.ofPrime P.asIdeal, ⋯⟩) ((fun S => { asIdeal := A.idealOfLE ↑S ⋯, isPrime := ⋯ }) S) = S
state_after: case a
K : Type u
inst✝ : Field K
A : ValuationSubring K
S : { S // A ≤ S }
⊢ ↑((fun P => ⟨A.ofPrime P.asIdeal, ⋯⟩) ((fun S => { asIdeal := A.idealOfLE ↑S ⋯, isPrime := ⋯ }) S)) = ↑S
tactic: ext1
state_before: case a
K : Type u
inst✝ : Field K
A : ValuationSubring K
S : { S // A ≤ S }
⊢ ↑((fun P => ⟨A.ofPrime P.asIdeal, ⋯⟩) ((fun S => { asIdeal := A.idealOfLE ↑S ⋯, isPrime := ⋯ }) S)) = ↑S
state_after: no goals
tactic: simp
Theorem: Polynomial.degree_smul_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a✝ b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
a : R
p : R[X]
⊢ (a • p).degree ≤ p.degree
state_after: R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
a : R
p : R[X]
m : ℕ
hm : p.degree < ↑m
⊢ (a • p).coeff m = 0
tactic: refine (degree_le_iff_coeff_zero _ _).2 fun m hm => ?_
state_before: R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
a : R
p : R[X]
m : ℕ
hm : p.degree < ↑m
⊢ (a • p).coeff m = 0
state_after: R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
a : R
p : R[X]
m : ℕ
hm : ∀ (m_1 : ℕ), m ≤ m_1 → p.coeff m_1 = 0
⊢ (a • p).coeff m = 0
tactic: rw [degree_lt_iff_coeff_zero] at hm
state_before: R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
a : R
p : R[X]
m : ℕ
hm : ∀ (m_1 : ℕ), m ≤ m_1 → p.coeff m_1 = 0
⊢ (a • p).coeff m = 0
state_after: no goals
tactic: simp [hm m le_rfl]
Theorem: Set.apply_mulIndicator_symmDiff
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
inst✝ : Group G
s✝ t✝ : Set α
f✝ g✝ : α → G
a : α
g : G → β
hg : ∀ (x : G), g x⁻¹ = g x
s t : Set α
f : α → G
x : α
⊢ g ((s ∆ t).mulIndicator f x) = g (s.mulIndicator f x / t.mulIndicator f x)
state_after: no goals
tactic: by_cases hs : x ∈ s <;> by_cases ht : x ∈ t <;> simp [mem_symmDiff, *]
Theorem: Finset.sum_nonneg
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s t : Finset ι
h : ∀ i ∈ s, 1 ≤ f i
⊢ 1 ≤ ∏ i ∈ s, 1
state_after: no goals
tactic: rw [prod_const_one]
Theorem: MeasureTheory.mem_fundamentalInterior
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 α
s : Set α
x : α
⊢ x ∈ fundamentalInterior G s ↔ x ∈ s ∧ ∀ (g : G), g ≠ 1 → x ∉ g • s
state_after: no goals
tactic: simp [fundamentalInterior]
Theorem: Set.mem_range_mulIndicator
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g : α → M
a : α
r : M
s : Set α
f : α → M
⊢ r ∈ range (s.mulIndicator f) ↔ r = 1 ∧ s ≠ univ ∨ r ∈ f '' s
state_after: no goals
tactic: simp [mulIndicator, ite_eq_iff, exists_or, eq_univ_iff_forall, and_comm, or_comm,
    @eq_comm _ r 1]
Theorem: List.toFinsupp_singleton
File: Mathlib/Data/List/ToFinsupp.lean

Proof steps:
state_before: M : Type u_1
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => l.getD x 0 ≠ 0
n : ℕ
x : M
inst✝ : DecidablePred fun x_1 => [x].getD x_1 0 ≠ 0
⊢ [x].toFinsupp = Finsupp.single 0 x
state_after: no goals
tactic: ext ⟨_ | i⟩ <;> simp [Finsupp.single_apply, (Nat.zero_lt_succ _).ne]
Theorem: Set.inter_nonempty_iff_exists_right
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ (s ∩ t).Nonempty ↔ ∃ x ∈ t, x ∈ s
state_after: no goals
tactic: simp_rw [inter_nonempty, and_comm]
Theorem: Submodule.toAddSubmonoid_sSup
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
s : Set (Submodule R M)
p : Submodule R M := { toAddSubmonoid := sSup (toAddSubmonoid '' s), smul_mem' := ⋯ }
⊢ (sSup s).toAddSubmonoid = sSup (toAddSubmonoid '' s)
state_after: case refine_1
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
s : Set (Submodule R M)
p : Submodule R M := { toAddSubmonoid := sSup (toAddSubmonoid '' s), smul_mem' := ⋯ }
⊢ sSup s ≤ p

case refine_2
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
s : Set (Submodule R M)
p : Submodule R M := { toAddSubmonoid := sSup (toAddSubmonoid '' s), smul_mem' := ⋯ }
⊢ sSup (toAddSubmonoid '' s) ≤ (sSup s).toAddSubmonoid
tactic: refine le_antisymm (?_ : sSup s ≤ p) ?_
Theorem: Multiset.Nodup.sigma
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
σ✝ : α → Type u_4
a : α
s : Multiset α
t✝ : (a : α) → Multiset (σ✝ a)
σ : α → Type u_5
t : (a : α) → Multiset (σ a)
l₁ : List α
⊢ Nodup (Quot.mk Setoid.r l₁) → (∀ (a : α), (t a).Nodup) → (Multiset.sigma (Quot.mk Setoid.r l₁) t).Nodup
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
σ✝ : α → Type u_4
a : α
s : Multiset α
t✝ : (a : α) → Multiset (σ✝ a)
σ : α → Type u_5
t : (a : α) → Multiset (σ a)
l₁ : List α
f : (a : α) → List (σ a)
hf : ∀ (a : α), ⟦f a⟧ = t a
⊢ Nodup (Quot.mk Setoid.r l₁) → (∀ (a : α), (t a).Nodup) → (Multiset.sigma (Quot.mk Setoid.r l₁) t).Nodup
tactic: choose f hf using fun a => Quotient.exists_rep (t a)
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
σ✝ : α → Type u_4
a : α
s : Multiset α
t✝ : (a : α) → Multiset (σ✝ a)
σ : α → Type u_5
t : (a : α) → Multiset (σ a)
l₁ : List α
f : (a : α) → List (σ a)
hf : ∀ (a : α), ⟦f a⟧ = t a
⊢ Nodup (Quot.mk Setoid.r l₁) → (∀ (a : α), (t a).Nodup) → (Multiset.sigma (Quot.mk Setoid.r l₁) t).Nodup
state_after: no goals
tactic: simpa [← funext hf] using List.Nodup.sigma
Theorem: NNReal.indicator_summable
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0
hf : Summable f
s : Set α
⊢ Summable (s.indicator f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0
hf : Summable f
s : Set α
a : α
⊢ (if a ∈ s then f a else 0) ≤ f a
tactic: refine NNReal.summable_of_le (fun a => le_trans (le_of_eq (s.indicator_apply f a)) ?_) hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0
hf : Summable f
s : Set α
a : α
⊢ (if a ∈ s then f a else 0) ≤ f a
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0
hf : Summable f
s : Set α
a : α
h✝ : a ∈ s
⊢ f a ≤ f a

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0
hf : Summable f
s : Set α
a : α
h✝ : a ∉ s
⊢ 0 ≤ f a
tactic: split_ifs
Theorem: inv_le_inv
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ a⁻¹ ≤ b⁻¹ ↔ b ≤ a
state_after: no goals
tactic: rw [← one_div, div_le_iff ha, ← div_eq_inv_mul, le_div_iff hb, one_mul]
Theorem: Polynomial.leadingCoeff_sub_of_degree_lt'
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
h : p.degree < q.degree
⊢ (p - q).leadingCoeff = -q.leadingCoeff
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
h : p.degree < (-q).degree
⊢ (p - q).leadingCoeff = -q.leadingCoeff
tactic: rw [← q.degree_neg] at h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
h : p.degree < (-q).degree
⊢ (p - q).leadingCoeff = -q.leadingCoeff
state_after: no goals
tactic: rw [sub_eq_add_neg, leadingCoeff_add_of_degree_lt h, leadingCoeff_neg]
Theorem: MeasureTheory.VectorMeasure.of_diff_of_diff_eq_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
A B : Set α
hA : MeasurableSet A
hB : MeasurableSet B
h' : ↑v (B \ A) = 0
⊢ ↑v (A \ B) + ↑v B = ↑v A
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
A B : Set α
hA : MeasurableSet A
hB : MeasurableSet B
h' : ↑v (B \ A) = 0
⊢ ↑v A = ↑v (A \ B) + ↑v B
tactic: symm
Theorem: mem_comp_comp
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
p : β × β
⊢ p ∈ V ○ M ○ W ↔ (ball p.1 V ×ˢ ball p.2 W ∩ M).Nonempty
state_after: case mk
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y : β
⊢ (x, y) ∈ V ○ M ○ W ↔ (ball (x, y).1 V ×ˢ ball (x, y).2 W ∩ M).Nonempty
tactic: cases' p with x y
state_before: case mk
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y : β
⊢ (x, y) ∈ V ○ M ○ W ↔ (ball (x, y).1 V ×ˢ ball (x, y).2 W ∩ M).Nonempty
state_after: case mk.mp
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y : β
⊢ (x, y) ∈ V ○ M ○ W → (ball (x, y).1 V ×ˢ ball (x, y).2 W ∩ M).Nonempty

case mk.mpr
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y : β
⊢ (ball (x, y).1 V ×ˢ ball (x, y).2 W ∩ M).Nonempty → (x, y) ∈ V ○ M ○ W
tactic: constructor
Theorem: AlgHom.prod_apply
File: Mathlib/Algebra/Algebra/Prod.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
r : R
⊢ (↑↑__src✝).toFun ((algebraMap R A) r) = (algebraMap R (B × C)) r
state_after: no goals
tactic: simp only [toRingHom_eq_coe, RingHom.toFun_eq_coe, RingHom.prod_apply, coe_toRingHom,
        commutes, Prod.algebraMap_apply]
Theorem: CauSeq.limZero_sub_rev
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
hfg : (f - g).LimZero
⊢ (g - f).LimZero
state_after: no goals
tactic: simpa using neg_limZero hfg
Theorem: CategoryTheory.Limits.BinaryBicone.toBiconeFunctor_obj_π
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q X Y : C
b : BinaryBicone X Y
j j' : WalkingPair
⊢ (fun j => WalkingPair.casesOn j b.inl b.inr) j ≫ (fun j => WalkingPair.casesOn j b.fst b.snd) j' =
    if h : j = j' then eqToHom ⋯ else 0
state_after: no goals
tactic: rcases j with ⟨⟩ <;> rcases j' with ⟨⟩ <;> simp
Theorem: Turing.Tape.move_right_left
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
⊢ move Dir.left (move Dir.right T) = T
state_after: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ move Dir.left (move Dir.right { head := head✝, left := left✝, right := right✝ }) =
    { head := head✝, left := left✝, right := right✝ }
tactic: cases T
state_before: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ move Dir.left (move Dir.right { head := head✝, left := left✝, right := right✝ }) =
    { head := head✝, left := left✝, right := right✝ }
state_after: no goals
tactic: simp [Tape.move]
Theorem: contDiff_top_iff_deriv
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
⊢ ContDiff 𝕜 ⊤ f₂ ↔ Differentiable 𝕜 f₂ ∧ ContDiff 𝕜 ⊤ (deriv f₂)
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
⊢ ContDiffOn 𝕜 ⊤ f₂ univ ↔ DifferentiableOn 𝕜 f₂ univ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ univ) univ
tactic: simp only [← contDiffOn_univ, ← differentiableOn_univ, ← derivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
⊢ ContDiffOn 𝕜 ⊤ f₂ univ ↔ DifferentiableOn 𝕜 f₂ univ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ univ) univ
state_after: no goals
tactic: rw [contDiffOn_top_iff_derivWithin uniqueDiffOn_univ]
Theorem: Nat.ord_compl_pos
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p✝ n p : ℕ
hn : n ≠ 0
⊢ 0 < n / p ^ n.factorization p
state_after: no goals
tactic: if pp : p.Prime then
    exact Nat.div_pos (ord_proj_le p hn) (ord_proj_pos n p)
  else
    simpa [Nat.factorization_eq_zero_of_non_prime n pp] using hn.bot_lt
Theorem: Mathlib.Tactic.Ring.natCast_nat
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R
n : ℕ
⊢ ↑n.rawCast = n.rawCast
state_after: no goals
tactic: simp
Theorem: WithZeroTopology.hasBasis_nhds_zero
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

Proof steps:
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ (𝓝 0).HasBasis (fun γ => γ ≠ 0) Iio
state_after: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ (⨅ γ, ⨅ (_ : γ ≠ 0), 𝓟 (Iio γ)).HasBasis (fun γ => γ ≠ 0) Iio
tactic: rw [nhds_zero]
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ (⨅ γ, ⨅ (_ : γ ≠ 0), 𝓟 (Iio γ)).HasBasis (fun γ => γ ≠ 0) Iio
state_after: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ DirectedOn (Iio ⁻¹'o fun x x_1 => x ≥ x_1) fun γ => γ = 0 → False
tactic: refine hasBasis_biInf_principal ?_ ⟨1, one_ne_zero⟩
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ DirectedOn (Iio ⁻¹'o fun x x_1 => x ≥ x_1) fun γ => γ = 0 → False
state_after: no goals
tactic: exact directedOn_iff_directed.2 (Monotone.directed_ge fun a b hab => Iio_subset_Iio hab)
Theorem: Set.OrdConnected.convex_of_chain
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : s.OrdConnected
h : IsChain (fun x x_1 => x ≤ x_1) s
⊢ Convex 𝕜 s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : s.OrdConnected
h : IsChain (fun x x_1 => x ≤ x_1) s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
⊢ [x-[𝕜]y] ⊆ s
tactic: refine convex_iff_segment_subset.mpr fun x hx y hy => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : s.OrdConnected
h : IsChain (fun x x_1 => x ≤ x_1) s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
⊢ [x-[𝕜]y] ⊆ s
state_after: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : s.OrdConnected
h : IsChain (fun x x_1 => x ≤ x_1) s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≤ y
⊢ [x-[𝕜]y] ⊆ s

case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : s.OrdConnected
h : IsChain (fun x x_1 => x ≤ x_1) s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hyx : y ≤ x
⊢ [x-[𝕜]y] ⊆ s
tactic: obtain hxy | hyx := h.total hx hy
Theorem: Matrix.nonsing_inv_mul_cancel_left
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B✝ : Matrix n n α
B : Matrix n m α
h : IsUnit A.det
⊢ A⁻¹ * (A * B) = B
state_after: no goals
tactic: simp [← Matrix.mul_assoc, nonsing_inv_mul A h]
Theorem: Combinatorics.Line.apply_some
File: Mathlib/Combinatorics/HalesJewett.lean

Proof steps:
state_before: η : Type u_1
α : Type u_2
ι : Type u_3
κ : Type u_4
l : Line α ι
i : ι
a x : α
h : l.idxFun i = some a
⊢ (fun x i => (l.idxFun i).getD x) x i = a
state_after: no goals
tactic: simp [l.apply_def, h]
Theorem: Finset.erase_sdiff_distrib
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
⊢ (s \ t).erase a = s.erase a \ t.erase a
state_after: no goals
tactic: simp_rw [erase_eq, sdiff_sdiff, sup_sdiff_eq_sup le_rfl, sup_comm]
Theorem: List.maximum_le_of_forall_le
File: Mathlib/Data/List/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
b : WithBot α
h : ∀ (a : α), a ∈ l → ↑a ≤ b
⊢ l.maximum ≤ b
state_after: no goals
tactic: induction l with
  | nil => simp
  | cons a l ih =>
    simp only [maximum_cons, max_le_iff, WithBot.coe_le_coe]
    exact ⟨h a (by simp), ih fun a w => h a (mem_cons.mpr (Or.inr w))⟩
Theorem: MvPolynomial.degreeOf_rename_of_injective
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
f : σ → τ
h : Injective f
i : σ
⊢ degreeOf (f i) ((rename f) p) = degreeOf i p
state_after: no goals
tactic: classical
  simp only [degreeOf, degrees_rename_of_injective h, Multiset.count_map_eq_count' f p.degrees h]
Theorem: ENNReal.div_eq_zero_iff
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a / b = 0 ↔ a = 0 ∨ b = ⊤
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: Set.InjOn.exists_mem_nhdsSet
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X✝ : Type u_1
Y✝ : Type u_2
inst✝⁴ : TopologicalSpace X✝
inst✝³ : FirstCountableTopology X✝
X : Type u_3
Y : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : T2Space Y
f : X → Y
s : Set X
inj : InjOn f s
sc : IsCompact s
fc : ∀ x ∈ s, ContinuousAt f x
loc : ∀ x ∈ s, ∃ u ∈ 𝓝 x, InjOn f u
this : ∀ x ∈ s ×ˢ s, ∀ᶠ (y : X × X) in 𝓝 x, f y.1 = f y.2 → y.1 = y.2
⊢ ∃ t ∈ 𝓝ˢ s, InjOn f t
state_after: X✝ : Type u_1
Y✝ : Type u_2
inst✝⁴ : TopologicalSpace X✝
inst✝³ : FirstCountableTopology X✝
X : Type u_3
Y : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : T2Space Y
f : X → Y
s : Set X
inj : InjOn f s
sc : IsCompact s
fc : ∀ x ∈ s, ContinuousAt f x
loc : ∀ x ∈ s, ∃ u ∈ 𝓝 x, InjOn f u
this : ∀ᶠ (x : X × X) in 𝓝ˢ s ×ˢ 𝓝ˢ s, f x.1 = f x.2 → x.1 = x.2
⊢ ∃ t ∈ 𝓝ˢ s, InjOn f t
tactic: rw [← eventually_nhdsSet_iff_forall, sc.nhdsSet_prod_eq sc] at this
state_before: X✝ : Type u_1
Y✝ : Type u_2
inst✝⁴ : TopologicalSpace X✝
inst✝³ : FirstCountableTopology X✝
X : Type u_3
Y : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : T2Space Y
f : X → Y
s : Set X
inj : InjOn f s
sc : IsCompact s
fc : ∀ x ∈ s, ContinuousAt f x
loc : ∀ x ∈ s, ∃ u ∈ 𝓝 x, InjOn f u
this : ∀ᶠ (x : X × X) in 𝓝ˢ s ×ˢ 𝓝ˢ s, f x.1 = f x.2 → x.1 = x.2
⊢ ∃ t ∈ 𝓝ˢ s, InjOn f t
state_after: no goals
tactic: exact eventually_prod_self_iff.1 this