1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Ideal.comap_eq_top_iff
File: Mathlib/RingTheory/Ideal/Maps.lean

tactic: rw [h, comap_top]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
I : Ideal S
h : I = ⊤
⊢ comap f I = ⊤
state_after: no goals
Theorem: Finset.exists_next_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: simpa
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x✝ x : α
s : Finset α
h : ∃ y ∈ s, x < y
y : α
hy : y ∈ s ∧ x < y
⊢ y ∈ s ∧ x < y
state_after: no goals

tactic: simp
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x✝ x : α
s : Finset α
h : ∃ y ∈ s, x < y
Hne : (filter (fun x_1 => x < x_1) s).Nonempty
aux : (filter (fun x_1 => x < x_1) s).min' Hne ∈ s ∧ x < (filter (fun x_1 => x < x_1) s).min' Hne
⊢ x < (filter (fun x_1 => x < x_1) s).min' Hne
state_after: no goals

tactic: simpa
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x✝ x : α
s : Finset α
h : ∃ y ∈ s, x < y
Hne : (filter (fun x_1 => x < x_1) s).Nonempty
aux : (filter (fun x_1 => x < x_1) s).min' Hne ∈ s ∧ x < (filter (fun x_1 => x < x_1) s).min' Hne
z : α
hzs : z ∈ s
hz : x < z
⊢ x < z
state_after: no goals
Theorem: zpow_nonneg
File: Mathlib/Algebra/Order/Field/Defs.lean

tactic: rw [zpow_natCast]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ ↑n
state_after: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ n

tactic: exact pow_nonneg ha _
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ n
state_after: no goals

tactic: rw [zpow_neg, inv_nonneg, zpow_natCast]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ (-↑(n + 1))
state_after: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ (n + 1)

tactic: exact pow_nonneg ha _
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ (n + 1)
state_after: no goals
Theorem: List.Ico.filter_lt_of_succ_bot
File: Mathlib/Data/List/Intervals.lean

tactic: have r : min m (n + 1) = n + 1 := (@inf_eq_right _ _ m (n + 1)).mpr hnm
state_before: n m : ℕ
hnm : n < m
⊢ filter (fun x => decide (x < n + 1)) (Ico n m) = [n]
state_after: n m : ℕ
hnm : n < m
r : min m (n + 1) = n + 1
⊢ filter (fun x => decide (x < n + 1)) (Ico n m) = [n]

tactic: simp [filter_lt n m (n + 1), r]
state_before: n m : ℕ
hnm : n < m
r : min m (n + 1) = n + 1
⊢ filter (fun x => decide (x < n + 1)) (Ico n m) = [n]
state_after: no goals
Theorem: String.prev_of_valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp only [prev]
state_before: cs : List Char
c : Char
cs' : List Char
⊢ { data := cs ++ c :: cs' }.prev { byteIdx := utf8Len cs + c.utf8Size } = { byteIdx := utf8Len cs }
state_after: cs : List Char
c : Char
cs' : List Char
⊢ (if { byteIdx := utf8Len cs + c.utf8Size } = 0 then 0
    else utf8PrevAux (cs ++ c :: cs') 0 { byteIdx := utf8Len cs + c.utf8Size }) =
    { byteIdx := utf8Len cs }

tactic: refine (if_neg (Pos.ne_of_gt add_csize_pos)).trans ?_
state_before: cs : List Char
c : Char
cs' : List Char
⊢ (if { byteIdx := utf8Len cs + c.utf8Size } = 0 then 0
    else utf8PrevAux (cs ++ c :: cs') 0 { byteIdx := utf8Len cs + c.utf8Size }) =
    { byteIdx := utf8Len cs }
state_after: cs : List Char
c : Char
cs' : List Char
⊢ utf8PrevAux (cs ++ c :: cs') 0 { byteIdx := utf8Len cs + c.utf8Size } = { byteIdx := utf8Len cs }

tactic: rw [utf8PrevAux_of_valid] <;> simp
state_before: cs : List Char
c : Char
cs' : List Char
⊢ utf8PrevAux (cs ++ c :: cs') 0 { byteIdx := utf8Len cs + c.utf8Size } = { byteIdx := utf8Len cs }
state_after: no goals
Theorem: Filter.Frequently.uncurry
File: Mathlib/Order/Filter/Prod.lean

tactic: simpa only [not_frequently] using h.curry
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
la : Filter α
lb : Filter β
p : α → β → Prop
h✝ : ∃ᶠ (x : α) in la, ∃ᶠ (y : β) in lb, p x y
h : ∀ᶠ (x : α × β) in la ×ˢ lb, ¬(fun xy => p xy.1 xy.2) x
⊢ ∀ᶠ (x : α) in la, ¬(fun x => ∃ᶠ (y : β) in lb, p x y) x
state_after: no goals
Theorem: unique_subtype_iff_exists_unique
File: Mathlib/Logic/Unique.lean

tactic: congr
state_before: α : Sort u_1
p : α → Prop
x✝¹ : ∃! a, p a
a : α
ha : (fun a => p a) a
he : ∀ (y : α), (fun a => p a) y → y = a
x✝ : Subtype p
b : α
hb : p b
⊢ ⟨b, hb⟩ = default
state_after: case e_val
α : Sort u_1
p : α → Prop
x✝¹ : ∃! a, p a
a : α
ha : (fun a => p a) a
he : ∀ (y : α), (fun a => p a) y → y = a
x✝ : Subtype p
b : α
hb : p b
⊢ b = a

tactic: exact he b hb
state_before: case e_val
α : Sort u_1
p : α → Prop
x✝¹ : ∃! a, p a
a : α
ha : (fun a => p a) a
he : ∀ (y : α), (fun a => p a) y → y = a
x✝ : Subtype p
b : α
hb : p b
⊢ b = a
state_after: no goals
Theorem: Hyperreal.infinite_abs_iff
File: Mathlib/Data/Real/Hyperreal.lean

tactic: cases le_total 0 x <;> simp [*, abs_of_nonneg, abs_of_nonpos, infinite_neg]
state_before: x : ℝ*
⊢ |x|.Infinite ↔ x.Infinite
state_after: no goals
Theorem: Real.strictMono_eulerMascheroniSeq
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

tactic: refine strictMono_nat_of_lt_succ (fun n ↦ ?_)
state_before: ⊢ StrictMono eulerMascheroniSeq
state_after: n : ℕ
⊢ eulerMascheroniSeq n < eulerMascheroniSeq (n + 1)

tactic: rw [eulerMascheroniSeq, eulerMascheroniSeq, ← sub_pos, sub_sub_sub_comm,
  harmonic_succ, add_comm, Rat.cast_add, add_sub_cancel_right,
  ← log_div (by positivity) (by positivity), add_div, Nat.cast_add_one,
  Nat.cast_add_one, div_self (by positivity), sub_pos, one_div, Rat.cast_inv, Rat.cast_add,
  Rat.cast_one, Rat.cast_natCast]
state_before: n : ℕ
⊢ eulerMascheroniSeq n < eulerMascheroniSeq (n + 1)
state_after: n : ℕ
⊢ log (1 + (↑n + 1)⁻¹) < (↑n + 1)⁻¹

tactic: refine (log_lt_sub_one_of_pos ?_ (ne_of_gt <| lt_add_of_pos_right _ ?_)).trans_le (le_of_eq ?_)
state_before: n : ℕ
⊢ log (1 + (↑n + 1)⁻¹) < (↑n + 1)⁻¹
state_after: case refine_1
n : ℕ
⊢ 0 < 1 + (↑n + 1)⁻¹

case refine_2
n : ℕ
⊢ 0 < (↑n + 1)⁻¹

case refine_3
n : ℕ
⊢ 1 + (↑n + 1)⁻¹ - 1 = (↑n + 1)⁻¹

tactic: positivity
state_before: n : ℕ
⊢ ↑(n + 1) + 1 ≠ 0
state_after: no goals

tactic: positivity
state_before: n : ℕ
⊢ ↑n + 1 ≠ 0
state_after: no goals

tactic: positivity
state_before: case refine_1
n : ℕ
⊢ 0 < 1 + (↑n + 1)⁻¹
state_after: no goals

tactic: positivity
state_before: case refine_2
n : ℕ
⊢ 0 < (↑n + 1)⁻¹
state_after: no goals

tactic: simp only [add_sub_cancel_left]
state_before: case refine_3
n : ℕ
⊢ 1 + (↑n + 1)⁻¹ - 1 = (↑n + 1)⁻¹
state_after: no goals
Theorem: PowerBasis.constr_pow_gen
File: Mathlib/RingTheory/PowerBasis.lean

tactic: convert pb.constr_pow_aeval hy X <;> rw [aeval_X]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type u_6
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_7
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : (aeval y) (minpoly A pb.gen) = 0
⊢ ((pb.basis.constr A) fun i => y ^ ↑i) pb.gen = y
state_after: no goals
Theorem: MeasureTheory.SignedMeasure.restrictNonposSeq_measurableSet
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [restrictNonposSeq]
state_before: case succ
α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasurableSet (MeasureTheory.SignedMeasure.restrictNonposSeq s i (n✝ + 1))
state_after: case succ
α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasurableSet
    (MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \
        ⋃ k,
          ⋃ (H : k ≤ n✝),
            let_fun this := ⋯;
            MeasureTheory.SignedMeasure.restrictNonposSeq s i k))

tactic: exact someExistsOneDivLT_measurableSet
state_before: case succ
α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasurableSet
    (MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \
        ⋃ k,
          ⋃ (H : k ≤ n✝),
            let_fun this := ⋯;
            MeasureTheory.SignedMeasure.restrictNonposSeq s i k))
state_after: no goals
Theorem: MeasureTheory.snorm'_trim
File: Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean

tactic: simp_rw [snorm']
state_before: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ snorm' f q (μ.trim hm) = snorm' f q μ
state_after: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm) ^ (1 / q) = (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q)

tactic: congr 1
state_before: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm) ^ (1 / q) = (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q)
state_after: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm = ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ

tactic: refine lintegral_trim hm ?_
state_before: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm = ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ
state_after: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ↑‖f a‖₊ ^ q

tactic: refine @Measurable.pow_const _ _ _ _ _ _ _ m _ (@Measurable.coe_nnreal_ennreal _ m _ ?_) q
state_before: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ↑‖f a‖₊ ^ q
state_after: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ‖f a‖₊

tactic: apply @StronglyMeasurable.measurable
state_before: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ‖f a‖₊
state_after: case e_a.hf
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun a => ‖f a‖₊

tactic: exact @StronglyMeasurable.nnnorm α m _ _ _ hf
state_before: case e_a.hf
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun a => ‖f a‖₊
state_after: no goals
Theorem: Finset.card_image_of_injOn
File: Mathlib/Data/Finset/Card.lean

tactic: simp only [card, image_val_of_injOn H, card_map]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
H : Set.InjOn f ↑s
⊢ (image f s).card = s.card
state_after: no goals
Theorem: Ordinal.toPGame_moveLeft
File: Mathlib/SetTheory/Game/Ordinal.lean

tactic: simp
state_before: o : Ordinal.{u_1}
i : ↑(Set.Iio o)
⊢ o.toPGame.moveLeft (toLeftMovesToPGame i) = (↑i).toPGame
state_after: no goals
Theorem: Set.toFinset_compl
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝⁴ : DecidableEq α
inst✝³ : Fintype ↑s
inst✝² : Fintype ↑t
inst✝¹ : Fintype α
inst✝ : Fintype ↑sᶜ
⊢ sᶜ.toFinset = s.toFinsetᶜ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝⁴ : DecidableEq α
inst✝³ : Fintype ↑s
inst✝² : Fintype ↑t
inst✝¹ : Fintype α
inst✝ : Fintype ↑sᶜ
a✝ : α
⊢ a✝ ∈ sᶜ.toFinset ↔ a✝ ∈ s.toFinsetᶜ

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝⁴ : DecidableEq α
inst✝³ : Fintype ↑s
inst✝² : Fintype ↑t
inst✝¹ : Fintype α
inst✝ : Fintype ↑sᶜ
a✝ : α
⊢ a✝ ∈ sᶜ.toFinset ↔ a✝ ∈ s.toFinsetᶜ
state_after: no goals
Theorem: Stream'.length_take
File: Mathlib/Data/Stream/Init.lean

tactic: induction n generalizing s <;> simp [*, take_succ]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ (take n s).length = n
state_after: no goals
Theorem: Primrec.to_comp
File: Mathlib/Computability/Partrec.lean

tactic: simp
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → σ
hf : Primrec f
n : ℕ
⊢ (do
      let n ← (↑fun n => encode (Option.map f (decode n))) n
      ↑n.ppred) =
    (↑(decode n)).bind fun a => map encode (↑f a)
state_after: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → σ
hf : Primrec f
n : ℕ
⊢ ↑(encode (Option.map f (decode n))).ppred = (↑(decode n)).bind fun a => Part.some (encode (f a))

tactic: cases decode (α := α) n <;> simp
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → σ
hf : Primrec f
n : ℕ
⊢ ↑(encode (Option.map f (decode n))).ppred = (↑(decode n)).bind fun a => Part.some (encode (f a))
state_after: no goals
Theorem: IsSelfAdjoint.hasEigenvector_of_isLocalExtrOn
File: Mathlib/Analysis/InnerProductSpace/Rayleigh.lean

tactic: refine ⟨?_, hx₀⟩
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hx₀ : x₀ ≠ 0
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
⊢ HasEigenvector (↑T) (↑(T.rayleighQuotient x₀)) x₀
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hx₀ : x₀ ≠ 0
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
⊢ x₀ ∈ eigenspace ↑T ↑(T.rayleighQuotient x₀)

tactic: rw [Module.End.mem_eigenspace_iff]
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hx₀ : x₀ ≠ 0
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
⊢ x₀ ∈ eigenspace ↑T ↑(T.rayleighQuotient x₀)
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hx₀ : x₀ ≠ 0
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
⊢ ↑T x₀ = ↑(T.rayleighQuotient x₀) • x₀

tactic: exact hT.eq_smul_self_of_isLocalExtrOn hextr
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hx₀ : x₀ ≠ 0
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
⊢ ↑T x₀ = ↑(T.rayleighQuotient x₀) • x₀
state_after: no goals
Theorem: List.prod_eq_foldr
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: rw [prod_cons, foldr_cons, prod_eq_foldr]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a✝ a : M
l : List M
⊢ (a :: l).prod = foldr (fun x x_1 => x * x_1) 1 (a :: l)
state_after: no goals
Theorem: Metric.mem_sphere_comm
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [mem_sphere', mem_sphere]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ x ∈ sphere y ε ↔ y ∈ sphere x ε
state_after: no goals
Theorem: Nat.ModEq.mul_left_cancel'
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp [modEq_iff_dvd, ← mul_sub, mul_dvd_mul_iff_left (by simp [hc] : (c : ℤ) ≠ 0)]
state_before: m✝ n a✝ b✝ c✝ d a b c m : ℕ
hc : c ≠ 0
⊢ c * a ≡ c * b [MOD c * m] → a ≡ b [MOD m]
state_after: no goals

tactic: simp [hc]
state_before: m✝ n a✝ b✝ c✝ d a b c m : ℕ
hc : c ≠ 0
⊢ ↑c ≠ 0
state_after: no goals
Theorem: Primrec.list_findIdx₁
File: Mathlib/Computability/Primrec.lean

tactic: simp [List.findIdx_cons]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
p : α → β → Bool
hp : Primrec₂ p
a : β
l : List β
n : α
⊢ (bif p (id n) a then 0 else (List.findIdx (p n) l).succ) = List.findIdx (p n) (a :: l)
state_after: no goals
Theorem: Ordinal.nfpFamily_le_apply
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← not_iff_not]
state_before: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
inst✝ : Nonempty ι
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
⊢ (∃ i, nfpFamily f a ≤ f i b) ↔ nfpFamily f a ≤ b
state_after: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
inst✝ : Nonempty ι
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
⊢ (¬∃ i, nfpFamily f a ≤ f i b) ↔ ¬nfpFamily f a ≤ b

tactic: push_neg
state_before: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
inst✝ : Nonempty ι
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
⊢ (¬∃ i, nfpFamily f a ≤ f i b) ↔ ¬nfpFamily f a ≤ b
state_after: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
inst✝ : Nonempty ι
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
⊢ (∀ (i : ι), f i b < nfpFamily f a) ↔ b < nfpFamily f a

tactic: exact apply_lt_nfpFamily_iff H
state_before: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
inst✝ : Nonempty ι
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
⊢ (∀ (i : ι), f i b < nfpFamily f a) ↔ b < nfpFamily f a
state_after: no goals
Theorem: CategoryTheory.Limits.hasFiniteWidePushouts_of_has_finite_limits
File: Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean

tactic: cases nonempty_fintype J
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J✝ : Type v
inst✝ : HasFiniteColimits C
J : Type
x✝ : Finite J
⊢ HasColimitsOfShape (WidePushoutShape J) C
state_after: case intro
C : Type u
inst✝¹ : Category.{v, u} C
J✝ : Type v
inst✝ : HasFiniteColimits C
J : Type
x✝ : Finite J
val✝ : Fintype J
⊢ HasColimitsOfShape (WidePushoutShape J) C

tactic: exact HasFiniteColimits.out _
state_before: case intro
C : Type u
inst✝¹ : Category.{v, u} C
J✝ : Type v
inst✝ : HasFiniteColimits C
J : Type
x✝ : Finite J
val✝ : Fintype J
⊢ HasColimitsOfShape (WidePushoutShape J) C
state_after: no goals
Theorem: LinearMap.BilinForm.isAdjointPair_zero
File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

tactic: simp only [BilinForm.zero_left, BilinForm.zero_right, LinearMap.zero_apply]
state_before: R : Type u_1
M : Type u_2
inst✝¹⁴ : CommSemiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹¹ : CommRing R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
M'✝ : Type u_7
M'' : Type u_8
inst✝⁵ : AddCommMonoid M'✝
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M'✝
inst✝² : Module R M''
B : BilinForm R M
B₁ : BilinForm R₁ M₁
F : BilinForm R M
M' : Type u_9
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B' : BilinForm R M'
f f' : M →ₗ[R] M'
g g' : M' →ₗ[R] M
x : M
y : M'
⊢ (B' (0 x)) y = (B x) (0 y)
state_after: no goals
Theorem: CategoryTheory.OverPresheafAux.YonedaCollection.map₂_comp
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

tactic: ext
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ map₂ F (f ≫ g) = map₂ F f ∘ map₂ F g
state_after: case h.h.w.h.h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝¹ : YonedaCollection F Z
x✝ : Cᵒᵖ
a✝ : (yoneda.obj X).obj x✝
⊢ (map₂ F (f ≫ g) x✝¹).fst.app x✝ a✝ = ((map₂ F f ∘ map₂ F g) x✝¹).fst.app x✝ a✝

case h.h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝ : YonedaCollection F Z
⊢ F.map (eqToHom ⋯) ((map₂ F f ∘ map₂ F g) x✝).snd = (map₂ F (f ≫ g) x✝).snd

tactic: all_goals simp
state_before: case h.h.w.h.h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝¹ : YonedaCollection F Z
x✝ : Cᵒᵖ
a✝ : (yoneda.obj X).obj x✝
⊢ (map₂ F (f ≫ g) x✝¹).fst.app x✝ a✝ = ((map₂ F f ∘ map₂ F g) x✝¹).fst.app x✝ a✝

case h.h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝ : YonedaCollection F Z
⊢ F.map (eqToHom ⋯) ((map₂ F f ∘ map₂ F g) x✝).snd = (map₂ F (f ≫ g) x✝).snd
state_after: no goals

tactic: simp
state_before: case h.h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝ : YonedaCollection F Z
⊢ F.map (eqToHom ⋯) ((map₂ F f ∘ map₂ F g) x✝).snd = (map₂ F (f ≫ g) x✝).snd
state_after: no goals
Theorem: MvPolynomial.support_monomial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
h : Decidable (a = 0)
⊢ ((monomial s) a).support = if a = 0 then ∅ else {s}
state_after: no goals
Theorem: Subgroup.mem_iInf
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
ι : Sort u_5
S : ι → Subgroup G
x : G
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.comp_zero
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: ext p q hpq
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
h : n₁ + n₂ = n₁₂
⊢ z₁.comp 0 h = 0
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ (z₁.comp 0 h).v p q hpq = v 0 p q hpq

tactic: simp only [comp_v _ _ h p _ q rfl (by omega), zero_v, comp_zero]
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ (z₁.comp 0 h).v p q hpq = v 0 p q hpq
state_after: no goals

tactic: omega
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ p + n₁ + n₂ = q
state_after: no goals