1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: iteratedFDerivWithin_two_apply
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: simp only [iteratedFDerivWithin_succ_apply_right hs hz]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
z : E
hs : UniqueDiffOn 𝕜 s
hz : z ∈ s
m : Fin 2 → E
⊢ (iteratedFDerivWithin 𝕜 2 f s z) m = ((fderivWithin 𝕜 (fderivWithin 𝕜 f s) s z) (m 0)) (m 1)
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
z : E
hs : UniqueDiffOn 𝕜 s
hz : z ∈ s
m : Fin 2 → E
⊢ (((iteratedFDerivWithin 𝕜 0 (fun y => fderivWithin 𝕜 (fun y => fderivWithin 𝕜 f s y) s y) s z) (init (init m)))
        (init m (last 0)))
      (m (last 1)) =
    ((fderivWithin 𝕜 (fderivWithin 𝕜 f s) s z) (m 0)) (m 1)

tactic: rfl
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
z : E
hs : UniqueDiffOn 𝕜 s
hz : z ∈ s
m : Fin 2 → E
⊢ (((iteratedFDerivWithin 𝕜 0 (fun y => fderivWithin 𝕜 (fun y => fderivWithin 𝕜 f s y) s y) s z) (init (init m)))
        (init m (last 0)))
      (m (last 1)) =
    ((fderivWithin 𝕜 (fderivWithin 𝕜 f s) s z) (m 0)) (m 1)
state_after: no goals
Theorem: padicNorm.zero
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [padicNorm]
state_before: p : ℕ
⊢ padicNorm p 0 = 0
state_after: no goals
Theorem: Set.iUnion_Ioc_left
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: simp only [← Ioi_inter_Iic, ← iUnion_inter, iUnion_Ioi, univ_inter]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝¹ : Preorder α
a b✝ c : α
inst✝ : NoMinOrder α
b : α
⊢ ⋃ a, Ioc a b = Iic b
state_after: no goals
Theorem: List.splitOnP.go_ne_nil
File: Mathlib/Data/List/Basic.lean

tactic: induction xs generalizing acc <;> simp [go]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
xs acc : List α
⊢ go p xs acc ≠ []
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (acc : List α), go p tail✝ acc ≠ []
acc : List α
⊢ ¬(if p head✝ = true then acc.reverse :: go p tail✝ [] else go p tail✝ (head✝ :: acc)) = []

tactic: split <;> simp [*]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (acc : List α), go p tail✝ acc ≠ []
acc : List α
⊢ ¬(if p head✝ = true then acc.reverse :: go p tail✝ [] else go p tail✝ (head✝ :: acc)) = []
state_after: no goals
Theorem: Batteries.RBNode.toStream_toList'
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: induction t generalizing s <;> simp [*, toStream]
state_before: α : Type u_1
t : RBNode α
s : RBNode.Stream α
⊢ (t.toStream s).toList = t.toList ++ s.toList
state_after: no goals
Theorem: DFinsupp.mapRange.linearEquiv_trans
File: Mathlib/LinearAlgebra/DFinsupp.lean

tactic: simp
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : ι) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → Module R (M i)
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
β : ι → Type u_6
β₁ : ι → Type u_7
β₂ : ι → Type u_8
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
inst✝⁴ : (i : ι) → AddCommMonoid (β₁ i)
inst✝³ : (i : ι) → AddCommMonoid (β₂ i)
inst✝² : (i : ι) → Module R (β i)
inst✝¹ : (i : ι) → Module R (β₁ i)
inst✝ : (i : ι) → Module R (β₂ i)
f : (i : ι) → β i ≃ₗ[R] β₁ i
f₂ : (i : ι) → β₁ i ≃ₗ[R] β₂ i
⊢ ∀ (i : ι), ((fun i x => (f₂ i) x) i ∘ (fun i x => (f i) x) i) 0 = 0
state_after: no goals
Theorem: Concept.snd_subset_snd_iff
File: Mathlib/Order/Concept.lean

tactic: refine ⟨fun h => ?_, fun h => ?_⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
⊢ c.toProd.2 ⊆ d.toProd.2 ↔ d ≤ c
state_after: case refine_1
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.toProd.2 ⊆ d.toProd.2
⊢ d ≤ c

case refine_2
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : d ≤ c
⊢ c.toProd.2 ⊆ d.toProd.2

tactic: rw [← fst_subset_fst_iff, ← c.closure_snd, ← d.closure_snd]
state_before: case refine_1
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.toProd.2 ⊆ d.toProd.2
⊢ d ≤ c
state_after: case refine_1
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.toProd.2 ⊆ d.toProd.2
⊢ extentClosure r d.toProd.2 ⊆ extentClosure r c.toProd.2

tactic: exact extentClosure_anti _ h
state_before: case refine_1
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.toProd.2 ⊆ d.toProd.2
⊢ extentClosure r d.toProd.2 ⊆ extentClosure r c.toProd.2
state_after: no goals

tactic: rw [← c.closure_fst, ← d.closure_fst]
state_before: case refine_2
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : d ≤ c
⊢ c.toProd.2 ⊆ d.toProd.2
state_after: case refine_2
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : d ≤ c
⊢ intentClosure r c.toProd.1 ⊆ intentClosure r d.toProd.1

tactic: exact intentClosure_anti _ h
state_before: case refine_2
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Sort u_5
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : d ≤ c
⊢ intentClosure r c.toProd.1 ⊆ intentClosure r d.toProd.1
state_after: no goals
Theorem: IsNoetherian.iff_fg
File: Mathlib/FieldTheory/Finiteness.lean

tactic: constructor
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ IsNoetherian K V ↔ Module.Finite K V
state_after: case mp
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ IsNoetherian K V → Module.Finite K V

case mpr
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ Module.Finite K V → IsNoetherian K V

tactic: intro h
state_before: case mp
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ IsNoetherian K V → Module.Finite K V
state_after: case mp
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian K V
⊢ Module.Finite K V

tactic: exact
  ⟨⟨finsetBasisIndex K V, by
      convert (finsetBasis K V).span_eq
      simp⟩⟩
state_before: case mp
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian K V
⊢ Module.Finite K V
state_after: no goals

tactic: convert (finsetBasis K V).span_eq
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian K V
⊢ span K ↑(finsetBasisIndex K V) = ⊤
state_after: case h.e'_2.h.e'_6
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian K V
⊢ ↑(finsetBasisIndex K V) = Set.range ⇑(finsetBasis K V)

tactic: simp
state_before: case h.e'_2.h.e'_6
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian K V
⊢ ↑(finsetBasisIndex K V) = Set.range ⇑(finsetBasis K V)
state_after: no goals

tactic: rintro ⟨s, hs⟩
state_before: case mpr
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ Module.Finite K V → IsNoetherian K V
state_after: case mpr.mk.intro
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : span K ↑s = ⊤
⊢ IsNoetherian K V

tactic: rw [IsNoetherian.iff_rank_lt_aleph0, ← rank_top, ← hs]
state_before: case mpr.mk.intro
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : span K ↑s = ⊤
⊢ IsNoetherian K V
state_after: case mpr.mk.intro
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : span K ↑s = ⊤
⊢ Module.rank K ↥(span K ↑s) < ℵ₀

tactic: exact lt_of_le_of_lt (rank_span_le _) s.finite_toSet.lt_aleph0
state_before: case mpr.mk.intro
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : span K ↑s = ⊤
⊢ Module.rank K ↥(span K ↑s) < ℵ₀
state_after: no goals
Theorem: nilpotencyClass_zero
File: Mathlib/RingTheory/Nilpotent/Defs.lean

tactic: constructor <;> simp
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
⊢ 0 ^ (0 + 1) = 0 ∧ 0 ^ 0 ≠ 0
state_after: no goals
Theorem: Int.csSup_mem
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

tactic: convert (greatestOfBdd _ (Classical.choose_spec h2) h1).2.1
state_before: s : Set ℤ
h1 : s.Nonempty
h2 : BddAbove s
⊢ sSup s ∈ s
state_after: case h.e'_4
s : Set ℤ
h1 : s.Nonempty
h2 : BddAbove s
⊢ sSup s = ↑((Classical.choose h2).greatestOfBdd ⋯ h1)

tactic: exact dif_pos ⟨h1, h2⟩
state_before: case h.e'_4
s : Set ℤ
h1 : s.Nonempty
h2 : BddAbove s
⊢ sSup s = ↑((Classical.choose h2).greatestOfBdd ⋯ h1)
state_after: no goals
Theorem: StarAlgEquiv.nnnorm_map
File: Mathlib/Analysis/NormedSpace/Star/Spectrum.lean

tactic: simpa using StarAlgHom.nnnorm_apply_le (symm (φ : A ≃⋆ₐ[ℂ] B)) ((φ : A ≃⋆ₐ[ℂ] B) a)
state_before: F : Type u_1
A : Type u_2
B : Type u_3
inst✝¹² : NormedRing A
inst✝¹¹ : NormedAlgebra ℂ A
inst✝¹⁰ : CompleteSpace A
inst✝⁹ : StarRing A
inst✝⁸ : CstarRing A
inst✝⁷ : NormedRing B
inst✝⁶ : NormedAlgebra ℂ B
inst✝⁵ : CompleteSpace B
inst✝⁴ : StarRing B
inst✝³ : CstarRing B
inst✝² : EquivLike F A B
inst✝¹ : NonUnitalAlgEquivClass F ℂ A B
inst✝ : StarAlgEquivClass F ℂ A B
φ : F
a : A
⊢ ‖a‖₊ ≤ ‖φ a‖₊
state_after: no goals
Theorem: Matrix.pow_sub'
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [← tsub_add_cancel_of_le h, pow_add, Matrix.mul_assoc, mul_nonsing_inv,
  tsub_add_cancel_of_le h, Matrix.mul_one]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℕ
ha : IsUnit A.det
h : n ≤ m
⊢ A ^ (m - n) = A ^ m * (A ^ n)⁻¹
state_after: case h
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℕ
ha : IsUnit A.det
h : n ≤ m
⊢ IsUnit (A ^ n).det

tactic: simpa using ha.pow n
state_before: case h
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℕ
ha : IsUnit A.det
h : n ≤ m
⊢ IsUnit (A ^ n).det
state_after: no goals
Theorem: MulEquiv.comp_right_injective
File: Mathlib/Algebra/Group/Equiv/Basic.lean

tactic: simp [← MonoidHom.comp_assoc]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝³ : EquivLike F α β
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
e : M ≃* N
f : P →* M
⊢ (↑e.symm).comp ((↑e).comp f) = f
state_after: no goals
Theorem: ContDiffBump.tsupport_normed_eq
File: Mathlib/Analysis/Calculus/BumpFunction/Normed.lean

tactic: rw [tsupport, f.support_normed_eq, closure_ball _ f.rOut_pos.ne']
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ tsupport (f.normed μ) = closedBall c f.rOut
state_after: no goals
Theorem: Nat.right_le_pair
File: Mathlib/Data/Nat/Pairing.lean

tactic: by_cases h : a < b <;> simp [pair, h]
state_before: a b : ℕ
⊢ b ≤ pair a b
state_after: case pos
a b : ℕ
h : a < b
⊢ b ≤ b * b + a

tactic: exact le_trans (le_mul_self _) (Nat.le_add_right _ _)
state_before: case pos
a b : ℕ
h : a < b
⊢ b ≤ b * b + a
state_after: no goals
Theorem: YoungDiagram.pos_of_mem_rowLens
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: rw [rowLens, List.mem_map] at hx
state_before: μ : YoungDiagram
x : ℕ
hx : x ∈ μ.rowLens
⊢ 0 < x
state_after: μ : YoungDiagram
x : ℕ
hx : ∃ a ∈ List.range (μ.colLen 0), μ.rowLen a = x
⊢ 0 < x

tactic: obtain ⟨i, hi, rfl : μ.rowLen i = x⟩ := hx
state_before: μ : YoungDiagram
x : ℕ
hx : ∃ a ∈ List.range (μ.colLen 0), μ.rowLen a = x
⊢ 0 < x
state_after: case intro.intro
μ : YoungDiagram
i : ℕ
hi : i ∈ List.range (μ.colLen 0)
⊢ 0 < μ.rowLen i

tactic: rwa [List.mem_range, ← mem_iff_lt_colLen, mem_iff_lt_rowLen] at hi
state_before: case intro.intro
μ : YoungDiagram
i : ℕ
hi : i ∈ List.range (μ.colLen 0)
⊢ 0 < μ.rowLen i
state_after: no goals
Theorem: CategoryTheory.GlueData.t'_iji
File: Mathlib/CategoryTheory/GlueData.lean

tactic: rw [← Category.assoc, ← D.t_fac]
state_before: C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ D.t' i j i = pullback.fst ≫ D.t i j ≫ inv pullback.snd
state_after: C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ D.t' i j i = (D.t' i j i ≫ pullback.snd) ≫ inv pullback.snd

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ D.t' i j i = (D.t' i j i ≫ pullback.snd) ≫ inv pullback.snd
state_after: no goals
Theorem: VitaliFamily.FineSubfamilyOn.measure_le_tsum_of_absolutelyContinuous
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: simp only [subset_union_left, diff_union_self]
state_before: α : Type u_1
inst✝¹ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : v.FineSubfamilyOn f s
inst✝ : SecondCountableTopology α
ρ : Measure α
hρ : ρ ≪ μ
⊢ s ⊆ (s \ ⋃ p ∈ h.index, h.covering p) ∪ ⋃ p ∈ h.index, h.covering p
state_after: no goals

tactic: rw [hρ h.measure_diff_biUnion, zero_add,
  measure_biUnion h.index_countable h.covering_disjoint fun x hx => h.measurableSet_u hx]
state_before: α : Type u_1
inst✝¹ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : v.FineSubfamilyOn f s
inst✝ : SecondCountableTopology α
ρ : Measure α
hρ : ρ ≪ μ
⊢ ρ (s \ ⋃ p ∈ h.index, h.covering p) + ρ (⋃ p ∈ h.index, h.covering p) = ∑' (p : ↑h.index), ρ (h.covering ↑p)
state_after: no goals
Theorem: krullDim_eq_top_of_infiniteDimensionalOrder
File: Mathlib/Order/KrullDimension.lean

tactic: haveI : Inhabited α := ⟨LTSeries.withLength _ 0 0⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m
hm : ∀ (i : LTSeries α), ↑i.length ≤ ⊥
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m
hm : ∀ (i : LTSeries α), ↑i.length ≤ ⊥
this : Inhabited α
⊢ False

tactic: exact not_le_of_lt (WithBot.bot_lt_coe _ : ⊥ < (0 : WithBot (WithTop ℕ))) <| hm default
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m
hm : ∀ (i : LTSeries α), ↑i.length ≤ ⊥
this : Inhabited α
⊢ False
state_after: no goals

tactic: refine (not_lt_of_le (hm (LTSeries.withLength _ (m + 1))) ?_).elim
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ ⊤ ≤ some (some m)
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ some (some m) < ↑(LTSeries.withLength α (m + 1)).length

tactic: erw [WithBot.coe_lt_coe, WithTop.coe_lt_coe]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ some (some m) < ↑(LTSeries.withLength α (m + 1)).length
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ m < ↑(LTSeries.withLength α (m + 1)).length

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ m < ↑(LTSeries.withLength α (m + 1)).length
state_after: no goals
Theorem: ContinuousMap.homotopic_const_iff
File: Mathlib/Topology/Homotopy/Path.lean

tactic: inhabit Y
state_before: X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
⊢ (const Y x₀).Homotopic (const Y x₁) ↔ Joined x₀ x₁
state_after: X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
inhabited_h : Inhabited Y
⊢ (const Y x₀).Homotopic (const Y x₁) ↔ Joined x₀ x₁

tactic: refine ⟨fun ⟨H⟩ ↦ ⟨⟨(H.toContinuousMap.comp .prodSwap).curry default, ?_, ?_⟩⟩,
  fun ⟨p⟩ ↦ ⟨p.toHomotopyConst⟩⟩ <;> simp
state_before: X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
inhabited_h : Inhabited Y
⊢ (const Y x₀).Homotopic (const Y x₁) ↔ Joined x₀ x₁
state_after: no goals
Theorem: IsMinFilter.sub
File: Mathlib/Order/Filter/Extr.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝ : OrderedAddCommGroup β
f g : α → β
a : α
s : Set α
l : Filter α
hf : IsMinFilter f l a
hg : IsMaxFilter g l a
⊢ IsMinFilter (fun x => f x - g x) l a
state_after: no goals
Theorem: Finsupp.mapDomain_apply
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [mapDomain, sum_apply, sum_eq_single a, single_eq_same]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a : α
⊢ (mapDomain f x) (f a) = x a
state_after: case h₀
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a : α
⊢ ∀ (b : α), x b ≠ 0 → b ≠ a → (single (f b) (x b)) (f a) = 0

case h₁
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a : α
⊢ x a = 0 → (single (f a) 0) (f a) = 0

tactic: intro b _ hba
state_before: case h₀
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a : α
⊢ ∀ (b : α), x b ≠ 0 → b ≠ a → (single (f b) (x b)) (f a) = 0
state_after: case h₀
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a b : α
a✝ : x b ≠ 0
hba : b ≠ a
⊢ (single (f b) (x b)) (f a) = 0

tactic: exact single_eq_of_ne (hf.ne hba)
state_before: case h₀
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a b : α
a✝ : x b ≠ 0
hba : b ≠ a
⊢ (single (f b) (x b)) (f a) = 0
state_after: no goals

tactic: intro _
state_before: case h₁
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a : α
⊢ x a = 0 → (single (f a) 0) (f a) = 0
state_after: case h₁
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a : α
a✝ : x a = 0
⊢ (single (f a) 0) (f a) = 0

tactic: rw [single_zero, coe_zero, Pi.zero_apply]
state_before: case h₁
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
hf : Injective f
x : α →₀ M
a : α
a✝ : x a = 0
⊢ (single (f a) 0) (f a) = 0
state_after: no goals
Theorem: geom_goldConj_isSol_fibRec
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [fibRec.geom_sol_iff_root_charPoly, fibRec_charPoly_eq]
state_before: α : Type u_1
inst✝ : CommSemiring α
⊢ fibRec.IsSolution fun x => ψ ^ x
state_after: α : Type u_1
inst✝ : CommSemiring α
⊢ (X ^ 2 - (X + 1)).IsRoot ψ

tactic: simp [sub_eq_zero, - div_pow]
state_before: α : Type u_1
inst✝ : CommSemiring α
⊢ (X ^ 2 - (X + 1)).IsRoot ψ
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.smul_iSup
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

tactic: simp only [smul_apply, iSup_apply, ENNReal.smul_iSup]
state_before: α : Type u_1
β : Type u_2
m : OuterMeasure α
R : Type u_3
inst✝¹ : SMul R ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
ι : Sort u_4
f : ι → OuterMeasure α
c : R
s : Set α
⊢ (c • ⨆ i, f i) s = (⨆ i, c • f i) s
state_after: no goals
Theorem: Units.continuousOn_zpow₀_spectrum
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: simpa only [Set.subset_compl_singleton_iff] using spectrum.zero_not_mem R a.isUnit
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹¹ : Semifield R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : HasContinuousInv₀ R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f : R → R
a✝ : A
inst✝ : UniqueContinuousFunctionalCalculus R A
a : Aˣ
n : ℤ
⊢ spectrum R ↑a ⊆ {0}ᶜ
state_after: no goals