ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.sum_le_exp_of_nonneg
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n : ℕ
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ CauSeq.lim ⟨fun n => (↑(exp' ↑x) n).re, ⋯⟩
state_after: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ↑(const _root_.abs (∑ i ∈ range n, x ^ i / ↑i !)) j ≤ ↑⟨fun n => (↑(exp' ↑x) n).re, ⋯⟩ j
tactic: refine le_lim (CauSeq.le_of_exists ⟨n, fun j hj => ?_⟩)
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ↑(const _root_.abs (∑ i ∈ range n, x ^ i / ↑i !)) j ≤ ↑⟨fun n => (↑(exp' ↑x) n).re, ⋯⟩ j
state_after: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ ∑ i ∈ range j, (↑x ^ i / ↑i !).re
tactic: simp only [exp', const_apply, re_sum]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ ∑ i ∈ range j, (↑x ^ i / ↑i !).re
state_after: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ ∑ i ∈ range j, x ^ i / ↑i !
tactic: norm_cast
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ ∑ i ∈ range j, x ^ i / ↑i !
state_after: x✝³ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
x✝² : ℕ
x✝¹ : x✝² ∈ range j
x✝ : x✝² ∉ range n
⊢ 0 ≤ x ^ x✝² / ↑x✝²!
tactic: refine sum_le_sum_of_subset_of_nonneg (range_mono hj) fun _ _ _ ↦ ?_
state_before: x✝³ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
x✝² : ℕ
x✝¹ : x✝² ∈ range j
x✝ : x✝² ∉ range n
⊢ 0 ≤ x ^ x✝² / ↑x✝²!
state_after: no goals
tactic: positivity
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n : ℕ
⊢ CauSeq.lim ⟨fun n => (↑(exp' ↑x) n).re, ⋯⟩ = rexp x
state_after: no goals
tactic: rw [exp, Complex.exp, ← cauSeqRe, lim_re]
Theorem: LinearMap.IsProj.eq_conj_prodMap
File: Mathlib/LinearAlgebra/Projection.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
E : Type u_2
inst✝¹ : AddCommGroup E
inst✝ : Module R E
p : Submodule R E
f : E →ₗ[R] E
h : IsProj p f
⊢ f = (p.prodEquivOfIsCompl (ker f) ⋯).conj (id.prodMap 0)
state_after: R : Type u_1
inst✝² : CommRing R
E : Type u_2
inst✝¹ : AddCommGroup E
inst✝ : Module R E
p : Submodule R E
f : E →ₗ[R] E
h : IsProj p f
⊢ f = (↑(p.prodEquivOfIsCompl (ker f) ⋯) ∘ₗ id.prodMap 0) ∘ₗ ↑(p.prodEquivOfIsCompl (ker f) ⋯).symm
tactic: rw [LinearEquiv.conj_apply]
state_before: R : Type u_1
inst✝² : CommRing R
E : Type u_2
inst✝¹ : AddCommGroup E
inst✝ : Module R E
p : Submodule R E
f : E →ₗ[R] E
h : IsProj p f
⊢ f = (↑(p.prodEquivOfIsCompl (ker f) ⋯) ∘ₗ id.prodMap 0) ∘ₗ ↑(p.prodEquivOfIsCompl (ker f) ⋯).symm
state_after: no goals
tactic: exact h.eq_conj_prod_map'
Theorem: IsPrimitiveRoot.pow_of_dvd
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : M
f : F
h✝ h : IsPrimitiveRoot ζ k
p : ℕ
hp : p ≠ 0
hdiv : p ∣ k
⊢ IsPrimitiveRoot (ζ ^ p) (k / p)
state_after: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : M
f : F
h✝ h : IsPrimitiveRoot ζ k
p : ℕ
hp : p ≠ 0
hdiv : p ∣ k
⊢ orderOf (ζ ^ p) = k / p
tactic: suffices orderOf (ζ ^ p) = k / p by exact this ▸ IsPrimitiveRoot.orderOf (ζ ^ p)
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : M
f : F
h✝ h : IsPrimitiveRoot ζ k
p : ℕ
hp : p ≠ 0
hdiv : p ∣ k
⊢ orderOf (ζ ^ p) = k / p
state_after: no goals
tactic: rw [orderOf_pow' _ hp, ← eq_orderOf h, Nat.gcd_eq_right hdiv]
Theorem: EquicontinuousAt.closure'
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
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 γ
A : Set Y
u : Y → X → α
x₀ : X
hA : EquicontinuousAt (u ∘ Subtype.val) x₀
hu : Continuous u
⊢ EquicontinuousAt (u ∘ Subtype.val) x₀
state_after: ι : 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 γ
A : Set Y
u : Y → X → α
x₀ : X
hA : EquicontinuousWithinAt (u ∘ Subtype.val) univ x₀
hu : Continuous u
⊢ EquicontinuousWithinAt (u ∘ Subtype.val) univ x₀
tactic: rw [← equicontinuousWithinAt_univ] at hA ⊢
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 γ
A : Set Y
u : Y → X → α
x₀ : X
hA : EquicontinuousWithinAt (u ∘ Subtype.val) univ x₀
hu : Continuous u
⊢ EquicontinuousWithinAt (u ∘ Subtype.val) univ x₀
state_after: no goals
tactic: exact hA.closure' (Pi.continuous_restrict _ |>.comp hu) (continuous_apply x₀ |>.comp hu)
Theorem: MonCat.FilteredColimits.colimit_one_eq
File: Mathlib/Algebra/Category/MonCat/FilteredColimits.lean

Proof steps:
state_before: J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCatMax
inst✝ : IsFiltered J
j : J
⊢ 1 = M.mk F ⟨j, 1⟩
state_after: case h
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCatMax
inst✝ : IsFiltered J
j : J
⊢ ∃ k f g, (F.map f) ⟨⋯.some, 1⟩.snd = (F.map g) ⟨j, 1⟩.snd
tactic: apply M.mk_eq
state_before: case h
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCatMax
inst✝ : IsFiltered J
j : J
⊢ ∃ k f g, (F.map f) ⟨⋯.some, 1⟩.snd = (F.map g) ⟨j, 1⟩.snd
state_after: case h
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCatMax
inst✝ : IsFiltered J
j : J
⊢ (F.map (IsFiltered.leftToMax ⟨⋯.some, 1⟩.fst j)) ⟨⋯.some, 1⟩.snd =
    (F.map (IsFiltered.rightToMax ⟨⋯.some, 1⟩.fst j)) ⟨j, 1⟩.snd
tactic: refine ⟨max' _ j, IsFiltered.leftToMax _ j, IsFiltered.rightToMax _ j, ?_⟩
state_before: case h
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCatMax
inst✝ : IsFiltered J
j : J
⊢ (F.map (IsFiltered.leftToMax ⟨⋯.some, 1⟩.fst j)) ⟨⋯.some, 1⟩.snd =
    (F.map (IsFiltered.rightToMax ⟨⋯.some, 1⟩.fst j)) ⟨j, 1⟩.snd
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Martingale.setIntegral_eq
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
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✝ : SigmaFiniteFiltration μ ℱ
hf : Martingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ ∫ (ω : Ω) in s, f i ω ∂μ = ∫ (ω : Ω) in s, f j ω ∂μ
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✝ : SigmaFiniteFiltration μ ℱ
hf : Martingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ ∫ (ω : Ω) in s, f i ω ∂μ = ∫ (x : Ω) in s, (μ[f j|↑ℱ i]) x ∂μ
tactic: rw [← @setIntegral_condexp _ _ _ _ _ (ℱ i) m0 _ _ _ (ℱ.le i) _ (hf.integrable j) hs]
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✝ : SigmaFiniteFiltration μ ℱ
hf : Martingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ ∫ (ω : Ω) in s, f i ω ∂μ = ∫ (x : Ω) in s, (μ[f j|↑ℱ i]) x ∂μ
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✝ : SigmaFiniteFiltration μ ℱ
hf : Martingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ ∀ᵐ (x : Ω) ∂μ, x ∈ s → f i x = (μ[f j|↑ℱ i]) x
tactic: refine setIntegral_congr_ae (ℱ.le i s hs) ?_
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✝ : SigmaFiniteFiltration μ ℱ
hf : Martingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ ∀ᵐ (x : Ω) ∂μ, x ∈ s → f i x = (μ[f j|↑ℱ i]) x
state_after: no goals
tactic: filter_upwards [hf.2 i j hij] with _ heq _ using heq.symm
Theorem: subsingleton_or_nontrivial
File: Mathlib/Logic/Nontrivial/Defs.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ Subsingleton α ∨ Nontrivial α
state_after: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ Nontrivial α ∨ ¬Nontrivial α
tactic: rw [← not_nontrivial_iff_subsingleton, or_comm]
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ Nontrivial α ∨ ¬Nontrivial α
state_after: no goals
tactic: exact Classical.em _
Theorem: Projectivization.submodule_injective
File: Mathlib/LinearAlgebra/Projectivization/Basic.lean

Proof steps:
state_before: K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u v : ℙ K V
h : u.submodule = v.submodule
⊢ u = v
state_after: case h
K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : ℙ K V
u : V
hu : u ≠ 0
h : (mk K u hu).submodule = v.submodule
⊢ mk K u hu = v
tactic: induction' u using ind with u hu
state_before: case h
K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : ℙ K V
u : V
hu : u ≠ 0
h : (mk K u hu).submodule = v.submodule
⊢ mk K u hu = v
state_after: case h.h
K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u : V
hu : u ≠ 0
v : V
hv : v ≠ 0
h : (mk K u hu).submodule = (mk K v hv).submodule
⊢ mk K u hu = mk K v hv
tactic: induction' v using ind with v hv
state_before: case h.h
K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u : V
hu : u ≠ 0
v : V
hv : v ≠ 0
h : (mk K u hu).submodule = (mk K v hv).submodule
⊢ mk K u hu = mk K v hv
state_after: case h.h
K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u : V
hu : u ≠ 0
v : V
hv : v ≠ 0
h : ∃ z, z • u = v
⊢ mk K u hu = mk K v hv
tactic: rw [submodule_mk, submodule_mk, Submodule.span_singleton_eq_span_singleton] at h
state_before: case h.h
K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
u : V
hu : u ≠ 0
v : V
hv : v ≠ 0
h : ∃ z, z • u = v
⊢ mk K u hu = mk K v hv
state_after: no goals
tactic: exact ((mk_eq_mk_iff K v u hv hu).2 h).symm
Theorem: Finset.exists_lt_of_sum_lt
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hlt : ∏ i ∈ s, f i < ∏ i ∈ s, g i
⊢ ∃ i ∈ s, f i < g i
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hle : ∀ i ∈ s, g i ≤ f i
⊢ ∏ i ∈ s, g i ≤ ∏ i ∈ s, f i
tactic: contrapose! Hlt with Hle
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hle : ∀ i ∈ s, g i ≤ f i
⊢ ∏ i ∈ s, g i ≤ ∏ i ∈ s, f i
state_after: no goals
tactic: exact prod_le_prod' Hle
Theorem: Set.inclusion_self
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
s t u : Set α
x : ↑s
⊢ inclusion ⋯ x = x
state_after: case mk
α : Type u_1
s t u : Set α
val✝ : α
property✝ : val✝ ∈ s
⊢ inclusion ⋯ ⟨val✝, property✝⟩ = ⟨val✝, property✝⟩
tactic: cases x
state_before: case mk
α : Type u_1
s t u : Set α
val✝ : α
property✝ : val✝ ∈ s
⊢ inclusion ⋯ ⟨val✝, property✝⟩ = ⟨val✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: measurableSet_regionBetween
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet (regionBetween f g s)
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet ({a | a.1 ∈ s} ∩ {a | a.2 ∈ {a_1 | f a.1 < a_1} ∩ {a_1 | a_1 < g a.1}})
tactic: dsimp only [regionBetween, Ioo, mem_setOf_eq, setOf_and]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet ({a | a.1 ∈ s} ∩ {a | a.2 ∈ {a_1 | f a.1 < a_1} ∩ {a_1 | a_1 < g a.1}})
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet {a | a.1 ∈ s}
tactic: refine
    MeasurableSet.inter ?_
      ((measurableSet_lt (hf.comp measurable_fst) measurable_snd).inter
        (measurableSet_lt measurable_snd (hg.comp measurable_fst)))
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet {a | a.1 ∈ s}
state_after: no goals
tactic: exact measurable_fst hs
Theorem: SimpleGraph.cliqueSet_one
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n : ℕ
a b c : α
s✝ : Finset α
G : SimpleGraph α
s : Finset α
⊢ s ∈ G.cliqueSet 1 ↔ s ∈ Set.range singleton
state_after: no goals
tactic: simp [eq_comm]
Theorem: WeierstrassCurve.VariableChange.map_injective
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ✝ : R →+* A
C : VariableChange R
φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : VariableChange R
h : map φ x✝¹ = map φ x✝
⊢ x✝¹ = x✝
state_after: case intro.intro.intro
R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ✝ : R →+* A
C : VariableChange R
φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : VariableChange R
h✝ : map φ x✝¹ = map φ x✝
h : (Units.map ↑φ) x✝¹.u = (Units.map ↑φ) x✝.u
left✝¹ : φ x✝¹.r = φ x✝.r
left✝ : φ x✝¹.s = φ x✝.s
right✝ : φ x✝¹.t = φ x✝.t
⊢ x✝¹ = x✝
tactic: rcases mk.inj h with ⟨h, _, _, _⟩
state_before: case intro.intro.intro
R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ✝ : R →+* A
C : VariableChange R
φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : VariableChange R
h✝ : map φ x✝¹ = map φ x✝
h : (Units.map ↑φ) x✝¹.u = (Units.map ↑φ) x✝.u
left✝¹ : φ x✝¹.r = φ x✝.r
left✝ : φ x✝¹.s = φ x✝.s
right✝ : φ x✝¹.t = φ x✝.t
⊢ x✝¹ = x✝
state_after: case intro.intro.intro
R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ✝ : R →+* A
C : VariableChange R
φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : VariableChange R
h✝ : map φ x✝¹ = map φ x✝
left✝¹ : φ x✝¹.r = φ x✝.r
left✝ : φ x✝¹.s = φ x✝.s
right✝ : φ x✝¹.t = φ x✝.t
h : ↑φ ↑x✝¹.u = ↑φ ↑x✝.u
⊢ x✝¹ = x✝
tactic: replace h := (Units.mk.inj h).left
state_before: case intro.intro.intro
R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ✝ : R →+* A
C : VariableChange R
φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : VariableChange R
h✝ : map φ x✝¹ = map φ x✝
left✝¹ : φ x✝¹.r = φ x✝.r
left✝ : φ x✝¹.s = φ x✝.s
right✝ : φ x✝¹.t = φ x✝.t
h : ↑φ ↑x✝¹.u = ↑φ ↑x✝.u
⊢ x✝¹ = x✝
state_after: no goals
tactic: ext <;> apply_fun _ using hφ <;> assumption
Theorem: CategoryTheory.Preadditive.neg_comp_neg
File: Mathlib/CategoryTheory/Preadditive/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
P Q R : C
f f' : P ⟶ Q
g g' : Q ⟶ R
⊢ (-f) ≫ (-g) = f ≫ g
state_after: no goals
tactic: simp
Theorem: ProbabilityTheory.Kernel.compProd_zero_right
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ✝ : Type u_4
mγ : MeasurableSpace γ✝
s : Set (β × γ✝)
κ : Kernel α β
γ : Type u_5
inst✝ : MeasurableSpace γ
⊢ κ ⊗ₖ 0 = 0
state_after: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ✝ : Type u_4
mγ : MeasurableSpace γ✝
s : Set (β × γ✝)
κ : Kernel α β
γ : Type u_5
inst✝ : MeasurableSpace γ
h : IsSFiniteKernel κ
⊢ κ ⊗ₖ 0 = 0

case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ✝ : Type u_4
mγ : MeasurableSpace γ✝
s : Set (β × γ✝)
κ : Kernel α β
γ : Type u_5
inst✝ : MeasurableSpace γ
h : ¬IsSFiniteKernel κ
⊢ κ ⊗ₖ 0 = 0
tactic: by_cases h : IsSFiniteKernel κ
Theorem: _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.sum_filter_pairs_eq_sum_powersetCard_sum
File: Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean

Proof steps:
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∑ t ∈ filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k), f t =
    ∑ A ∈ powersetCard k univ, ∑ j ∈ A, f (A, j)
state_after: case h
σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∀ (p : Finset σ × σ),
    p ∈ filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k) ↔ p.1 ∈ powersetCard k univ ∧ p.2 ∈ p.1
tactic: apply sum_finset_product
state_before: case h
σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∀ (p : Finset σ × σ),
    p ∈ filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k) ↔ p.1 ∈ powersetCard k univ ∧ p.2 ∈ p.1
state_after: no goals
tactic: aesop
Theorem: TrivSqZeroExt.snd_list_prod
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module Rᵐᵒᵖ M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
l : List (tsze R M)
⊢ l.prod.snd =
    (List.map (fun x => (List.take x.1 (List.map fst l)).prod •> x.2.snd <• (List.drop x.1.succ (List.map fst l)).prod)
        l.enum).sum
state_after: case nil
R : Type u
M : Type v
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module Rᵐᵒᵖ M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
⊢ [].prod.snd =
    (List.map
        (fun x => (List.take x.1 (List.map fst [])).prod •> x.2.snd <• (List.drop x.1.succ (List.map fst [])).prod)
        [].enum).sum

case cons
R : Type u
M : Type v
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module Rᵐᵒᵖ M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
xs : List (tsze R M)
ih :
  xs.prod.snd =
    (List.map
        (fun x => (List.take x.1 (List.map fst xs)).prod •> x.2.snd <• (List.drop x.1.succ (List.map fst xs)).prod)
        xs.enum).sum
⊢ (x :: xs).prod.snd =
    (List.map
        (fun x_1 =>
          (List.take x_1.1 (List.map fst (x :: xs))).prod •> x_1.2.snd <•
            (List.drop x_1.1.succ (List.map fst (x :: xs))).prod)
        (x :: xs).enum).sum
tactic: induction' l with x xs ih
Theorem: MeasureTheory.Supermartingale.setIntegral_le
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
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✝ : SigmaFiniteFiltration μ ℱ
f : ι → Ω → ℝ
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ ∫ (ω : Ω) in s, f j ω ∂μ ≤ ∫ (ω : Ω) in s, f i ω ∂μ
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✝ : SigmaFiniteFiltration μ ℱ
f : ι → Ω → ℝ
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ ∫ (x : Ω) in s, (μ[f j|↑ℱ i]) x ∂μ ≤ ∫ (ω : Ω) in s, f i ω ∂μ
tactic: rw [← setIntegral_condexp (ℱ.le i) (hf.integrable j) hs]
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✝ : SigmaFiniteFiltration μ ℱ
f : ι → Ω → ℝ
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ ∫ (x : Ω) in s, (μ[f j|↑ℱ i]) x ∂μ ≤ ∫ (ω : Ω) in s, f i ω ∂μ
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✝ : SigmaFiniteFiltration μ ℱ
f : ι → Ω → ℝ
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ μ[f j|↑ℱ i] ≤ᶠ[ae μ] f i
tactic: refine setIntegral_mono_ae integrable_condexp.integrableOn (hf.integrable i).integrableOn ?_
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✝ : SigmaFiniteFiltration μ ℱ
f : ι → Ω → ℝ
hf : Supermartingale f ℱ μ
i j : ι
hij : i ≤ j
s : Set Ω
hs : MeasurableSet s
⊢ μ[f j|↑ℱ i] ≤ᶠ[ae μ] f i
state_after: no goals
tactic: filter_upwards [hf.2.1 i j hij] with _ heq using heq
Theorem: mabs_eq_mabs
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : LinearOrder α
a b : α
⊢ mabs a = mabs b ↔ a = b ∨ a = b⁻¹
state_after: α : Type u_1
inst✝¹ : Group α
inst✝ : LinearOrder α
a b : α
h : mabs a = mabs b
⊢ a = b ∨ a = b⁻¹
tactic: refine ⟨fun h ↦ ?_, by rintro (h | h) <;> simp [h, abs_neg]⟩
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : LinearOrder α
a b : α
h : mabs a = mabs b
⊢ a = b ∨ a = b⁻¹
state_after: no goals
tactic: obtain rfl | rfl := eq_or_eq_inv_of_mabs_eq h <;>
    simpa only [inv_eq_iff_eq_inv (a := |b|ₘ), inv_inv, inv_inj, or_comm] using mabs_choice b