ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Surreal.Multiplication.mul_right_le_of_equiv
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : x₁.Numeric
h₂ : x₂.Numeric
h₁₂ : IH24 x₁ x₂ y
h₂₁ : IH24 x₂ x₁ y
he : x₁ ≈ x₂
⊢ x₁ * y ≤ x₂ * y
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : x₁.Numeric
h₂ : x₂.Numeric
h₁₂ : IH24 x₁ x₂ y
h₂₁ : IH24 x₂ x₁ y
he : x₁ ≈ x₂
he' : -x₁ ≈ -x₂
⊢ x₁ * y ≤ x₂ * y
tactic: have he' := neg_equiv_neg_iff.2 he
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : x₁.Numeric
h₂ : x₂.Numeric
h₁₂ : IH24 x₁ x₂ y
h₂₁ : IH24 x₂ x₁ y
he : x₁ ≈ x₂
he' : -x₁ ≈ -x₂
⊢ x₁ * y ≤ x₂ * y
state_after: case h₁
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : x₁.Numeric
h₂ : x₂.Numeric
h₁₂ : IH24 x₁ x₂ y
h₂₁ : IH24 x₂ x₁ y
he : x₁ ≈ x₂
he' : -x₁ ≈ -x₂
⊢ ∀ (i : (x₁ * y).LeftMoves), ⟦(x₁ * y).moveLeft i⟧ < ⟦x₂ * y⟧

case h₂
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : x₁.Numeric
h₂ : x₂.Numeric
h₁₂ : IH24 x₁ x₂ y
h₂₁ : IH24 x₂ x₁ y
he : x₁ ≈ x₂
he' : -x₁ ≈ -x₂
⊢ ∀ (j : (x₂ * y).RightMoves), ⟦x₁ * y⟧ < ⟦(x₂ * y).moveRight j⟧
tactic: apply PGame.le_of_forall_lt <;> simp_rw [lt_iff_game_lt]
Theorem: _private.Mathlib.NumberTheory.Harmonic.GammaDeriv.0.Complex.HasDerivAt.complex_of_real
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

Proof steps:
state_before: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ HasDerivAt f ↑g' ↑s
state_after: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ deriv f ↑s = ↑g'
tactic: refine HasDerivAt.congr_deriv hf.hasDerivAt ?_
state_before: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ deriv f ↑s = ↑g'
state_after: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ deriv (fun x => ↑(g x)) s = ↑g'
tactic: rw [← (funext hfg ▸ hf.hasDerivAt.comp_ofReal.deriv :)]
state_before: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ deriv (fun x => ↑(g x)) s = ↑g'
state_after: no goals
tactic: exact hg.ofReal_comp.deriv
Theorem: Finset.powersetCard_eq_empty
File: Mathlib/Data/Finset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s✝ t✝ : Finset α
n : ℕ
s t : Finset α
⊢ powersetCard n s = ∅ ↔ s.card < n
state_after: α : Type u_1
s✝ t✝ : Finset α
n : ℕ
s t : Finset α
⊢ powersetCard n s = ∅ → s.card < n
tactic: refine ⟨?_, fun h ↦ card_eq_zero.1 $ by rw [card_powersetCard, Nat.choose_eq_zero_of_lt h]⟩
state_before: α : Type u_1
s✝ t✝ : Finset α
n : ℕ
s t : Finset α
⊢ powersetCard n s = ∅ → s.card < n
state_after: α : Type u_1
s✝ t✝ : Finset α
n : ℕ
s t : Finset α
⊢ n ≤ s.card → powersetCard n s ≠ ∅
tactic: contrapose!
state_before: α : Type u_1
s✝ t✝ : Finset α
n : ℕ
s t : Finset α
⊢ n ≤ s.card → powersetCard n s ≠ ∅
state_after: no goals
tactic: exact fun h ↦ nonempty_iff_ne_empty.1 $ (exists_subset_card_eq h).imp $ by simp
Theorem: Polynomial.coeff_X_add_one_pow
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
a b : R✝
n✝ m : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
R : Type u_1
inst✝ : Semiring R
n k : ℕ
⊢ ((X + 1) ^ n).coeff k = ↑(n.choose k)
state_after: no goals
tactic: rw [← C_1, coeff_X_add_C_pow, one_pow, one_mul]
Theorem: schnirelmannDensity_diff_singleton_zero
File: Mathlib/Combinatorics/Schnirelmann.lean

Proof steps:
state_before: A : Set ℕ
inst✝¹ : DecidablePred fun x => x ∈ A
inst✝ : DecidablePred fun x => x ∈ A \ {0}
⊢ ∀ n > 0, n ∈ A \ {0} ↔ n ∈ A
state_after: no goals
tactic: aesop
Theorem: MeasurableSpace.ae_induction_on_inter
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝¹ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
β : Type u_6
inst✝ : MeasurableSpace β
μ : Measure β
C : β → Set α → Prop
s : Set (Set α)
m : MeasurableSpace α
h_eq : m = generateFrom s
h_inter : IsPiSystem s
h_empty : ∀ᵐ (x : β) ∂μ, C x ∅
h_basic : ∀ᵐ (x : β) ∂μ, ∀ t ∈ s, C x t
h_compl : ∀ᵐ (x : β) ∂μ, ∀ (t : Set α), MeasurableSet t → C x t → C x tᶜ
h_union :
  ∀ᵐ (x : β) ∂μ,
    ∀ (f : ℕ → Set α),
      Pairwise (Disjoint on f) → (∀ (i : ℕ), MeasurableSet (f i)) → (∀ (i : ℕ), C x (f i)) → C x (⋃ i, f i)
⊢ ∀ᵐ (x : β) ∂μ, ∀ ⦃t : Set α⦄, MeasurableSet t → C x t
state_after: no goals
tactic: filter_upwards [h_empty, h_basic, h_compl, h_union] with x hx_empty hx_basic hx_compl hx_union
    using MeasurableSpace.induction_on_inter h_eq h_inter hx_empty hx_basic hx_compl hx_union
Theorem: AddSemiconjBy.addOrderOf_eq
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
⊢ orderOf x = orderOf y
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
⊢ ∀ (n : ℕ), x ^ n = 1 ↔ y ^ n = 1
tactic: rw [orderOf_eq_orderOf_iff]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
⊢ ∀ (n : ℕ), x ^ n = 1 ↔ y ^ n = 1
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ x ^ n = 1 ↔ y ^ n = 1
tactic: intro n
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ x ^ n = 1 ↔ y ^ n = 1
state_after: no goals
tactic: exact (h.pow_right n).eq_one_iff
Theorem: MeasureTheory.le_hitting
File: Mathlib/Probability/Process/HittingTime.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω✝ : Ω
m : ι
hnm : n ≤ m
ω : Ω
⊢ n ≤ hitting u s n m ω
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω✝ : Ω
m : ι
hnm : n ≤ m
ω : Ω
⊢ n ≤ if ∃ j ∈ Set.Icc n m, u j ω ∈ s then sInf (Set.Icc n m ∩ {i | u i ω ∈ s}) else m
tactic: simp only [hitting]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω✝ : Ω
m : ι
hnm : n ≤ m
ω : Ω
⊢ n ≤ if ∃ j ∈ Set.Icc n m, u j ω ∈ s then sInf (Set.Icc n m ∩ {i | u i ω ∈ s}) else m
state_after: case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω✝ : Ω
m : ι
hnm : n ≤ m
ω : Ω
h : ∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ n ≤ sInf (Set.Icc n m ∩ {i | u i ω ∈ s})

case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω✝ : Ω
m : ι
hnm : n ≤ m
ω : Ω
h : ¬∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ n ≤ m
tactic: split_ifs with h
Theorem: Ordinal.add_omega_opow
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
h : a < ω ^ b
⊢ a + ω ^ b = ω ^ b
state_after: a b : Ordinal.{u_1}
h : a < ω ^ b
⊢ a + ω ^ b ≤ ω ^ b
tactic: refine le_antisymm ?_ (le_add_left _ _)
state_before: a b : Ordinal.{u_1}
h : a < ω ^ b
⊢ a + ω ^ b ≤ ω ^ b
state_after: case H₁
a : Ordinal.{u_1}
h : a < ω ^ 0
⊢ a + ω ^ 0 ≤ ω ^ 0

case H₂
a b : Ordinal.{u_1}
a✝ : a < ω ^ b → a + ω ^ b ≤ ω ^ b
h : a < ω ^ succ b
⊢ a + ω ^ succ b ≤ ω ^ succ b

case H₃
a b : Ordinal.{u_1}
l : b.IsLimit
IH : ∀ o' < b, a < ω ^ o' → a + ω ^ o' ≤ ω ^ o'
h : a < ω ^ b
⊢ a + ω ^ b ≤ ω ^ b
tactic: induction' b using limitRecOn with b _ b l IH
Theorem: Equiv.Perm.subtypeCongr.refl
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
⊢ subtypeCongr (Equiv.refl { a // p a }) (Equiv.refl { a // ¬p a }) = Equiv.refl ε
state_after: case H
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
⊢ (subtypeCongr (Equiv.refl { a // p a }) (Equiv.refl { a // ¬p a })) x = (Equiv.refl ε) x
tactic: ext x
state_before: case H
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
⊢ (subtypeCongr (Equiv.refl { a // p a }) (Equiv.refl { a // ¬p a })) x = (Equiv.refl ε) x
state_after: no goals
tactic: by_cases h : p x <;> simp [h]
Theorem: CategoryTheory.ConcreteCategory.isIso_iff_bijective
File: Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).ReflectsIsomorphisms
X Y : C
f : X ⟶ Y
⊢ IsIso f ↔ Function.Bijective ((forget C).map f)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).ReflectsIsomorphisms
X Y : C
f : X ⟶ Y
⊢ IsIso f ↔ IsIso ((forget C).map f)
tactic: rw [← CategoryTheory.isIso_iff_bijective]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).ReflectsIsomorphisms
X Y : C
f : X ⟶ Y
⊢ IsIso f ↔ IsIso ((forget C).map f)
state_after: no goals
tactic: exact ⟨fun _ ↦ inferInstance, fun _ ↦ isIso_of_reflects_iso f (forget C)⟩
Theorem: AdjoinRoot.powerBasis'_gen
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : g.Monic
i : Fin g.natDegree
⊢ (powerBasisAux' hg) i = root g ^ ↑i
state_after: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : g.Monic
i : Fin g.natDegree
⊢ (mk g) (∑ i_1 : Fin g.natDegree, (monomial ↑i_1) (Function.update 0 i 1 i_1)) = root g ^ ↑i
tactic: simp only [powerBasisAux', Basis.coe_ofEquivFun, LinearEquiv.coe_symm_mk]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : g.Monic
i : Fin g.natDegree
⊢ (mk g) (∑ i_1 : Fin g.natDegree, (monomial ↑i_1) (Function.update 0 i 1 i_1)) = root g ^ ↑i
state_after: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : g.Monic
i : Fin g.natDegree
⊢ (mk g) ((monomial ↑i) (Function.update 0 i 1 i)) = root g ^ ↑i

case h₀
R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : g.Monic
i : Fin g.natDegree
⊢ ∀ b ∈ Finset.univ, b ≠ i → (monomial ↑b) (Function.update 0 i 1 b) = 0

case h₁
R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : g.Monic
i : Fin g.natDegree
⊢ i ∉ Finset.univ → (monomial ↑i) (Function.update 0 i 1 i) = 0
tactic: rw [Finset.sum_eq_single i]
Theorem: Finsupp.inner_sum
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
ι : Type u_4
l : ι →₀ 𝕜
v : ι → E
x : E
⊢ ⟪x, l.sum fun i a => a • v i⟫_𝕜 = l.sum fun i a => a • ⟪x, v i⟫_𝕜
state_after: case h.e'_3
𝕜 : 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
ι : Type u_4
l : ι →₀ 𝕜
v : ι → E
x : E
⊢ (l.sum fun i a => a • ⟪x, v i⟫_𝕜) = ∑ i ∈ l.support, ⟪x, l i • v i⟫_𝕜
tactic: convert _root_.inner_sum (𝕜 := 𝕜) l.support (fun a => l a • v a) x
state_before: case h.e'_3
𝕜 : 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
ι : Type u_4
l : ι →₀ 𝕜
v : ι → E
x : E
⊢ (l.sum fun i a => a • ⟪x, v i⟫_𝕜) = ∑ i ∈ l.support, ⟪x, l i • v i⟫_𝕜
state_after: no goals
tactic: simp only [inner_smul_right, Finsupp.sum, smul_eq_mul]
Theorem: PEquiv.mul_matrix_apply
File: Mathlib/Data/Matrix/PEquiv.lean

Proof steps:
state_before: k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : Semiring α
f : l ≃. m
M : Matrix m n α
i : l
j : n
⊢ (f.toMatrix * M) i j = Option.casesOn (f i) 0 fun fi => M fi j
state_after: k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : Semiring α
f : l ≃. m
M : Matrix m n α
i : l
j : n
⊢ ∑ j_1 : m, (if j_1 ∈ f i then 1 else 0) * M j_1 j = Option.rec 0 (fun val => M val j) (f i)
tactic: dsimp [toMatrix, Matrix.mul_apply]
state_before: k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : Semiring α
f : l ≃. m
M : Matrix m n α
i : l
j : n
⊢ ∑ j_1 : m, (if j_1 ∈ f i then 1 else 0) * M j_1 j = Option.rec 0 (fun val => M val j) (f i)
state_after: case none
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : Semiring α
f : l ≃. m
M : Matrix m n α
i : l
j : n
h : f i = none
⊢ ∑ j_1 : m, (if j_1 ∈ none then 1 else 0) * M j_1 j = Option.rec 0 (fun val => M val j) none

case some
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : Semiring α
f : l ≃. m
M : Matrix m n α
i : l
j : n
fi : m
h : f i = some fi
⊢ ∑ j_1 : m, (if j_1 ∈ some fi then 1 else 0) * M j_1 j = Option.rec 0 (fun val => M val j) (some fi)
tactic: cases' h : f i with fi
Theorem: CochainComplex.mappingCone.lift_f_snd_v
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.217928, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cocycle K F 1
β : Cochain K G 0
eq : δ 0 1 β + (↑α).comp (Cochain.ofHom φ) ⋯ = 0
p q : ℤ
hpq : p + 0 = q
⊢ (lift φ α β eq).f p ≫ (snd φ).v p q hpq = β.v p q hpq
state_after: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.217928, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cocycle K F 1
β : Cochain K G 0
eq : δ 0 1 β + (↑α).comp (Cochain.ofHom φ) ⋯ = 0
q : ℤ
hpq : q + 0 = q
⊢ (lift φ α β eq).f q ≫ (snd φ).v q q hpq = β.v q q hpq
tactic: obtain rfl : q = p := by omega
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.217928, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cocycle K F 1
β : Cochain K G 0
eq : δ 0 1 β + (↑α).comp (Cochain.ofHom φ) ⋯ = 0
q : ℤ
hpq : q + 0 = q
⊢ (lift φ α β eq).f q ≫ (snd φ).v q q hpq = β.v q q hpq
state_after: no goals
tactic: simp [lift]
Theorem: StrictMonoOn.exists_slope_lt_deriv
File: Mathlib/Analysis/Convex/Deriv.lean

Proof steps:
state_before: x y : ℝ
f : ℝ → ℝ
hf : ContinuousOn f (Icc x y)
hxy : x < y
hf'_mono : StrictMonoOn (deriv f) (Ioo x y)
⊢ ∃ a ∈ Ioo x y, (f y - f x) / (y - x) < deriv f a
state_after: case pos
x y : ℝ
f : ℝ → ℝ
hf : ContinuousOn f (Icc x y)
hxy : x < y
hf'_mono : StrictMonoOn (deriv f) (Ioo x y)
h : ∀ w ∈ Ioo x y, deriv f w ≠ 0
⊢ ∃ a ∈ Ioo x y, (f y - f x) / (y - x) < deriv f a

case neg
x y : ℝ
f : ℝ → ℝ
hf : ContinuousOn f (Icc x y)
hxy : x < y
hf'_mono : StrictMonoOn (deriv f) (Ioo x y)
h : ¬∀ w ∈ Ioo x y, deriv f w ≠ 0
⊢ ∃ a ∈ Ioo x y, (f y - f x) / (y - x) < deriv f a
tactic: by_cases h : ∀ w ∈ Ioo x y, deriv f w ≠ 0
Theorem: Function.Injective.noZeroSMulDivisors
File: Mathlib/Algebra/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
R✝ : Type u_2
k : Type u_3
S : Type u_4
M✝ : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
R : Type u_9
M : Type u_10
N : Type u_11
inst✝⁵ : Zero R
inst✝⁴ : Zero M
inst✝³ : Zero N
inst✝² : SMul R M
inst✝¹ : SMul R N
inst✝ : NoZeroSMulDivisors R N
f : M → N
hf : Injective f
h0 : f 0 = 0
hs : ∀ (c : R) (x : M), f (c • x) = c • f x
x✝¹ : R
x✝ : M
h : x✝¹ • x✝ = 0
⊢ x✝¹ • f x✝ = 0
state_after: no goals
tactic: rw [← hs, h, h0]
Theorem: Finset.lcm_dvd_iff
File: Mathlib/Algebra/GCDMonoid/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ s.lcm f ∣ a ↔ ∀ b ∈ s, f b ∣ a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∀ b ∈ Multiset.map f s.val, b ∣ a) ↔ ∀ b ∈ s, f b ∣ a
tactic: apply Iff.trans Multiset.lcm_dvd
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∀ b ∈ Multiset.map f s.val, b ∣ a) ↔ ∀ b ∈ s, f b ∣ a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∀ (b : α), ∀ x ∈ s.val, f x = b → b ∣ a) ↔ ∀ b ∈ s, f b ∣ a
tactic: simp only [Multiset.mem_map, and_imp, exists_imp]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∀ (b : α), ∀ x ∈ s.val, f x = b → b ∣ a) ↔ ∀ b ∈ s, f b ∣ a
state_after: no goals
tactic: exact ⟨fun k b hb ↦ k _ _ hb rfl, fun k a' b hb h ↦ h ▸ k _ hb⟩
Theorem: Function.Injective.sSameSide_map_iff
File: Mathlib/Analysis/Convex/Side.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
hf : Function.Injective ⇑f
⊢ (map f s).SSameSide (f x) (f y) ↔ s.SSameSide x y
state_after: no goals
tactic: simp_rw [SSameSide, hf.wSameSide_map_iff, mem_map_iff_mem_of_injective hf]
Theorem: CategoryTheory.GrothendieckTopology.isGLB_sInf
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
s : Set (GrothendieckTopology C)
⊢ IsGLB s (sInf s)
state_after: case refine_1
C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
s : Set (GrothendieckTopology C)
⊢ ∀ {x y : GrothendieckTopology C}, x.sieves ≤ y.sieves ↔ x ≤ y

case refine_2
C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
s : Set (GrothendieckTopology C)
⊢ IsGLB (sieves '' s) (sInf s).sieves
tactic: refine @IsGLB.of_image _ _ _ _ sieves ?_ _ _ ?_
Theorem: Cardinal.card_le_of
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β α : Type u
n : ℕ
H : ∀ (s : Finset α), s.card ≤ n
⊢ #α ≤ ↑n
state_after: α✝ β α : Type u
n : ℕ
H : ↑n < #α
⊢ ∃ s, n < s.card
tactic: contrapose! H
state_before: α✝ β α : Type u
n : ℕ
H : ↑n < #α
⊢ ∃ s, n < s.card
state_after: α✝ β α : Type u
n : ℕ
H : ↑n < #α
⊢ ↑(n + 1) ≤ #α
tactic: apply exists_finset_le_card α (n+1)
state_before: α✝ β α : Type u
n : ℕ
H : ↑n < #α
⊢ ↑(n + 1) ≤ #α
state_after: no goals
tactic: simpa only [nat_succ, succ_le_iff] using H
Theorem: IsGroupHom.inv_iff_ker'
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
⊢ f a = f b ↔ a⁻¹ * b ∈ ker f
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
⊢ f a = f b ↔ f (a⁻¹ * b) = 1
tactic: rw [mem_ker]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
⊢ f a = f b ↔ f (a⁻¹ * b) = 1
state_after: no goals
tactic: exact one_iff_ker_inv' hf _ _
Theorem: LinearMap.det_toMatrix'
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type u_3
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι✝ : Type u_4
inst✝⁶ : DecidableEq ι✝
inst✝⁵ : Fintype ι✝
e : Basis ι✝ R M
A : Type u_5
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type u_6
inst✝² : Fintype κ
ι : Type u_7
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f : (ι → A) →ₗ[A] ι → A
⊢ (toMatrix' f).det = LinearMap.det f
state_after: no goals
tactic: simp [← toMatrix_eq_toMatrix']
Theorem: Finset.sum_smul_const_vsub_eq_neg_weightedVSub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p₂ : ι → P
p₁ : P
h : ∑ i ∈ s, w i = 0
⊢ ∑ i ∈ s, w i • (p₁ -ᵥ p₂ i) = -(s.weightedVSub p₂) w
state_after: no goals
tactic: rw [sum_smul_vsub_eq_weightedVSub_sub, s.weightedVSub_apply_const _ _ h, zero_sub]
Theorem: _private.Mathlib.Data.Finset.Union.0.Finset.pairwiseDisjoint_fibers
File: Mathlib/Data/Finset/Union.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
x' : β
hx : x' ∈ ↑t
y' : β
hy : y' ∈ ↑t
hne : x' ≠ y'
⊢ (Disjoint on fun a => filter (fun x => f x = a) s) x' y'
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
x' : β
hx : x' ∈ ↑t
y' : β
hy : y' ∈ ↑t
hne : x' ≠ y'
⊢ ∀ ⦃a : α⦄, a ∈ s ∧ f a = x' → ¬(a ∈ s ∧ f a = y')
tactic: simp_rw [disjoint_left, mem_filter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
x' : β
hx : x' ∈ ↑t
y' : β
hy : y' ∈ ↑t
hne : x' ≠ y'
⊢ ∀ ⦃a : α⦄, a ∈ s ∧ f a = x' → ¬(a ∈ s ∧ f a = y')
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
i : α
left✝¹ : i ∈ s
hx : f i ∈ ↑t
left✝ : i ∈ s
hy : f i ∈ ↑t
hne : f i ≠ f i
⊢ False
tactic: rintro i ⟨_, rfl⟩ ⟨_, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
i : α
left✝¹ : i ∈ s
hx : f i ∈ ↑t
left✝ : i ∈ s
hy : f i ∈ ↑t
hne : f i ≠ f i
⊢ False
state_after: no goals
tactic: exact hne rfl
Theorem: Nat.minSqFac_has_prop
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n : ℕ
⊢ n.MinSqFacProp n.minSqFac
state_after: s : Finset ℕ
m n✝ p n : ℕ
⊢ n.MinSqFacProp (if 2 ∣ n then if 2 ∣ n / 2 then some 2 else (n / 2).minSqFacAux 3 else n.minSqFacAux 3)
tactic: dsimp only [minSqFac]
state_before: s : Finset ℕ
m n✝ p n : ℕ
⊢ n.MinSqFacProp (if 2 ∣ n then if 2 ∣ n / 2 then some 2 else (n / 2).minSqFacAux 3 else n.minSqFacAux 3)
state_after: case pos
s : Finset ℕ
m n✝ p n : ℕ
d2 : 2 ∣ n
d4 : 2 ∣ n / 2
⊢ n.MinSqFacProp (some 2)

case neg
s : Finset ℕ
m n✝ p n : ℕ
d2 : 2 ∣ n
d4 : ¬2 ∣ n / 2
⊢ n.MinSqFacProp ((n / 2).minSqFacAux 3)

case neg
s : Finset ℕ
m n✝ p n : ℕ
d2 : ¬2 ∣ n
⊢ n.MinSqFacProp (n.minSqFacAux 3)
tactic: split_ifs with d2 d4
Theorem: sup_iSup
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
inst✝ : Nonempty ι
f : ι → α
a : α
⊢ a ⊔ ⨆ x, f x = ⨆ x, a ⊔ f x
state_after: no goals
tactic: rw [iSup_sup_eq, iSup_const]
Theorem: PMF.toMeasure_apply_inter_support
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : MeasurableSpace α
p : PMF α
s t : Set α
hs : MeasurableSet s
hp : MeasurableSet p.support
⊢ p.toMeasure (s ∩ p.support) = p.toMeasure s
state_after: no goals
tactic: simp [p.toMeasure_apply_eq_toOuterMeasure_apply s hs,
    p.toMeasure_apply_eq_toOuterMeasure_apply _ (hs.inter hp)]