1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: HasFPowerSeriesOnBall.hasSum_sub
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: have : y - x ∈ EMetric.ball (0 : E) r := by simpa [edist_eq_coe_nnnorm_sub] using hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
⊢ HasSum (fun n => (p n) fun x_1 => y - x) (f y)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
this : y - x ∈ EMetric.ball 0 r
⊢ HasSum (fun n => (p n) fun x_1 => y - x) (f y)

tactic: simpa only [add_sub_cancel] using hf.hasSum this
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
this : y - x ∈ EMetric.ball 0 r
⊢ HasSum (fun n => (p n) fun x_1 => y - x) (f y)
state_after: no goals

tactic: simpa [edist_eq_coe_nnnorm_sub] using hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
⊢ y - x ∈ EMetric.ball 0 r
state_after: no goals
Theorem: HasCompactMulSupport.continuous_extend_one
File: Mathlib/Topology/Support.lean

tactic: rw [show x = ↑(⟨x, Subtype.coe_image_subset _ _
  (supp.mulTSupport_extend_one_subset continuous_subtype_val h)⟩ : U) by rfl,
  ← (hU.openEmbedding_subtype_val).continuousAt_iff, extend_comp Subtype.val_injective]
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace α'
inst✝⁴ : One β
inst✝³ : One γ
inst✝² : One δ
g✝ : β → γ
f✝ : α → β
f₂ : α → γ
m : β → γ → δ
x✝ : α
inst✝¹ : T2Space α'
hf : HasCompactMulSupport f✝
g : α → α'
cont✝ : Continuous g
inst✝ : TopologicalSpace β
U : Set α'
hU : IsOpen U
f : ↑U → β
cont : Continuous f
supp : HasCompactMulSupport f
x : α'
h : x ∈ mulTSupport (extend Subtype.val f 1)
⊢ ContinuousAt (extend Subtype.val f 1) x
state_after: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace α'
inst✝⁴ : One β
inst✝³ : One γ
inst✝² : One δ
g✝ : β → γ
f✝ : α → β
f₂ : α → γ
m : β → γ → δ
x✝ : α
inst✝¹ : T2Space α'
hf : HasCompactMulSupport f✝
g : α → α'
cont✝ : Continuous g
inst✝ : TopologicalSpace β
U : Set α'
hU : IsOpen U
f : ↑U → β
cont : Continuous f
supp : HasCompactMulSupport f
x : α'
h : x ∈ mulTSupport (extend Subtype.val f 1)
⊢ ContinuousAt f ⟨x, ⋯⟩

tactic: exact cont.continuousAt
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace α'
inst✝⁴ : One β
inst✝³ : One γ
inst✝² : One δ
g✝ : β → γ
f✝ : α → β
f₂ : α → γ
m : β → γ → δ
x✝ : α
inst✝¹ : T2Space α'
hf : HasCompactMulSupport f✝
g : α → α'
cont✝ : Continuous g
inst✝ : TopologicalSpace β
U : Set α'
hU : IsOpen U
f : ↑U → β
cont : Continuous f
supp : HasCompactMulSupport f
x : α'
h : x ∈ mulTSupport (extend Subtype.val f 1)
⊢ ContinuousAt f ⟨x, ⋯⟩
state_after: no goals

tactic: rfl
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace α'
inst✝⁴ : One β
inst✝³ : One γ
inst✝² : One δ
g✝ : β → γ
f✝ : α → β
f₂ : α → γ
m : β → γ → δ
x✝ : α
inst✝¹ : T2Space α'
hf : HasCompactMulSupport f✝
g : α → α'
cont✝ : Continuous g
inst✝ : TopologicalSpace β
U : Set α'
hU : IsOpen U
f : ↑U → β
cont : Continuous f
supp : HasCompactMulSupport f
x : α'
h : x ∈ mulTSupport (extend Subtype.val f 1)
⊢ x = ↑⟨x, ⋯⟩
state_after: no goals
Theorem: String.Iterator.ValidFor.next
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: cases h.out'
state_before: l : List Char
c : Char
r : List Char
it : Iterator
h : ValidFor l (c :: r) it
⊢ ValidFor (c :: l) r it.next
state_after: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor (c :: l) r { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse } }.next

tactic: simp only [Iterator.next, next_of_valid l.reverse c r]
state_before: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor (c :: l) r { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse } }.next
state_after: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor (c :: l) r { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse + c.utf8Size } }

tactic: rw [← List.reverseAux_eq, utf8Len_reverse]
state_before: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor (c :: l) r { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse + c.utf8Size } }
state_after: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor (c :: l) r { s := { data := l.reverseAux (c :: r) }, i := { byteIdx := utf8Len l + c.utf8Size } }

tactic: constructor
state_before: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := l.reverse ++ c :: r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor (c :: l) r { s := { data := l.reverseAux (c :: r) }, i := { byteIdx := utf8Len l + c.utf8Size } }
state_after: no goals
Theorem: Function.minimalPeriod_pos_of_mem_periodicPts
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp only [minimalPeriod, dif_pos hx, (Nat.find_spec hx).1.lt]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ 0 < minimalPeriod f x
state_after: no goals
Theorem: DFinsupp.liftAddHom_comp_single
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
f : (i : ι) → β i →+ γ
i : ι
⊢ (liftAddHom f).comp (singleAddHom β i) = f i
state_after: no goals
Theorem: PNat.gcd_one
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [gcd_comm]
state_before: n : ℕ+
⊢ n.gcd 1 = 1
state_after: n : ℕ+
⊢ gcd 1 n = 1

tactic: apply one_gcd
state_before: n : ℕ+
⊢ gcd 1 n = 1
state_after: no goals
Theorem: Matrix.invOf_submatrix_equiv_eq
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: letI := submatrixEquivInvertible A e₁ e₂
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommRing α
A✝ B : Matrix n n α
inst✝³ : Fintype m
inst✝² : DecidableEq m
A : Matrix m m α
e₁ e₂ : n ≃ m
inst✝¹ : Invertible A
inst✝ : Invertible (A.submatrix ⇑e₁ ⇑e₂)
⊢ ⅟(A.submatrix ⇑e₁ ⇑e₂) = (⅟A).submatrix ⇑e₂ ⇑e₁
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommRing α
A✝ B : Matrix n n α
inst✝³ : Fintype m
inst✝² : DecidableEq m
A : Matrix m m α
e₁ e₂ : n ≃ m
inst✝¹ : Invertible A
inst✝ : Invertible (A.submatrix ⇑e₁ ⇑e₂)
this : Invertible (A.submatrix ⇑e₁ ⇑e₂) := A.submatrixEquivInvertible e₁ e₂
⊢ ⅟(A.submatrix ⇑e₁ ⇑e₂) = (⅟A).submatrix ⇑e₂ ⇑e₁

tactic: convert (rfl : ⅟ (A.submatrix e₁ e₂) = _)
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommRing α
A✝ B : Matrix n n α
inst✝³ : Fintype m
inst✝² : DecidableEq m
A : Matrix m m α
e₁ e₂ : n ≃ m
inst✝¹ : Invertible A
inst✝ : Invertible (A.submatrix ⇑e₁ ⇑e₂)
this : Invertible (A.submatrix ⇑e₁ ⇑e₂) := A.submatrixEquivInvertible e₁ e₂
⊢ ⅟(A.submatrix ⇑e₁ ⇑e₂) = (⅟A).submatrix ⇑e₂ ⇑e₁
state_after: no goals
Theorem: HurwitzZeta.jacobiTheta₂''_conj
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: simp only [jacobiTheta₂'', jacobiTheta₂'_conj, jacobiTheta₂_conj,
  ← exp_conj, conj_ofReal, conj_I, map_mul, map_add, map_div₀, mul_neg, map_pow, map_ofNat,
  neg_mul, div_neg, neg_div, jacobiTheta₂'_neg_left, jacobiTheta₂_neg_left]
state_before: z τ : ℂ
⊢ (starRingEnd ℂ) (jacobiTheta₂'' z τ) = jacobiTheta₂'' ((starRingEnd ℂ) z) (-(starRingEnd ℂ) τ)
state_after: no goals
Theorem: iteratedDerivWithin_neg
File: Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean

tactic: rw [iteratedDerivWithin, iteratedDerivWithin, iteratedFDerivWithin_neg_apply h hx,
  ContinuousMultilinearMap.neg_apply]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
n : ℕ
x : 𝕜
s : Set 𝕜
hx : x ∈ s
h : UniqueDiffOn 𝕜 s
f g : 𝕜 → F
⊢ iteratedDerivWithin n (-f) s x = -iteratedDerivWithin n f s x
state_after: no goals
Theorem: MeasureTheory.Content.sup_le
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: simp only [apply_eq_coe_toFun]
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K₁ K₂ : Compacts G
⊢ (fun s => ↑(μ.toFun s)) (K₁ ⊔ K₂) ≤ (fun s => ↑(μ.toFun s)) K₁ + (fun s => ↑(μ.toFun s)) K₂
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K₁ K₂ : Compacts G
⊢ ↑(μ.toFun (K₁ ⊔ K₂)) ≤ ↑(μ.toFun K₁) + ↑(μ.toFun K₂)

tactic: norm_cast
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K₁ K₂ : Compacts G
⊢ ↑(μ.toFun (K₁ ⊔ K₂)) ≤ ↑(μ.toFun K₁) + ↑(μ.toFun K₂)
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K₁ K₂ : Compacts G
⊢ μ.toFun (K₁ ⊔ K₂) ≤ μ.toFun K₁ + μ.toFun K₂

tactic: exact μ.sup_le' _ _
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K₁ K₂ : Compacts G
⊢ μ.toFun (K₁ ⊔ K₂) ≤ μ.toFun K₁ + μ.toFun K₂
state_after: no goals
Theorem: Nat.ord_compl_mul
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: if ha : a = 0 then simp [ha] else
if hb : b = 0 then simp [hb] else
simp only [ord_proj_mul p ha hb]
rw [div_mul_div_comm (ord_proj_dvd a p) (ord_proj_dvd b p)]
state_before: a✝ b✝ m n p✝ a b p : ℕ
⊢ a * b / p ^ (a * b).factorization p = a / p ^ a.factorization p * (b / p ^ b.factorization p)
state_after: no goals

tactic: simp [ha]
state_before: a✝ b✝ m n p✝ a b p : ℕ
ha : a = 0
⊢ a * b / p ^ (a * b).factorization p = a / p ^ a.factorization p * (b / p ^ b.factorization p)
state_after: no goals

tactic: if hb : b = 0 then simp [hb] else
simp only [ord_proj_mul p ha hb]
rw [div_mul_div_comm (ord_proj_dvd a p) (ord_proj_dvd b p)]
state_before: a✝ b✝ m n p✝ a b p : ℕ
ha : ¬a = 0
⊢ a * b / p ^ (a * b).factorization p = a / p ^ a.factorization p * (b / p ^ b.factorization p)
state_after: no goals

tactic: simp [hb]
state_before: a✝ b✝ m n p✝ a b p : ℕ
ha : ¬a = 0
hb : b = 0
⊢ a * b / p ^ (a * b).factorization p = a / p ^ a.factorization p * (b / p ^ b.factorization p)
state_after: no goals

tactic: simp only [ord_proj_mul p ha hb]
state_before: a✝ b✝ m n p✝ a b p : ℕ
ha : ¬a = 0
hb : ¬b = 0
⊢ a * b / p ^ (a * b).factorization p = a / p ^ a.factorization p * (b / p ^ b.factorization p)
state_after: a✝ b✝ m n p✝ a b p : ℕ
ha : ¬a = 0
hb : ¬b = 0
⊢ a * b / (p ^ a.factorization p * p ^ b.factorization p) = a / p ^ a.factorization p * (b / p ^ b.factorization p)

tactic: rw [div_mul_div_comm (ord_proj_dvd a p) (ord_proj_dvd b p)]
state_before: a✝ b✝ m n p✝ a b p : ℕ
ha : ¬a = 0
hb : ¬b = 0
⊢ a * b / (p ^ a.factorization p * p ^ b.factorization p) = a / p ^ a.factorization p * (b / p ^ b.factorization p)
state_after: no goals
Theorem: MeasureTheory.Submartingale.smul_nonneg
File: Mathlib/Probability/Martingale/Basic.lean

tactic: rw [← neg_neg c, (by ext (i x); simp : - -c • f = -(c • -f))]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : 0 ≤ c
hf : Submartingale f ℱ μ
⊢ Submartingale (c • f) ℱ μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : 0 ≤ c
hf : Submartingale f ℱ μ
⊢ Submartingale (-(c • -f)) ℱ μ

tactic: exact Supermartingale.neg (hf.neg.smul_nonneg hc)
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : 0 ≤ c
hf : Submartingale f ℱ μ
⊢ Submartingale (-(c • -f)) ℱ μ
state_after: no goals

tactic: ext (i x)
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : 0 ≤ c
hf : Submartingale f ℱ μ
⊢ - -c • f = -(c • -f)
state_after: case h.h
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : 0 ≤ c
hf : Submartingale f ℱ μ
i : ι
x : Ω
⊢ (- -c • f) i x = (-(c • -f)) i x

tactic: simp
state_before: case h.h
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : 0 ≤ c
hf : Submartingale f ℱ μ
i : ι
x : Ω
⊢ (- -c • f) i x = (-(c • -f)) i x
state_after: no goals
Theorem: List.getElem_tails
File: Mathlib/Data/List/Infix.lean

tactic: induction l generalizing n with
| nil => simp
| cons a l ihl =>
  cases n with
  | zero => simp
  | succ n => simp [ihl]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
l : List α
n : ℕ
h : n < l.tails.length
⊢ l.tails[n] = drop n l
state_after: no goals

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n✝ n : ℕ
h : n < [].tails.length
⊢ [].tails[n] = drop n []
state_after: no goals

tactic: cases n with
| zero => simp
| succ n => simp [ihl]
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n✝ : ℕ
a : α
l : List α
ihl : ∀ (n : ℕ) (h : n < l.tails.length), l.tails[n] = drop n l
n : ℕ
h : n < (a :: l).tails.length
⊢ (a :: l).tails[n] = drop n (a :: l)
state_after: no goals

tactic: simp
state_before: case cons.zero
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
l : List α
ihl : ∀ (n : ℕ) (h : n < l.tails.length), l.tails[n] = drop n l
h : 0 < (a :: l).tails.length
⊢ (a :: l).tails[0] = drop 0 (a :: l)
state_after: no goals

tactic: simp [ihl]
state_before: case cons.succ
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n✝ : ℕ
a : α
l : List α
ihl : ∀ (n : ℕ) (h : n < l.tails.length), l.tails[n] = drop n l
n : ℕ
h : n + 1 < (a :: l).tails.length
⊢ (a :: l).tails[n + 1] = drop (n + 1) (a :: l)
state_after: no goals
Theorem: LucasLehmer.X.ωb_mul_ω
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: rw [mul_comm, ω_mul_ωb]
state_before: q✝ q : ℕ+
⊢ ωb * ω = 1
state_after: no goals
Theorem: dist_homothety_center
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rw [dist_comm, dist_center_homothety]
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ dist ((homothety p₁ c) p₂) p₁ = ‖c‖ * dist p₁ p₂
state_after: no goals
Theorem: Nat.psub'_eq_psub
File: Mathlib/Data/Nat/PSub.lean

tactic: rw [psub']
state_before: m n : ℕ
⊢ m.psub' n = m.psub n
state_after: m n : ℕ
⊢ (if n ≤ m then some (m - n) else none) = m.psub n

tactic: split_ifs with h
state_before: m n : ℕ
⊢ (if n ≤ m then some (m - n) else none) = m.psub n
state_after: case pos
m n : ℕ
h : n ≤ m
⊢ some (m - n) = m.psub n

case neg
m n : ℕ
h : ¬n ≤ m
⊢ none = m.psub n

tactic: exact (psub_eq_sub h).symm
state_before: case pos
m n : ℕ
h : n ≤ m
⊢ some (m - n) = m.psub n
state_after: no goals

tactic: exact (psub_eq_none.2 (not_le.1 h)).symm
state_before: case neg
m n : ℕ
h : ¬n ≤ m
⊢ none = m.psub n
state_after: no goals
Theorem: symmetric_symmetrizeRel
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp [SymmetricRel, symmetrizeRel, preimage_inter, inter_comm, ← preimage_comp]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
V : Set (α × α)
⊢ SymmetricRel (symmetrizeRel V)
state_after: no goals
Theorem: AkraBazziRecurrence.bi_min_div_two_pos
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: norm_num
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ 0 < 2
state_after: no goals
Theorem: Computation.liftRel_of_mem
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [mem_unique ma' ma]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ ca
⊢ ∃ b, b ∈ cb ∧ R a' b
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ ca
⊢ ∃ b, b ∈ cb ∧ R a b

tactic: exact ⟨b, mb, ab⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ ca
⊢ ∃ b, b ∈ cb ∧ R a b
state_after: no goals

tactic: rw [mem_unique mb' mb]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ ∃ a, a ∈ ca ∧ R a b'
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ ∃ a, a ∈ ca ∧ R a b

tactic: exact ⟨a, ma, ab⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ ∃ a, a ∈ ca ∧ R a b
state_after: no goals
Theorem: List.map₂Right_eq_zipWith
File: Mathlib/Data/List/Basic.lean

tactic: have : (fun a b => flip f a (some b)) = flip fun a b => f (some a) b := rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : Option α → β → γ
a : α
as : List α
b : β
bs : List β
h : bs.length ≤ as.length
⊢ map₂Right f as bs = zipWith (fun a b => f (some a) b) as bs
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : Option α → β → γ
a : α
as : List α
b : β
bs : List β
h : bs.length ≤ as.length
this : (fun a b => flip f a (some b)) = flip fun a b => f (some a) b
⊢ map₂Right f as bs = zipWith (fun a b => f (some a) b) as bs

tactic: simp only [map₂Right, map₂Left_eq_zipWith, zipWith_flip, *]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : Option α → β → γ
a : α
as : List α
b : β
bs : List β
h : bs.length ≤ as.length
this : (fun a b => flip f a (some b)) = flip fun a b => f (some a) b
⊢ map₂Right f as bs = zipWith (fun a b => f (some a) b) as bs
state_after: no goals
Theorem: Nat.floorRoot_zero_left
File: Mathlib/Data/Nat/Factorization/Root.lean

tactic: simp [floorRoot]
state_before: a✝ b n a : ℕ
⊢ floorRoot 0 a = 0
state_after: no goals
Theorem: Sym2.GameAdd.fix_eq
File: Mathlib/Order/GameAdd.lean

tactic: dsimp [GameAdd.fix]
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝ : β
C : α → α → Sort u_3
hr : WellFounded rα
IH : (a₁ b₁ : α) → ((a₂ b₂ : α) → GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁
a b : α
⊢ fix hr IH a b = IH a b fun a' b' x => fix hr IH a' b'
state_after: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝ : β
C : α → α → Sort u_3
hr : WellFounded rα
IH : (a₁ b₁ : α) → ((a₂ b₂ : α) → GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁
a b : α
⊢ ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a, b) =
    IH a b fun a' b' x => ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a', b')

tactic: exact WellFounded.fix_eq _ _ _
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝ : β
C : α → α → Sort u_3
hr : WellFounded rα
IH : (a₁ b₁ : α) → ((a₂ b₂ : α) → GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁
a b : α
⊢ ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a, b) =
    IH a b fun a' b' x => ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a', b')
state_after: no goals
Theorem: Equiv.Perm.sign_subtypeCongr
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp [subtypeCongr]
state_before: α : Type u
inst✝⁴ : DecidableEq α
β : Type v
inst✝³ : Fintype α
inst✝² : DecidableEq β
inst✝¹ : Fintype β
p : α → Prop
inst✝ : DecidablePred p
ep : Perm { a // p a }
en : Perm { a // ¬p a }
⊢ sign (ep.subtypeCongr en) = sign ep * sign en
state_after: no goals
Theorem: Fin.succ_injective
File: Mathlib/Data/Fin/Basic.lean

tactic: simp [ext_iff]
state_before: n✝ m n : ℕ
a b : Fin n
⊢ a.succ = b.succ → a = b
state_after: no goals