1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Quiver.Path.cast_cons
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: subst_vars
state_before: U : Type u_1
inst✝ : Quiver U
u v w u' w' : U
p : Path u v
e : v ⟶ w
hu : u = u'
hw : w = w'
⊢ cast hu hw (p.cons e) = (cast hu ⋯ p).cons (Hom.cast ⋯ hw e)
state_after: U : Type u_1
inst✝ : Quiver U
v u' w' : U
p : Path u' v
e : v ⟶ w'
⊢ cast ⋯ ⋯ (p.cons e) = (cast ⋯ ⋯ p).cons (Hom.cast ⋯ ⋯ e)

tactic: rfl
state_before: U : Type u_1
inst✝ : Quiver U
v u' w' : U
p : Path u' v
e : v ⟶ w'
⊢ cast ⋯ ⋯ (p.cons e) = (cast ⋯ ⋯ p).cons (Hom.cast ⋯ ⋯ e)
state_after: no goals
Theorem: ContinuousLinearMap.hasFPowerSeriesOnBall_bilinear
File: Mathlib/Analysis/Analytic/Linear.lean

tactic: simp
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E →L[𝕜] F →L[𝕜] G
x : E × F
⊢ ⊤ ≤ (f.fpowerSeriesBilinear x).radius
state_after: no goals

tactic: simp only [Finset.sum_range_succ, Finset.sum_range_one, Prod.fst_add, Prod.snd_add,
  f.map_add_add]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E →L[𝕜] F →L[𝕜] G
x y✝ : E × F
x✝ : y✝ ∈ EMetric.ball 0 ⊤
⊢ HasSum (fun n => (f.fpowerSeriesBilinear x (n + 3)) fun x => y✝)
    ((f (x + y✝).1) (x + y✝).2 - ∑ i ∈ Finset.range 3, (f.fpowerSeriesBilinear x i) fun x => y✝)
state_after: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E →L[𝕜] F →L[𝕜] G
x y✝ : E × F
x✝ : y✝ ∈ EMetric.ball 0 ⊤
⊢ HasSum (fun n => (f.fpowerSeriesBilinear x (n + 3)) fun x => y✝)
    ((f x.1) x.2 + (f.deriv₂ (x.1, x.2)) (y✝.1, y✝.2) + (f y✝.1) y✝.2 -
      ((((∑ x_1 ∈ Finset.range 0, (f.fpowerSeriesBilinear x x_1) fun x => y✝) +
            (f.fpowerSeriesBilinear x 0) fun x => y✝) +
          (f.fpowerSeriesBilinear x 1) fun x => y✝) +
        (f.fpowerSeriesBilinear x 2) fun x => y✝))

tactic: simp [fpowerSeriesBilinear, hasSum_zero]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E →L[𝕜] F →L[𝕜] G
x y✝ : E × F
x✝ : y✝ ∈ EMetric.ball 0 ⊤
⊢ HasSum (fun n => (f.fpowerSeriesBilinear x (n + 3)) fun x => y✝)
    ((f x.1) x.2 + (f.deriv₂ (x.1, x.2)) (y✝.1, y✝.2) + (f y✝.1) y✝.2 -
      ((((∑ x_1 ∈ Finset.range 0, (f.fpowerSeriesBilinear x x_1) fun x => y✝) +
            (f.fpowerSeriesBilinear x 0) fun x => y✝) +
          (f.fpowerSeriesBilinear x 1) fun x => y✝) +
        (f.fpowerSeriesBilinear x 2) fun x => y✝))
state_after: no goals
Theorem: FirstOrder.Language.Substructure.dense_induction
File: Mathlib/ModelTheory/Substructures.lean

tactic: have : ∀ x ∈ closure L s, p x := fun x hx => closure_induction hx Hs fun {n} => Hfun
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s✝ : Set M
p : M → Prop
x : M
s : Set M
hs : (closure L).toFun s = ⊤
Hs : ∀ x ∈ s, p x
Hfun : ∀ {n : ℕ} (f : L.Functions n), ClosedUnder f (setOf p)
⊢ p x
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s✝ : Set M
p : M → Prop
x : M
s : Set M
hs : (closure L).toFun s = ⊤
Hs : ∀ x ∈ s, p x
Hfun : ∀ {n : ℕ} (f : L.Functions n), ClosedUnder f (setOf p)
this : ∀ x ∈ (closure L).toFun s, p x
⊢ p x

tactic: simpa [hs] using this x
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s✝ : Set M
p : M → Prop
x : M
s : Set M
hs : (closure L).toFun s = ⊤
Hs : ∀ x ∈ s, p x
Hfun : ∀ {n : ℕ} (f : L.Functions n), ClosedUnder f (setOf p)
this : ∀ x ∈ (closure L).toFun s, p x
⊢ p x
state_after: no goals
Theorem: Substring.Valid.extract
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: let ⟨l, m, r, h₁⟩ := h₁.validFor
state_before: b e : Pos
x✝ : Substring
h₁ : x✝.Valid
h₂ : { str := x✝.toString, startPos := b, stopPos := e }.Valid
⊢ (x✝.extract b e).Valid
state_after: b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
h₂ : { str := x✝.toString, startPos := b, stopPos := e }.Valid
l m r : List Char
h₁ : ValidFor l m r x✝
⊢ (x✝.extract b e).Valid

tactic: rw [h₁.toString] at h₂
state_before: b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
h₂ : { str := x✝.toString, startPos := b, stopPos := e }.Valid
l m r : List Char
h₁ : ValidFor l m r x✝
⊢ (x✝.extract b e).Valid
state_after: b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
l m : List Char
h₂ : { str := { data := m }, startPos := b, stopPos := e }.Valid
r : List Char
h₁ : ValidFor l m r x✝
⊢ (x✝.extract b e).Valid

tactic: let ⟨ml, mm, mr, h₂⟩ := h₂.validFor
state_before: b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
l m : List Char
h₂ : { str := { data := m }, startPos := b, stopPos := e }.Valid
r : List Char
h₁ : ValidFor l m r x✝
⊢ (x✝.extract b e).Valid
state_after: b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
l m : List Char
h₂✝ : { str := { data := m }, startPos := b, stopPos := e }.Valid
r : List Char
h₁ : ValidFor l m r x✝
ml mm mr : List Char
h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e }
⊢ (x✝.extract b e).Valid

tactic: have ⟨l', r', h₃⟩ := h₁.extract h₂
state_before: b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
l m : List Char
h₂✝ : { str := { data := m }, startPos := b, stopPos := e }.Valid
r : List Char
h₁ : ValidFor l m r x✝
ml mm mr : List Char
h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e }
⊢ (x✝.extract b e).Valid
state_after: b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
l m : List Char
h₂✝ : { str := { data := m }, startPos := b, stopPos := e }.Valid
r : List Char
h₁ : ValidFor l m r x✝
ml mm mr : List Char
h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e }
l' r' : List Char
h₃ : ValidFor l' mm r' (x✝.extract b e)
⊢ (x✝.extract b e).Valid

tactic: exact h₃.valid
state_before: b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
l m : List Char
h₂✝ : { str := { data := m }, startPos := b, stopPos := e }.Valid
r : List Char
h₁ : ValidFor l m r x✝
ml mm mr : List Char
h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e }
l' r' : List Char
h₃ : ValidFor l' mm r' (x✝.extract b e)
⊢ (x✝.extract b e).Valid
state_after: no goals
Theorem: Ordinal.add_omega
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: rcases lt_omega.1 h with ⟨n, rfl⟩
state_before: a : Ordinal.{u_1}
h : a < ω
⊢ a + ω = ω
state_after: case intro
n : ℕ
h : ↑n < ω
⊢ ↑n + ω = ω

tactic: clear h
state_before: case intro
n : ℕ
h : ↑n < ω
⊢ ↑n + ω = ω
state_after: case intro
n : ℕ
⊢ ↑n + ω = ω

tactic: induction' n with n IH
state_before: case intro
n : ℕ
⊢ ↑n + ω = ω
state_after: case intro.zero

⊢ ↑0 + ω = ω

case intro.succ
n : ℕ
IH : ↑n + ω = ω
⊢ ↑(n + 1) + ω = ω

tactic: rw [Nat.cast_zero, zero_add]
state_before: case intro.zero

⊢ ↑0 + ω = ω
state_after: no goals

tactic: rwa [Nat.cast_succ, add_assoc, one_add_of_omega_le (le_refl _)]
state_before: case intro.succ
n : ℕ
IH : ↑n + ω = ω
⊢ ↑(n + 1) + ω = ω
state_after: no goals
Theorem: SemiconjBy.inv_right_iff
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

tactic: rw [← inv_symm_left_iff, inv_inv_symm_iff]
state_before: G : Type u_1
inst✝ : Group G
a x y : G
⊢ SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y
state_after: no goals
Theorem: Real.volume_Ioc
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp [volume_val]
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ℝ
⊢ volume (Ioc a b) = ofReal (b - a)
state_after: no goals
Theorem: OrthonormalBasis.repr_apply_apply
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: classical
  rw [← b.repr.inner_map_map (b i) v, b.repr_self i, EuclideanSpace.inner_single_left]
  simp only [one_mul, eq_self_iff_true, map_one]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
b : OrthonormalBasis ι 𝕜 E
v : E
i : ι
⊢ b.repr v i = ⟪b i, v⟫_𝕜
state_after: no goals

tactic: rw [← b.repr.inner_map_map (b i) v, b.repr_self i, EuclideanSpace.inner_single_left]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
b : OrthonormalBasis ι 𝕜 E
v : E
i : ι
⊢ b.repr v i = ⟪b i, v⟫_𝕜
state_after: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
b : OrthonormalBasis ι 𝕜 E
v : E
i : ι
⊢ b.repr v i = (starRingEnd 𝕜) 1 * b.repr v i

tactic: simp only [one_mul, eq_self_iff_true, map_one]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
b : OrthonormalBasis ι 𝕜 E
v : E
i : ι
⊢ b.repr v i = (starRingEnd 𝕜) 1 * b.repr v i
state_after: no goals
Theorem: strictConvexOn_pow
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: apply StrictMonoOn.strictConvexOn_of_deriv (convex_Ici _) (continuousOn_pow _)
state_before: n : ℕ
hn : 2 ≤ n
⊢ StrictConvexOn ℝ (Ici 0) fun x => x ^ n
state_after: n : ℕ
hn : 2 ≤ n
⊢ StrictMonoOn (deriv fun x => x ^ n) (interior (Ici 0))

tactic: rw [deriv_pow', interior_Ici]
state_before: n : ℕ
hn : 2 ≤ n
⊢ StrictMonoOn (deriv fun x => x ^ n) (interior (Ici 0))
state_after: n : ℕ
hn : 2 ≤ n
⊢ StrictMonoOn (fun x => ↑n * x ^ (n - 1)) (Ioi 0)

tactic: exact fun x (hx : 0 < x) y _ hxy => mul_lt_mul_of_pos_left
  (pow_lt_pow_left hxy hx.le <| Nat.sub_ne_zero_of_lt hn) (by positivity)
state_before: n : ℕ
hn : 2 ≤ n
⊢ StrictMonoOn (fun x => ↑n * x ^ (n - 1)) (Ioi 0)
state_after: no goals

tactic: positivity
state_before: n : ℕ
hn : 2 ≤ n
x : ℝ
hx : 0 < x
y : ℝ
x✝ : y ∈ Ioi 0
hxy : x < y
⊢ 0 < ↑n
state_after: no goals
Theorem: Set.image_subtype_val_Icc
File: Mathlib/Order/Interval/Set/OrdConnected.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t s : Set α
inst✝ : s.OrdConnected
x y : ↑s
⊢ (range ⇑(OrderEmbedding.subtype fun x => x ∈ s)).OrdConnected
state_after: no goals
Theorem: Coheyting.boundary_le_boundary_sup_sup_boundary_inf_right
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [sup_comm a, inf_comm]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ ∂ b ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b)
state_after: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ ∂ b ≤ ∂ (b ⊔ a) ⊔ ∂ (b ⊓ a)

tactic: exact boundary_le_boundary_sup_sup_boundary_inf_left
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ ∂ b ≤ ∂ (b ⊔ a) ⊔ ∂ (b ⊓ a)
state_after: no goals
Theorem: Order.IsSuccLimit.isMin_of_noMax
File: Mathlib/Order/SuccPred/Limit.lean

tactic: rcases hb.exists_succ_iterate with ⟨_ | n, rfl⟩
state_before: α : Type u_1
inst✝³ : Preorder α
a : α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
h : IsSuccLimit a
b : α
hb : b ≤ a
⊢ a ≤ b
state_after: case intro.zero
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
h : IsSuccLimit (succ^[0] b)
hb : b ≤ succ^[0] b
⊢ succ^[0] b ≤ b

case intro.succ
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
n : ℕ
h : IsSuccLimit (succ^[n + 1] b)
hb : b ≤ succ^[n + 1] b
⊢ succ^[n + 1] b ≤ b

tactic: exact le_rfl
state_before: case intro.zero
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
h : IsSuccLimit (succ^[0] b)
hb : b ≤ succ^[0] b
⊢ succ^[0] b ≤ b
state_after: no goals

tactic: rw [iterate_succ_apply'] at h
state_before: case intro.succ
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
n : ℕ
h : IsSuccLimit (succ^[n + 1] b)
hb : b ≤ succ^[n + 1] b
⊢ succ^[n + 1] b ≤ b
state_after: case intro.succ
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
n : ℕ
h : IsSuccLimit (succ (succ^[n] b))
hb : b ≤ succ^[n + 1] b
⊢ succ^[n + 1] b ≤ b

tactic: exact (not_isSuccLimit_succ _ h).elim
state_before: case intro.succ
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
n : ℕ
h : IsSuccLimit (succ (succ^[n] b))
hb : b ≤ succ^[n + 1] b
⊢ succ^[n + 1] b ≤ b
state_after: no goals
Theorem: IsSubgroup.normalizer_isSubgroup
File: Mathlib/Deprecated/Subgroup.lean

tactic: simp [normalizer]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
s : Set G
⊢ 1 ∈ normalizer s
state_after: no goals

tactic: rw [mul_inv_rev, ← mul_assoc, mul_assoc a, mul_assoc a, ← ha, ← hb]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝ : Group G
s : Set G
a b : G
ha : ∀ (n : G), n ∈ s ↔ a * n * a⁻¹ ∈ s
hb : ∀ (n : G), n ∈ s ↔ b * n * b⁻¹ ∈ s
n : G
⊢ n ∈ s ↔ a * b * n * (a * b)⁻¹ ∈ s
state_after: no goals

tactic: rw [ha (a⁻¹ * n * a⁻¹⁻¹)]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
s : Set G
a : G
ha : ∀ (n : G), n ∈ s ↔ a * n * a⁻¹ ∈ s
n : G
⊢ n ∈ s ↔ a⁻¹ * n * a⁻¹⁻¹ ∈ s
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
s : Set G
a : G
ha : ∀ (n : G), n ∈ s ↔ a * n * a⁻¹ ∈ s
n : G
⊢ n ∈ s ↔ a * (a⁻¹ * n * a⁻¹⁻¹) * a⁻¹ ∈ s

tactic: simp [mul_assoc]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
s : Set G
a : G
ha : ∀ (n : G), n ∈ s ↔ a * n * a⁻¹ ∈ s
n : G
⊢ n ∈ s ↔ a * (a⁻¹ * n * a⁻¹⁻¹) * a⁻¹ ∈ s
state_after: no goals
Theorem: IsAlgClosure.equivOfEquiv_symm_algebraMap
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

tactic: simp
state_before: k : Type u
inst✝¹⁴ : Field k
K : Type u_1
J : Type u_2
R : Type u
S : Type u_3
L : Type v
M : Type w
inst✝¹³ : Field K
inst✝¹² : Field J
inst✝¹¹ : CommRing R
inst✝¹⁰ : CommRing S
inst✝⁹ : Field L
inst✝⁸ : Field M
inst✝⁷ : Algebra R M
inst✝⁶ : NoZeroSMulDivisors R M
inst✝⁵ : IsAlgClosure R M
inst✝⁴ : Algebra K M
inst✝³ : IsAlgClosure K M
inst✝² : Algebra S L
inst✝¹ : NoZeroSMulDivisors S L
inst✝ : IsAlgClosure S L
hSR : S ≃+* R
r : R
⊢ (equivOfEquiv L M hSR) ((equivOfEquiv L M hSR).symm ((algebraMap R M) r)) =
    (equivOfEquiv L M hSR) ((algebraMap S L) (hSR.symm r))
state_after: no goals
Theorem: IntermediateField.normalClosure_def'
File: Mathlib/FieldTheory/NormalClosure.lean

tactic: refine (normalClosure_def F K L).trans (le_antisymm (iSup_le (fun f ↦ ?_)) (iSup_le (fun f ↦ ?_)))
state_before: F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
⊢ normalClosure F (↥K) L = ⨆ f, map f K
state_after: case refine_1
F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
f : ↥K →ₐ[F] L
⊢ f.fieldRange ≤ ⨆ f, map f K

case refine_2
F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
f : L →ₐ[F] L
⊢ map f K ≤ ⨆ f, f.fieldRange

tactic: exact le_iSup_of_le (f.liftNormal L) (fun b ⟨a, h⟩ ↦ ⟨a, a.2, h ▸ f.liftNormal_commutes L a⟩)
state_before: case refine_1
F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
f : ↥K →ₐ[F] L
⊢ f.fieldRange ≤ ⨆ f, map f K
state_after: no goals

tactic: exact le_iSup_of_le (f.comp K.val) (fun b ⟨a, h⟩ ↦ ⟨⟨a, h.1⟩, h.2⟩)
state_before: case refine_2
F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
f : L →ₐ[F] L
⊢ map f K ≤ ⨆ f, f.fieldRange
state_after: no goals
Theorem: Fin.partialProd_succ
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simp [partialProd, List.take_succ, List.ofFnNthVal, dif_pos j.is_lt]
state_before: α : Type u_1
β : Type u_2
inst✝ : Monoid α
n : ℕ
f : Fin n → α
j : Fin n
⊢ partialProd f j.succ = partialProd f j.castSucc * f j
state_after: no goals
Theorem: Polynomial.map_evalRingHom_eval
File: Mathlib/Algebra/Polynomial/Bivariate.lean

tactic: rw [eval_map, eval₂_evalRingHom]
state_before: R : Type u_1
S : Type u_2
inst✝ : CommSemiring R
x y : R
p : R[X][Y]
⊢ eval y (map (evalRingHom x) p) = evalEval x y p
state_after: no goals
Theorem: MeasureTheory.dist_indicatorConstLp_eq_norm
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [Lp.dist_edist, edist_indicatorConstLp_eq_nnnorm, ENNReal.coe_toReal, Lp.coe_nnnorm]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : μ s ≠ ⊤
c : E
t : Set α
ht : MeasurableSet t
hμt : μ t ≠ ⊤
⊢ dist (indicatorConstLp p hs hμs c) (indicatorConstLp p ht hμt c) = ‖indicatorConstLp p ⋯ ⋯ c‖
state_after: no goals
Theorem: MeasureTheory.sFiniteSeq_zero
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: ext s hs
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
n : ℕ
⊢ sFiniteSeq 0 n = 0
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
⊢ (sFiniteSeq 0 n) s = 0 s

tactic: have h : ∑' n, sFiniteSeq (0 : Measure α) n s = 0 := by
  simp [← Measure.sum_apply _ hs, sum_sFiniteSeq]
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
⊢ (sFiniteSeq 0 n) s = 0 s
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
h : ∑' (n : ℕ), (sFiniteSeq 0 n) s = 0
⊢ (sFiniteSeq 0 n) s = 0 s

tactic: simp only [ENNReal.tsum_eq_zero] at h
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
h : ∑' (n : ℕ), (sFiniteSeq 0 n) s = 0
⊢ (sFiniteSeq 0 n) s = 0 s
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
h : ∀ (i : ℕ), (sFiniteSeq 0 i) s = 0
⊢ (sFiniteSeq 0 n) s = 0 s

tactic: exact h n
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
h : ∀ (i : ℕ), (sFiniteSeq 0 i) s = 0
⊢ (sFiniteSeq 0 n) s = 0 s
state_after: no goals

tactic: simp [← Measure.sum_apply _ hs, sum_sFiniteSeq]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
⊢ ∑' (n : ℕ), (sFiniteSeq 0 n) s = 0
state_after: no goals
Theorem: sq_nonneg
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: obtain ha | ha := le_total 0 a
state_before: α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b c d : α
inst✝ : ExistsAddOfLE α
a : α
⊢ 0 ≤ a ^ 2
state_after: case inl
α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : 0 ≤ a
⊢ 0 ≤ a ^ 2

case inr
α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
⊢ 0 ≤ a ^ 2

tactic: obtain ⟨b, hab⟩ := exists_add_of_le ha
state_before: case inr
α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
⊢ 0 ≤ a ^ 2
state_after: case inr.intro
α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b✝ c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
b : α
hab : 0 = a + b
⊢ 0 ≤ a ^ 2

tactic: calc
  0 ≤ b ^ 2 := pow_nonneg (not_lt.1 fun hb ↦ hab.not_gt <| add_neg_of_nonpos_of_neg ha hb) _
  _ = a ^ 2 := add_left_injective (a * b) ?_
state_before: case inr.intro
α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b✝ c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
b : α
hab : 0 = a + b
⊢ 0 ≤ a ^ 2
state_after: case inr.intro
α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b✝ c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
b : α
hab : 0 = a + b
⊢ (fun x => x + a * b) (b ^ 2) = (fun x => x + a * b) (a ^ 2)

tactic: calc
  b ^ 2 + a * b = (a + b) * b := by rw [add_comm, sq, add_mul]
  _ = a * (a + b) := by simp [← hab]
  _ = a ^ 2 + a * b := by rw [sq, mul_add]
state_before: case inr.intro
α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b✝ c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
b : α
hab : 0 = a + b
⊢ (fun x => x + a * b) (b ^ 2) = (fun x => x + a * b) (a ^ 2)
state_after: no goals

tactic: exact pow_nonneg ha _
state_before: case inl
α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : 0 ≤ a
⊢ 0 ≤ a ^ 2
state_after: no goals

tactic: rw [add_comm, sq, add_mul]
state_before: α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b✝ c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
b : α
hab : 0 = a + b
⊢ b ^ 2 + a * b = (a + b) * b
state_after: no goals

tactic: simp [← hab]
state_before: α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b✝ c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
b : α
hab : 0 = a + b
⊢ (a + b) * b = a * (a + b)
state_after: no goals

tactic: rw [sq, mul_add]
state_before: α : Type u
β : Type u_1
inst✝¹ : LinearOrderedSemiring α
a✝ b✝ c d : α
inst✝ : ExistsAddOfLE α
a : α
ha : a ≤ 0
b : α
hab : 0 = a + b
⊢ a * (a + b) = a ^ 2 + a * b
state_after: no goals
Theorem: AddCircle.norm_eq'
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: conv_rhs =>
  congr
  rw [← abs_eq_self.mpr hp.le]
state_before: p : ℝ
hp : 0 < p
x : ℝ
⊢ ‖↑x‖ = p * |p⁻¹ * x - ↑(round (p⁻¹ * x))|
state_after: p : ℝ
hp : 0 < p
x : ℝ
⊢ ‖↑x‖ = |p| * |p⁻¹ * x - ↑(round (p⁻¹ * x))|

tactic: rw [← abs_mul, mul_sub, mul_inv_cancel_left₀ hp.ne.symm, norm_eq, mul_comm p]
state_before: p : ℝ
hp : 0 < p
x : ℝ
⊢ ‖↑x‖ = |p| * |p⁻¹ * x - ↑(round (p⁻¹ * x))|
state_after: no goals