1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.Submartingale.neg
File: Mathlib/Probability/Martingale/Basic.lean

tactic: refine ⟨hf.1.neg, fun i j hij => (condexp_neg (f j)).le.trans ?_, fun i => (hf.2.2 i).neg⟩
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
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Submartingale f ℱ μ
⊢ Supermartingale (-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
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Submartingale f ℱ μ
i j : ι
hij : i ≤ j
⊢ -μ[f j|↑ℱ i] ≤ᶠ[ae μ] (-f) i

tactic: filter_upwards [hf.2.1 i j hij] with _ _
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
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Submartingale f ℱ μ
i j : ι
hij : i ≤ j
⊢ -μ[f j|↑ℱ i] ≤ᶠ[ae μ] (-f) i
state_after: case 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
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Submartingale f ℱ μ
i j : ι
hij : i ≤ j
a✝¹ : Ω
a✝ : f i a✝¹ ≤ (μ[f j|↑ℱ i]) a✝¹
⊢ (-μ[f j|↑ℱ i]) a✝¹ ≤ (-f) i a✝¹

tactic: simpa
state_before: case 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
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Submartingale f ℱ μ
i j : ι
hij : i ≤ j
a✝¹ : Ω
a✝ : f i a✝¹ ≤ (μ[f j|↑ℱ i]) a✝¹
⊢ (-μ[f j|↑ℱ i]) a✝¹ ≤ (-f) i a✝¹
state_after: no goals
Theorem: WittVector.iterate_verschiebung_mul_left
File: Mathlib/RingTheory/WittVector/Identities.lean

tactic: induction' i with i ih generalizing y
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x y : 𝕎 R
i : ℕ
⊢ (⇑verschiebung)^[i] x * y = (⇑verschiebung)^[i] (x * (⇑frobenius)^[i] y)
state_after: case zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x y : 𝕎 R
⊢ (⇑verschiebung)^[0] x * y = (⇑verschiebung)^[0] (x * (⇑frobenius)^[0] y)

case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
i : ℕ
ih : ∀ (y : 𝕎 R), (⇑verschiebung)^[i] x * y = (⇑verschiebung)^[i] (x * (⇑frobenius)^[i] y)
y : 𝕎 R
⊢ (⇑verschiebung)^[i + 1] x * y = (⇑verschiebung)^[i + 1] (x * (⇑frobenius)^[i + 1] y)

tactic: simp
state_before: case zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x y : 𝕎 R
⊢ (⇑verschiebung)^[0] x * y = (⇑verschiebung)^[0] (x * (⇑frobenius)^[0] y)
state_after: no goals

tactic: rw [iterate_succ_apply', ← verschiebung_mul_frobenius, ih, iterate_succ_apply']
state_before: case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
i : ℕ
ih : ∀ (y : 𝕎 R), (⇑verschiebung)^[i] x * y = (⇑verschiebung)^[i] (x * (⇑frobenius)^[i] y)
y : 𝕎 R
⊢ (⇑verschiebung)^[i + 1] x * y = (⇑verschiebung)^[i + 1] (x * (⇑frobenius)^[i + 1] y)
state_after: case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
i : ℕ
ih : ∀ (y : 𝕎 R), (⇑verschiebung)^[i] x * y = (⇑verschiebung)^[i] (x * (⇑frobenius)^[i] y)
y : 𝕎 R
⊢ verschiebung ((⇑verschiebung)^[i] (x * (⇑frobenius)^[i] (frobenius y))) =
    verschiebung ((⇑verschiebung)^[i] (x * (⇑frobenius)^[i + 1] y))

tactic: rfl
state_before: case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
i : ℕ
ih : ∀ (y : 𝕎 R), (⇑verschiebung)^[i] x * y = (⇑verschiebung)^[i] (x * (⇑frobenius)^[i] y)
y : 𝕎 R
⊢ verschiebung ((⇑verschiebung)^[i] (x * (⇑frobenius)^[i] (frobenius y))) =
    verschiebung ((⇑verschiebung)^[i] (x * (⇑frobenius)^[i + 1] y))
state_after: no goals
Theorem: Real.diam_Ioo
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp [Metric.diam, ENNReal.toReal_ofReal (sub_nonneg.2 h)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : a ≤ b
⊢ Metric.diam (Ioo a b) = b - a
state_after: no goals
Theorem: ENNReal.toReal_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [ENNReal.toReal, ENNReal.toReal, ← NNReal.coe_rpow, ENNReal.toNNReal_rpow]
state_before: x : ℝ≥0∞
z : ℝ
⊢ x.toReal ^ z = (x ^ z).toReal
state_after: no goals
Theorem: AddMonoidAlgebra.lift_unique
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: conv_lhs =>
  rw [lift_unique' F]
  simp [lift_apply]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝⁵ : CommSemiring k
inst✝⁴ : AddMonoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type u_3
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : k[G] →ₐ[k] A
f : MonoidAlgebra k G
⊢ F f = sum f fun a b => b • F (single a 1)
state_after: no goals
Theorem: Polynomial.roots_C
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: classical exact
if H : x = 0 then by rw [H, C_0, roots_zero]
else
  Multiset.ext.mpr fun r => (by
    rw [count_roots, count_zero, rootMultiplicity_eq_zero (not_isRoot_C _ _ H)])
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
x : R
⊢ (C x).roots = 0
state_after: no goals

tactic: exact
if H : x = 0 then by rw [H, C_0, roots_zero]
else
Multiset.ext.mpr fun r => (by
rw [count_roots, count_zero, rootMultiplicity_eq_zero (not_isRoot_C _ _ H)])
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
x : R
⊢ (C x).roots = 0
state_after: no goals

tactic: rw [H, C_0, roots_zero]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
x : R
H : x = 0
⊢ (C x).roots = 0
state_after: no goals

tactic: rw [count_roots, count_zero, rootMultiplicity_eq_zero (not_isRoot_C _ _ H)]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
x : R
H : ¬x = 0
r : R
⊢ count r (C x).roots = count r 0
state_after: no goals
Theorem: SemiconjBy.neg_left
File: Mathlib/Algebra/Ring/Semiconj.lean

tactic: simp only [SemiconjBy, h.eq, neg_mul, mul_neg]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Mul R
inst✝ : HasDistribNeg R
a x y : R
h : SemiconjBy a x y
⊢ SemiconjBy (-a) x y
state_after: no goals
Theorem: Complex.abs_re_lt_abs
File: Mathlib/Data/Complex/Abs.lean

tactic: rw [Complex.abs, AbsoluteValue.coe_mk, MulHom.coe_mk, Real.lt_sqrt (abs_nonneg _), normSq_apply,
  _root_.sq_abs, ← sq, lt_add_iff_pos_right, mul_self_pos]
state_before: z : ℂ
⊢ |z.re| < abs z ↔ z.im ≠ 0
state_after: no goals
Theorem: inv_mul_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [mul_eq_one_iff_eq_inv, inv_inj]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ a⁻¹ * b = 1 ↔ a = b
state_after: no goals
Theorem: LinearPMap.closure_def
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

tactic: simp [closure, hf]
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : f.IsClosable
⊢ f.closure = Exists.choose hf
state_after: no goals
Theorem: List.get?_set_eq_of_lt
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [get?_eq_getElem?, getElem?_set_eq', getElem?_eq_getElem h]
state_before: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (l.set n a).get? n = some a
state_after: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (fun x => a) <$> some l[n] = some a

tactic: rfl
state_before: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (fun x => a) <$> some l[n] = some a
state_after: no goals
Theorem: equicontinuousWithinAt_iff_range
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: simp only [EquicontinuousWithinAt, forall_subtype_range_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
x₀ : X
⊢ EquicontinuousWithinAt F S x₀ ↔ EquicontinuousWithinAt Subtype.val S x₀
state_after: no goals
Theorem: Sum.elim_mulSingle_one
File: Mathlib/Algebra/Group/Pi/Basic.lean

tactic: simp only [Pi.mulSingle, Sum.elim_update_left, elim_one_one]
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f i
i✝ : I
a a' : α → γ
b b' : β → γ
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : One γ
i : α
c : γ
⊢ Sum.elim (Pi.mulSingle i c) 1 = Pi.mulSingle (inl i) c
state_after: no goals
Theorem: AlgebraicGeometry.LocallyRingedSpace.toΓSpec_preim_basicOpen_eq
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

tactic: ext
state_before: X : LocallyRingedSpace
r : ↑(Γ.obj { unop := X })
⊢ X.toΓSpecFun ⁻¹' (basicOpen r).carrier = (X.toRingedSpace.basicOpen r).carrier
state_after: case h
X : LocallyRingedSpace
r : ↑(Γ.obj { unop := X })
x✝ : ↑X.toTopCat
⊢ x✝ ∈ X.toΓSpecFun ⁻¹' (basicOpen r).carrier ↔ x✝ ∈ (X.toRingedSpace.basicOpen r).carrier

tactic: erw [X.toRingedSpace.mem_top_basicOpen]
state_before: case h
X : LocallyRingedSpace
r : ↑(Γ.obj { unop := X })
x✝ : ↑X.toTopCat
⊢ x✝ ∈ X.toΓSpecFun ⁻¹' (basicOpen r).carrier ↔ x✝ ∈ (X.toRingedSpace.basicOpen r).carrier
state_after: case h
X : LocallyRingedSpace
r : ↑(Γ.obj { unop := X })
x✝ : ↑X.toTopCat
⊢ x✝ ∈ X.toΓSpecFun ⁻¹' (basicOpen r).carrier ↔ IsUnit ((X.toRingedSpace.presheaf.germ ⟨x✝, ⋯⟩) r)

tactic: apply not_mem_prime_iff_unit_in_stalk
state_before: case h
X : LocallyRingedSpace
r : ↑(Γ.obj { unop := X })
x✝ : ↑X.toTopCat
⊢ x✝ ∈ X.toΓSpecFun ⁻¹' (basicOpen r).carrier ↔ IsUnit ((X.toRingedSpace.presheaf.germ ⟨x✝, ⋯⟩) r)
state_after: no goals
Theorem: List.kerase_of_not_mem_keys
File: Mathlib/Data/List/Sigma.lean

tactic: induction' l with _ _ ih <;> [rfl; (simp [not_or] at h; simp [h.1, ih h.2])]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : a ∉ l.keys
⊢ kerase a l = l
state_after: no goals

tactic: simp [not_or] at h
state_before: case cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
tail✝ : List (Sigma β)
ih : a ∉ tail✝.keys → kerase a tail✝ = tail✝
h : a ∉ (head✝ :: tail✝).keys
⊢ kerase a (head✝ :: tail✝) = head✝ :: tail✝
state_after: case cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
tail✝ : List (Sigma β)
ih : a ∉ tail✝.keys → kerase a tail✝ = tail✝
h : ¬a = head✝.fst ∧ a ∉ tail✝.keys
⊢ kerase a (head✝ :: tail✝) = head✝ :: tail✝

tactic: simp [h.1, ih h.2]
state_before: case cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
tail✝ : List (Sigma β)
ih : a ∉ tail✝.keys → kerase a tail✝ = tail✝
h : ¬a = head✝.fst ∧ a ∉ tail✝.keys
⊢ kerase a (head✝ :: tail✝) = head✝ :: tail✝
state_after: no goals
Theorem: inv_ne_zero
File: Mathlib/Algebra/GroupWithZero/NeZero.lean

tactic: have := mul_inv_cancel h
state_before: M₀ : Type u_1
M₀' : Type u_2
inst✝² : MulZeroOneClass M₀
inst✝¹ : Nontrivial M₀
G₀ : Type u_3
inst✝ : GroupWithZero G₀
a : G₀
h : a ≠ 0
a_eq_0 : a⁻¹ = 0
⊢ False
state_after: M₀ : Type u_1
M₀' : Type u_2
inst✝² : MulZeroOneClass M₀
inst✝¹ : Nontrivial M₀
G₀ : Type u_3
inst✝ : GroupWithZero G₀
a : G₀
h : a ≠ 0
a_eq_0 : a⁻¹ = 0
this : a * a⁻¹ = 1
⊢ False

tactic: simp only [a_eq_0, mul_zero, zero_ne_one] at this
state_before: M₀ : Type u_1
M₀' : Type u_2
inst✝² : MulZeroOneClass M₀
inst✝¹ : Nontrivial M₀
G₀ : Type u_3
inst✝ : GroupWithZero G₀
a : G₀
h : a ≠ 0
a_eq_0 : a⁻¹ = 0
this : a * a⁻¹ = 1
⊢ False
state_after: no goals
Theorem: HasStrictDerivAt.const_mul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: convert (hasStrictDerivAt_const _ _).mul hd using 1
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c✝ d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
c : 𝔸
hd : HasStrictDerivAt d d' x
⊢ HasStrictDerivAt (fun y => c * d y) (c * d') x
state_after: case h.e'_7
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c✝ d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
c : 𝔸
hd : HasStrictDerivAt d d' x
⊢ c * d' = 0 * d x + c * d'

tactic: rw [zero_mul, zero_add]
state_before: case h.e'_7
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c✝ d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
c : 𝔸
hd : HasStrictDerivAt d d' x
⊢ c * d' = 0 * d x + c * d'
state_after: no goals
Theorem: Fin.prod_univ_eight
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [prod_univ_castSucc, prod_univ_seven]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 8 → β
⊢ ∏ i : Fin 8, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5 * f 6 * f 7
state_after: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 8 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (castSucc 4) * f (castSucc 5) * f (castSucc 6) *
      f (last 7) =
    f 0 * f 1 * f 2 * f 3 * f 4 * f 5 * f 6 * f 7

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 8 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (castSucc 4) * f (castSucc 5) * f (castSucc 6) *
      f (last 7) =
    f 0 * f 1 * f 2 * f 3 * f 4 * f 5 * f 6 * f 7
state_after: no goals
Theorem: intervalIntegral.integral_eq_zero_iff_of_le_of_nonneg_ae
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [integral_of_le hab, integral_eq_zero_iff_of_nonneg_ae hf hfi.1]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hab : a ≤ b
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc a b))] f
hfi : IntervalIntegrable f μ a b
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0 ↔ f =ᶠ[ae (μ.restrict (Ioc a b))] 0
state_after: no goals
Theorem: OmegaCompletePartialOrder.ScottContinuous.continuous'
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: constructor
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α → β
hf : ScottContinuous f
⊢ Continuous' f
state_after: case h
α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α → β
hf : ScottContinuous f
⊢ Continuous { toFun := f, monotone' := ?w }

case w
α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α → β
hf : ScottContinuous f
⊢ Monotone f

tactic: intro c
state_before: case h
α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α → β
hf : ScottContinuous f
⊢ Continuous { toFun := f, monotone' := ?w }
state_after: case h
α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α → β
hf : ScottContinuous f
c : Chain α
⊢ { toFun := f, monotone' := ?w } (ωSup c) = ωSup (c.map { toFun := f, monotone' := ?w })

tactic: rw [← (ωSup_eq_of_isLUB (isLUB_of_scottContinuous hf))]
state_before: case h
α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α → β
hf : ScottContinuous f
c : Chain α
⊢ { toFun := f, monotone' := ?w } (ωSup c) = ωSup (c.map { toFun := f, monotone' := ?w })
state_after: case h
α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α → β
hf : ScottContinuous f
c : Chain α
⊢ { toFun := f, monotone' := ⋯ } (ωSup c) = f (ωSup c)

tactic: simp only [OrderHom.coe_mk]
state_before: case h
α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α → β
hf : ScottContinuous f
c : Chain α
⊢ { toFun := f, monotone' := ⋯ } (ωSup c) = f (ωSup c)
state_after: no goals
Theorem: ONote.fastGrowingε₀_one
File: Mathlib/SetTheory/Ordinal/Notation.lean

tactic: simp [fastGrowingε₀, show oadd 0 1 0 = 1 from rfl]
state_before: ⊢ fastGrowingε₀ 1 = 2
state_after: no goals
Theorem: KaehlerDifferential.mvPolynomialBasis_repr_symm_single
File: Mathlib/RingTheory/Kaehler/Polynomial.lean

tactic: apply (mvPolynomialBasis R σ).repr.injective
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
σ : Type u_1
i : σ
x : MvPolynomial σ R
⊢ (mvPolynomialBasis R σ).repr.symm (Finsupp.single i x) = x • (D R (MvPolynomial σ R)) (MvPolynomial.X i)
state_after: case a
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
σ : Type u_1
i : σ
x : MvPolynomial σ R
⊢ (mvPolynomialBasis R σ).repr ((mvPolynomialBasis R σ).repr.symm (Finsupp.single i x)) =
    (mvPolynomialBasis R σ).repr (x • (D R (MvPolynomial σ R)) (MvPolynomial.X i))

tactic: simp [LinearEquiv.map_smul, -map_smul]
state_before: case a
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
σ : Type u_1
i : σ
x : MvPolynomial σ R
⊢ (mvPolynomialBasis R σ).repr ((mvPolynomialBasis R σ).repr.symm (Finsupp.single i x)) =
    (mvPolynomialBasis R σ).repr (x • (D R (MvPolynomial σ R)) (MvPolynomial.X i))
state_after: no goals
Theorem: Set.Ioc_top
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : OrderTop α
a : α
⊢ Ioc a ⊤ = Ioi a
state_after: no goals
Theorem: CategoryTheory.Limits.MonoCoprod.mono_binaryCofanSum_inr'
File: Mathlib/CategoryTheory/Limits/MonoCoprod.lean

tactic: suffices inr = (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr by
  rw [this]
  exact MonoCoprod.binaryCofan_inr _ (isColimitBinaryCofanSum c c₁ c₂ hc hc₁ hc₂)
state_before: C : Type u_1
inst✝¹ : Category.{u_4, u_1} C
I₁ : Type u_2
I₂ : Type u_3
X : I₁ ⊕ I₂ → C
c : Cofan X
c₁ : Cofan (X ∘ Sum.inl)
c₂ : Cofan (X ∘ Sum.inr)
hc : IsColimit c
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
inst✝ : MonoCoprod C
inr : c₂.pt ⟶ c.pt
hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂)
⊢ Mono inr
state_after: C : Type u_1
inst✝¹ : Category.{u_4, u_1} C
I₁ : Type u_2
I₂ : Type u_3
X : I₁ ⊕ I₂ → C
c : Cofan X
c₁ : Cofan (X ∘ Sum.inl)
c₂ : Cofan (X ∘ Sum.inr)
hc : IsColimit c
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
inst✝ : MonoCoprod C
inr : c₂.pt ⟶ c.pt
hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂)
⊢ inr = (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr

tactic: exact Cofan.IsColimit.hom_ext hc₂ _ _ (by simpa using hinr)
state_before: C : Type u_1
inst✝¹ : Category.{u_4, u_1} C
I₁ : Type u_2
I₂ : Type u_3
X : I₁ ⊕ I₂ → C
c : Cofan X
c₁ : Cofan (X ∘ Sum.inl)
c₂ : Cofan (X ∘ Sum.inr)
hc : IsColimit c
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
inst✝ : MonoCoprod C
inr : c₂.pt ⟶ c.pt
hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂)
⊢ inr = (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr
state_after: no goals

tactic: rw [this]
state_before: C : Type u_1
inst✝¹ : Category.{u_4, u_1} C
I₁ : Type u_2
I₂ : Type u_3
X : I₁ ⊕ I₂ → C
c : Cofan X
c₁ : Cofan (X ∘ Sum.inl)
c₂ : Cofan (X ∘ Sum.inr)
hc : IsColimit c
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
inst✝ : MonoCoprod C
inr : c₂.pt ⟶ c.pt
hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂)
this : inr = (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr
⊢ Mono inr
state_after: C : Type u_1
inst✝¹ : Category.{u_4, u_1} C
I₁ : Type u_2
I₂ : Type u_3
X : I₁ ⊕ I₂ → C
c : Cofan X
c₁ : Cofan (X ∘ Sum.inl)
c₂ : Cofan (X ∘ Sum.inr)
hc : IsColimit c
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
inst✝ : MonoCoprod C
inr : c₂.pt ⟶ c.pt
hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂)
this : inr = (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr
⊢ Mono (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr

tactic: exact MonoCoprod.binaryCofan_inr _ (isColimitBinaryCofanSum c c₁ c₂ hc hc₁ hc₂)
state_before: C : Type u_1
inst✝¹ : Category.{u_4, u_1} C
I₁ : Type u_2
I₂ : Type u_3
X : I₁ ⊕ I₂ → C
c : Cofan X
c₁ : Cofan (X ∘ Sum.inl)
c₂ : Cofan (X ∘ Sum.inr)
hc : IsColimit c
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
inst✝ : MonoCoprod C
inr : c₂.pt ⟶ c.pt
hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂)
this : inr = (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr
⊢ Mono (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr
state_after: no goals

tactic: simpa using hinr
state_before: C : Type u_1
inst✝¹ : Category.{u_4, u_1} C
I₁ : Type u_2
I₂ : Type u_3
X : I₁ ⊕ I₂ → C
c : Cofan X
c₁ : Cofan (X ∘ Sum.inl)
c₂ : Cofan (X ∘ Sum.inr)
hc : IsColimit c
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
inst✝ : MonoCoprod C
inr : c₂.pt ⟶ c.pt
hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂)
⊢ ∀ (i : I₂), c₂.inj i ≫ inr = c₂.inj i ≫ (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr
state_after: no goals
Theorem: root_X_pow_sub_C_ne_zero
File: Mathlib/FieldTheory/KummerExtension.lean

tactic: rwa [natDegree_X_pow_sub_C, natDegree_X]
state_before: K : Type u
inst✝ : Field K
n : ℕ
hn : 1 < n
a : K
⊢ X.natDegree < (X ^ n - C a).natDegree
state_after: no goals
Theorem: MeasureTheory.snorm_one_smul_measure
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: rw [@snorm_smul_measure_of_ne_top _ _ _ μ _ 1 (@ENNReal.coe_ne_top 1) f c]
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
f : α → F
c : ℝ≥0∞
⊢ snorm f 1 (c • μ) = c * snorm f 1 μ
state_after: α : 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
f : α → F
c : ℝ≥0∞
⊢ c ^ (1 / 1).toReal • snorm f 1 μ = c * snorm f 1 μ

tactic: simp
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
f : α → F
c : ℝ≥0∞
⊢ c ^ (1 / 1).toReal • snorm f 1 μ = c * snorm f 1 μ
state_after: no goals