ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: intervalIntegral.integral_le_sub_of_hasDeriv_right_of_le
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
hab : a ≤ b
hcont : ContinuousOn g (Icc a b)
hderiv : ∀ x ∈ Ioo a b, HasDerivWithinAt g (g' x) (Ioi x) x
φint : IntegrableOn φ (Icc a b) volume
hφg : ∀ x ∈ Ioo a b, φ x ≤ g' x
⊢ ∫ (y : ℝ) in a..b, φ y ≤ g b - g a
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
hab : a ≤ b
hcont : ContinuousOn g (Icc a b)
hderiv : ∀ x ∈ Ioo a b, HasDerivWithinAt g (g' x) (Ioi x) x
φint : IntegrableOn φ (Icc a b) volume
hφg : ∀ x ∈ Ioo a b, φ x ≤ g' x
⊢ -(g b - g a) ≤ -∫ (y : ℝ) in a..b, φ y
tactic: rw [← neg_le_neg_iff]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
hab : a ≤ b
hcont : ContinuousOn g (Icc a b)
hderiv : ∀ x ∈ Ioo a b, HasDerivWithinAt g (g' x) (Ioi x) x
φint : IntegrableOn φ (Icc a b) volume
hφg : ∀ x ∈ Ioo a b, φ x ≤ g' x
⊢ -(g b - g a) ≤ -∫ (y : ℝ) in a..b, φ y
state_after: case h.e'_3
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
hab : a ≤ b
hcont : ContinuousOn g (Icc a b)
hderiv : ∀ x ∈ Ioo a b, HasDerivWithinAt g (g' x) (Ioi x) x
φint : IntegrableOn φ (Icc a b) volume
hφg : ∀ x ∈ Ioo a b, φ x ≤ g' x
⊢ -(g b - g a) = -g b - -g a

case h.e'_4
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
hab : a ≤ b
hcont : ContinuousOn g (Icc a b)
hderiv : ∀ x ∈ Ioo a b, HasDerivWithinAt g (g' x) (Ioi x) x
φint : IntegrableOn φ (Icc a b) volume
hφg : ∀ x ∈ Ioo a b, φ x ≤ g' x
⊢ -∫ (y : ℝ) in a..b, φ y = ∫ (y : ℝ) in a..b, (-φ) y
tactic: convert sub_le_integral_of_hasDeriv_right_of_le hab hcont.neg (fun x hx => (hderiv x hx).neg)
    φint.neg fun x hx => neg_le_neg (hφg x hx) using 1
Theorem: List.count_le_count_map
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_2
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : DecidableEq β
l : List α
f : α → β
x : α
⊢ count x l ≤ count (f x) (map f l)
state_after: α : Type u_2
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : DecidableEq β
l : List α
f : α → β
x : α
⊢ countP (fun x_1 => x_1 == x) l ≤ countP ((fun x_1 => x_1 == f x) ∘ f) l
tactic: rw [count, count, countP_map]
state_before: α : Type u_2
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : DecidableEq β
l : List α
f : α → β
x : α
⊢ countP (fun x_1 => x_1 == x) l ≤ countP ((fun x_1 => x_1 == f x) ∘ f) l
state_after: case h
α : Type u_2
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : DecidableEq β
l : List α
f : α → β
x : α
⊢ ∀ (x_1 : α), x_1 ∈ l → (x_1 == x) = true → ((fun x_2 => x_2 == f x) ∘ f) x_1 = true
tactic: apply countP_mono_left
state_before: case h
α : Type u_2
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : DecidableEq β
l : List α
f : α → β
x : α
⊢ ∀ (x_1 : α), x_1 ∈ l → (x_1 == x) = true → ((fun x_2 => x_2 == f x) ∘ f) x_1 = true
state_after: no goals
tactic: simp (config := { contextual := true })
Theorem: PartENat.lt_find_iff
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
⊢ ↑n < find P ↔ ∀ m ≤ n, ¬P m
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
⊢ ↑n < find P → ∀ m ≤ n, ¬P m
tactic: refine ⟨?_, lt_find P n⟩
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
⊢ ↑n < find P → ∀ m ≤ n, ¬P m
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ↑n < find P
m : ℕ
hm : m ≤ n
⊢ ¬P m
tactic: intro h m hm
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ↑n < find P
m : ℕ
hm : m ≤ n
⊢ ¬P m
state_after: case pos
P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ↑n < find P
m : ℕ
hm : m ≤ n
H : (find P).Dom
⊢ ¬P m

case neg
P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ↑n < find P
m : ℕ
hm : m ≤ n
H : ¬(find P).Dom
⊢ ¬P m
tactic: by_cases H : (find P).Dom
Theorem: Nat.gcd_self_add_left
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n : ℕ
⊢ (m + n).gcd m = n.gcd m
state_after: no goals
tactic: rw [add_comm, gcd_add_self_left]
Theorem: partialSups_eq_ciSup_Iic
File: Mathlib/Order/PartialSups.lean

Proof steps:
state_before: α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (partialSups f) n ≤ x✝ ↔ ⨆ i, f ↑i ≤ x✝
state_after: α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (∀ k ≤ n, f k ≤ x✝) ↔ ∀ i ∈ Set.Iic n, f i ≤ x✝
tactic: rw [ciSup_set_le_iff Set.nonempty_Iic ((Set.finite_le_nat _).image _).bddAbove,
      partialSups_le_iff]
state_before: α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (∀ k ≤ n, f k ≤ x✝) ↔ ∀ i ∈ Set.Iic n, f i ≤ x✝
state_after: no goals
tactic: rfl
Theorem: HurwitzZeta.cosKernel_neg
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
x : ℝ
⊢ cosKernel (-a) x = cosKernel a x
state_after: case H
x a' : ℝ
⊢ cosKernel (-↑a') x = cosKernel (↑a') x
tactic: induction' a using QuotientAddGroup.induction_on' with a'
state_before: case H
x a' : ℝ
⊢ cosKernel (-↑a') x = cosKernel (↑a') x
state_after: no goals
tactic: simp only [← QuotientAddGroup.mk_neg, ← ofReal_inj, cosKernel_def, ofReal_neg,
    jacobiTheta₂_neg_left]
Theorem: Order.Ideal.PrimePair.F_isPrime
File: Mathlib/Order/PrimeIdeal.lean

Proof steps:
state_before: P : Type u_1
inst✝ : Preorder P
IF : Ideal.PrimePair P
⊢ IsIdeal (↑IF.F)ᶜ
state_after: P : Type u_1
inst✝ : Preorder P
IF : Ideal.PrimePair P
⊢ IsIdeal ↑IF.I
tactic: rw [IF.compl_F_eq_I]
state_before: P : Type u_1
inst✝ : Preorder P
IF : Ideal.PrimePair P
⊢ IsIdeal ↑IF.I
state_after: no goals
tactic: exact IF.I.isIdeal
Theorem: Stream'.get?_take
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
k n : ℕ
h : k + 1 < n + 1
⊢ (take (n + 1) s).get? (k + 1) = some (s.get (k + 1))
state_after: no goals
tactic: rw [take_succ, List.get?, get?_take (Nat.lt_of_succ_lt_succ h), get_succ]
Theorem: Finite.bddAbove_range
File: Mathlib/Data/Fintype/Order.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≤ x_1
f : β → α
⊢ BddAbove (Set.range f)
state_after: case intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≤ x_1
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
⊢ BddAbove (Set.range f)
tactic: obtain ⟨M, hM⟩ := Finite.exists_le f
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≤ x_1
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
⊢ BddAbove (Set.range f)
state_after: case intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≤ x_1
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
a : α
ha : a ∈ Set.range f
⊢ a ≤ M
tactic: refine ⟨M, fun a ha => ?_⟩
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≤ x_1
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
a : α
ha : a ∈ Set.range f
⊢ a ≤ M
state_after: case intro.intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≤ x_1
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
b : β
⊢ f b ≤ M
tactic: obtain ⟨b, rfl⟩ := ha
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≤ x_1
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
b : β
⊢ f b ≤ M
state_after: no goals
tactic: exact hM b
Theorem: SimpleGraph.Subgraph.neighborSet_iSup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
f : ι → G.Subgraph
v : V
⊢ (⨆ i, f i).neighborSet v = ⋃ i, (f i).neighborSet v
state_after: no goals
tactic: simp [iSup]
Theorem: MeasureTheory.measure_union₀'
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s μ
hd : AEDisjoint μ s t
⊢ μ (s ∪ t) = μ s + μ t
state_after: no goals
tactic: rw [union_comm, measure_union₀ hs (AEDisjoint.symm hd), add_comm]
Theorem: norm_add_sq_real
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
h : ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * re ⟪x, y⟫_ℝ + ‖y‖ ^ 2
⊢ ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2
tactic: have h := @norm_add_sq ℝ _ _ _ _ x y
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
h : ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * re ⟪x, y⟫_ℝ + ‖y‖ ^ 2
⊢ ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2
state_after: no goals
tactic: simpa using h
Theorem: Polynomial.modByMonic_eq_mod
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q p : R[X]
hq : q.Monic
⊢ p %ₘ q = p %ₘ (q * C q.leadingCoeff⁻¹)
state_after: no goals
tactic: simp only [Monic.def.1 hq, inv_one, mul_one, C_1]
Theorem: NonUnitalStarAlgHom.coe_range
File: Mathlib/Algebra/Star/NonUnitalSubalgebra.lean

Proof steps:
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹² : CommSemiring R
inst✝¹¹ : NonUnitalNonAssocSemiring A
inst✝¹⁰ : Module R A
inst✝⁹ : Star A
inst✝⁸ : NonUnitalNonAssocSemiring B
inst✝⁷ : Module R B
inst✝⁶ : Star B
inst✝⁵ : NonUnitalNonAssocSemiring C
inst✝⁴ : Module R C
inst✝³ : Star C
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
φ : F
⊢ ↑(NonUnitalStarAlgHom.range φ) = Set.range ⇑φ
state_after: case h
F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹² : CommSemiring R
inst✝¹¹ : NonUnitalNonAssocSemiring A
inst✝¹⁰ : Module R A
inst✝⁹ : Star A
inst✝⁸ : NonUnitalNonAssocSemiring B
inst✝⁷ : Module R B
inst✝⁶ : Star B
inst✝⁵ : NonUnitalNonAssocSemiring C
inst✝⁴ : Module R C
inst✝³ : Star C
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
φ : F
x✝ : B
⊢ x✝ ∈ ↑(NonUnitalStarAlgHom.range φ) ↔ x✝ ∈ Set.range ⇑φ
tactic: ext
state_before: case h
F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹² : CommSemiring R
inst✝¹¹ : NonUnitalNonAssocSemiring A
inst✝¹⁰ : Module R A
inst✝⁹ : Star A
inst✝⁸ : NonUnitalNonAssocSemiring B
inst✝⁷ : Module R B
inst✝⁶ : Star B
inst✝⁵ : NonUnitalNonAssocSemiring C
inst✝⁴ : Module R C
inst✝³ : Star C
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
φ : F
x✝ : B
⊢ x✝ ∈ ↑(NonUnitalStarAlgHom.range φ) ↔ x✝ ∈ Set.range ⇑φ
state_after: case h
F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹² : CommSemiring R
inst✝¹¹ : NonUnitalNonAssocSemiring A
inst✝¹⁰ : Module R A
inst✝⁹ : Star A
inst✝⁸ : NonUnitalNonAssocSemiring B
inst✝⁷ : Module R B
inst✝⁶ : Star B
inst✝⁵ : NonUnitalNonAssocSemiring C
inst✝⁴ : Module R C
inst✝³ : Star C
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
φ : F
x✝ : B
⊢ (∃ x, φ x = x✝) ↔ x✝ ∈ Set.range ⇑φ
tactic: rw [SetLike.mem_coe, mem_range]
state_before: case h
F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹² : CommSemiring R
inst✝¹¹ : NonUnitalNonAssocSemiring A
inst✝¹⁰ : Module R A
inst✝⁹ : Star A
inst✝⁸ : NonUnitalNonAssocSemiring B
inst✝⁷ : Module R B
inst✝⁶ : Star B
inst✝⁵ : NonUnitalNonAssocSemiring C
inst✝⁴ : Module R C
inst✝³ : Star C
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
φ : F
x✝ : B
⊢ (∃ x, φ x = x✝) ↔ x✝ ∈ Set.range ⇑φ
state_after: no goals
tactic: rfl
Theorem: Real.ext_cauchy_iff
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
a b : Cauchy abs
⊢ { cauchy := a } = { cauchy := b } ↔ { cauchy := a }.cauchy = { cauchy := b }.cauchy
state_after: no goals
tactic: rw [ofCauchy.injEq]
Theorem: max_sub_sub_left
File: Mathlib/Algebra/Order/Group/MinMax.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ max (a / b) (a / c) = a / min b c
state_after: no goals
tactic: simp only [div_eq_mul_inv, max_mul_mul_left, max_inv_inv']
Theorem: List.foldl_op_eq_op_foldr_assoc
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
op : α → α → α
ha : Std.Associative op
hc : Std.Commutative op
a : α
l : List α
a₁ a₂ : α
⊢ op ((a :: l) <*> a₁) a₂ = op a₁ (foldr (fun x x_1 => op x x_1) a₂ (a :: l))
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
op : α → α → α
ha : Std.Associative op
hc : Std.Commutative op
a : α
l : List α
a₁ a₂ : α
⊢ op a₁ (op (l <*> a) a₂) = op a₁ (op a (foldr (fun x x_1 => op x x_1) a₂ l))
tactic: simp only [foldl_cons, foldr_cons, foldl_assoc, ha.assoc]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
op : α → α → α
ha : Std.Associative op
hc : Std.Commutative op
a : α
l : List α
a₁ a₂ : α
⊢ op a₁ (op (l <*> a) a₂) = op a₁ (op a (foldr (fun x x_1 => op x x_1) a₂ l))
state_after: no goals
tactic: rw [foldl_op_eq_op_foldr_assoc]
Theorem: Set.preimage_const_mul_Icc_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x => c * x) ⁻¹' Icc a b = Icc (b / c) (a / c)
state_after: no goals
tactic: simpa only [mul_comm] using preimage_mul_const_Icc_of_neg a b h
Theorem: SimpleGraph.Reachable.elim_path
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
p : Prop
u v : V
h : G.Reachable u v
hp : G.Path u v → p
⊢ p
state_after: no goals
tactic: classical exact h.elim fun q => hp q.toPath
Theorem: Real.toNNReal_mul_nnnorm
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
x y : ℝ
hx : 0 ≤ x
⊢ x.toNNReal * ‖y‖₊ = ‖x * y‖₊
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
x y : ℝ
hx : 0 ≤ x
⊢ ↑(x.toNNReal * ‖y‖₊) = ↑‖x * y‖₊
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
x y : ℝ
hx : 0 ≤ x
⊢ ↑(x.toNNReal * ‖y‖₊) = ↑‖x * y‖₊
state_after: no goals
tactic: simp only [NNReal.coe_mul, nnnorm_mul, coe_nnnorm, Real.toNNReal_of_nonneg, norm_of_nonneg, hx,
    NNReal.coe_mk]
Theorem: WittVector.mul_charP_coeff_succ
File: Mathlib/RingTheory/WittVector/Identities.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
x : 𝕎 R
i : ℕ
⊢ (x * ↑p).coeff (i + 1) = x.coeff i ^ p
state_after: no goals
tactic: rw [← frobenius_verschiebung, coeff_frobenius_charP, verschiebung_coeff_succ]
Theorem: MeasureTheory.IsProjectiveLimit.unique
File: Mathlib/MeasureTheory/Constructions/Projective.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
inst✝ : ∀ (i : Finset ι), IsFiniteMeasure (P i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
⊢ μ = ν
state_after: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
inst✝ : ∀ (i : Finset ι), IsFiniteMeasure (P i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
this : IsFiniteMeasure μ
⊢ μ = ν
tactic: haveI : IsFiniteMeasure μ := hμ.isFiniteMeasure
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
inst✝ : ∀ (i : Finset ι), IsFiniteMeasure (P i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
this : IsFiniteMeasure μ
⊢ μ = ν
state_after: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
inst✝ : ∀ (i : Finset ι), IsFiniteMeasure (P i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
this : IsFiniteMeasure μ
s : Set ((i : ι) → α i)
hs : s ∈ measurableCylinders α
⊢ μ s = ν s
tactic: refine ext_of_generate_finite (measurableCylinders α) generateFrom_measurableCylinders.symm
    isPiSystem_measurableCylinders (fun s hs ↦ ?_) (hμ.measure_univ_unique hν)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
inst✝ : ∀ (i : Finset ι), IsFiniteMeasure (P i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
this : IsFiniteMeasure μ
s : Set ((i : ι) → α i)
hs : s ∈ measurableCylinders α
⊢ μ s = ν s
state_after: case intro.intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
inst✝ : ∀ (i : Finset ι), IsFiniteMeasure (P i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
this : IsFiniteMeasure μ
I : Finset ι
S : Set ((i : { x // x ∈ I }) → α ↑i)
hS : MeasurableSet S
hs : cylinder I S ∈ measurableCylinders α
⊢ μ (cylinder I S) = ν (cylinder I S)
tactic: obtain ⟨I, S, hS, rfl⟩ := (mem_measurableCylinders _).mp hs
state_before: case intro.intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
inst✝ : ∀ (i : Finset ι), IsFiniteMeasure (P i)
hμ : IsProjectiveLimit μ P
hν : IsProjectiveLimit ν P
this : IsFiniteMeasure μ
I : Finset ι
S : Set ((i : { x // x ∈ I }) → α ↑i)
hS : MeasurableSet S
hs : cylinder I S ∈ measurableCylinders α
⊢ μ (cylinder I S) = ν (cylinder I S)
state_after: no goals
tactic: rw [hμ.measure_cylinder _ hS, hν.measure_cylinder _ hS]
Theorem: Stream'.mem_interleave_right
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
a : α
s₁ s₂ : Stream' α
x✝ : a ∈ s₂
n : ℕ
h : (fun b => a = b) (s₂.get n)
⊢ (fun b => a = b) ((s₁ ⋈ s₂).get (2 * n + 1))
state_after: no goals
tactic: rw [h, get_interleave_right]
Theorem: Ideal.mem_iInf_smul_pow_eq_bot_iff
File: Mathlib/RingTheory/Filtration.lean

Proof steps:
state_before: R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : I.Filtration M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
x : M
⊢ x ∈ ⨅ i, I ^ i • ⊤ ↔ ∃ r, ↑r • x = x
state_after: R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : I.Filtration M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
x : M
N : Submodule R M := ⨅ i, I ^ i • ⊤
⊢ x ∈ ⨅ i, I ^ i • ⊤ ↔ ∃ r, ↑r • x = x
tactic: let N := (⨅ i : ℕ, I ^ i • ⊤ : Submodule R M)
state_before: R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : I.Filtration M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
x : M
N : Submodule R M := ⨅ i, I ^ i • ⊤
⊢ x ∈ ⨅ i, I ^ i • ⊤ ↔ ∃ r, ↑r • x = x
state_after: R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : I.Filtration M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
x : M
N : Submodule R M := ⨅ i, I ^ i • ⊤
hN : ∀ (k : ℕ), (I.stableFiltration ⊤ ⊓ I.trivialFiltration N).N k = N
⊢ x ∈ ⨅ i, I ^ i • ⊤ ↔ ∃ r, ↑r • x = x
tactic: have hN : ∀ k, (I.stableFiltration ⊤ ⊓ I.trivialFiltration N).N k = N :=
    fun k => inf_eq_right.mpr ((iInf_le _ k).trans <| le_of_eq <| by simp)
state_before: R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : I.Filtration M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
x : M
N : Submodule R M := ⨅ i, I ^ i • ⊤
hN : ∀ (k : ℕ), (I.stableFiltration ⊤ ⊓ I.trivialFiltration N).N k = N
⊢ x ∈ ⨅ i, I ^ i • ⊤ ↔ ∃ r, ↑r • x = x
state_after: case mp
R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : I.Filtration M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
x : M
N : Submodule R M := ⨅ i, I ^ i • ⊤
hN : ∀ (k : ℕ), (I.stableFiltration ⊤ ⊓ I.trivialFiltration N).N k = N
⊢ x ∈ ⨅ i, I ^ i • ⊤ → ∃ r, ↑r • x = x

case mpr
R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : I.Filtration M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
x : M
N : Submodule R M := ⨅ i, I ^ i • ⊤
hN : ∀ (k : ℕ), (I.stableFiltration ⊤ ⊓ I.trivialFiltration N).N k = N
⊢ (∃ r, ↑r • x = x) → x ∈ ⨅ i, I ^ i • ⊤
tactic: constructor
Theorem: IsCauSeq.of_mono_bounded
File: Mathlib/Algebra/Order/CauSeq/BigOperators.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : LinearOrderedField α
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
f✝ g : ℕ → β
a✝ : ℕ → α
inst✝ : Archimedean α
f : ℕ → α
a : α
m : ℕ
ham : ∀ n ≥ m, |f n| ≤ a
hnm : ∀ n ≥ m, f n ≤ f n.succ
⊢ ∀ n ≥ m, |(-f) n| ≤ a
state_after: no goals
tactic: simpa using ham
state_before: α : Type u_1
β : Type u_2
inst✝³ : LinearOrderedField α
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
f✝ g : ℕ → β
a✝ : ℕ → α
inst✝ : Archimedean α
f : ℕ → α
a : α
m : ℕ
ham : ∀ n ≥ m, |f n| ≤ a
hnm : ∀ n ≥ m, f n ≤ f n.succ
⊢ ∀ n ≥ m, (-f) n.succ ≤ (-f) n
state_after: no goals
tactic: simpa using hnm
Theorem: RelIso.minimals_preimage_eq
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x : α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ≃r s
y : Set β
⊢ minimals r (⇑f ⁻¹' y) = ⇑f ⁻¹' minimals s y
state_after: case h.e'_3.h.e'_4.h.e'_3
α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x : α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ≃r s
y : Set β
⊢ y = y ∩ range ⇑f.toRelEmbedding
tactic: convert f.toRelEmbedding.minimals_preimage_eq y
state_before: case h.e'_3.h.e'_4.h.e'_3
α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x : α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ≃r s
y : Set β
⊢ y = y ∩ range ⇑f.toRelEmbedding
state_after: no goals
tactic: simp
Theorem: Fintype.prod_bool
File: Mathlib/Data/Fintype/BigOperators.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : CommMonoid α
f : Bool → α
⊢ ∏ b : Bool, f b = f true * f false
state_after: no goals
tactic: simp