ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.sum_le_card_nsmul
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✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f✝ g : ι → N
s✝ t s : Finset ι
f : ι → N
n : N
h : ∀ x ∈ s, f x ≤ n
⊢ s.prod f ≤ n ^ s.card
state_after: case refine_1
ι : 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✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f✝ g : ι → N
s✝ t s : Finset ι
f : ι → N
n : N
h : ∀ x ∈ s, f x ≤ n
⊢ ∀ x ∈ Multiset.map f s.val, x ≤ n

case refine_2
ι : 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✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f✝ g : ι → N
s✝ t s : Finset ι
f : ι → N
n : N
h : ∀ x ∈ s, f x ≤ n
⊢ n ^ Multiset.card (Multiset.map f s.val) ≤ n ^ s.card
tactic: refine (Multiset.prod_le_pow_card (s.val.map f) n ?_).trans ?_
Theorem: SemiconjBy.neg_right
File: Mathlib/Algebra/Ring/Semiconj.lean

Proof steps:
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
tactic: simp only [SemiconjBy, h.eq, neg_mul, mul_neg]
Theorem: MvPolynomial.totalDegree_sub
File: Mathlib/Algebra/MvPolynomial/CommRing.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommRing R
p q a b : MvPolynomial σ R
⊢ (a - b).totalDegree = (a + -b).totalDegree
state_after: no goals
tactic: rw [sub_eq_add_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommRing R
p q a b : MvPolynomial σ R
⊢ max a.totalDegree (-b).totalDegree = max a.totalDegree b.totalDegree
state_after: no goals
tactic: rw [totalDegree_neg]
Theorem: residual_of_dense_Gδ
File: Mathlib/Topology/GDelta.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
s : Set X
ho : IsGδ s
hd : Dense s
⊢ s ∈ residual X
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
T : Set (Set X)
To : ∀ t ∈ T, IsOpen t
Tct : T.Countable
hd : Dense (⋂₀ T)
⊢ ⋂₀ T ∈ residual X
tactic: rcases ho with ⟨T, To, Tct, rfl⟩
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
T : Set (Set X)
To : ∀ t ∈ T, IsOpen t
Tct : T.Countable
hd : Dense (⋂₀ T)
⊢ ⋂₀ T ∈ residual X
state_after: no goals
tactic: exact
    (countable_sInter_mem Tct).mpr fun t tT =>
      residual_of_dense_open (To t tT) (hd.mono (sInter_subset_of_mem tT))
Theorem: Matroid.mapSetEmbedding_indep_iff'
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set β
⊢ (M.mapSetEmbedding f).Indep I ↔ ∃ I₀, M.Indep ↑I₀ ∧ I = ⇑f '' I₀
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set β
⊢ (M.Indep ↑(⇑f ⁻¹' I) ∧ ∃ t, ⇑f '' t = I) ↔ ∃ I₀, M.Indep ↑I₀ ∧ I = ⇑f '' I₀
tactic: simp only [mapSetEmbedding_indep_iff, subset_range_iff_exists_image_eq]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set β
⊢ (M.Indep ↑(⇑f ⁻¹' I) ∧ ∃ t, ⇑f '' t = I) ↔ ∃ I₀, M.Indep ↑I₀ ∧ I = ⇑f '' I₀
state_after: case mp
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set β
⊢ (M.Indep ↑(⇑f ⁻¹' I) ∧ ∃ t, ⇑f '' t = I) → ∃ I₀, M.Indep ↑I₀ ∧ I = ⇑f '' I₀

case mpr
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set β
⊢ (∃ I₀, M.Indep ↑I₀ ∧ I = ⇑f '' I₀) → M.Indep ↑(⇑f ⁻¹' I) ∧ ∃ t, ⇑f '' t = I
tactic: constructor
state_before: case mpr
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set β
⊢ (∃ I₀, M.Indep ↑I₀ ∧ I = ⇑f '' I₀) → M.Indep ↑(⇑f ⁻¹' I) ∧ ∃ t, ⇑f '' t = I
state_after: case mpr.intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set ↑M.E
hI : M.Indep ↑I
⊢ M.Indep ↑(⇑f ⁻¹' (⇑f '' I)) ∧ ∃ t, ⇑f '' t = ⇑f '' I
tactic: rintro ⟨I, hI, rfl⟩
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set ↑M.E
hI : M.Indep ↑I
⊢ M.Indep ↑(⇑f ⁻¹' (⇑f '' I)) ∧ ∃ t, ⇑f '' t = ⇑f '' I
state_after: case mpr.intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set ↑M.E
hI : M.Indep ↑I
⊢ M.Indep ↑I ∧ ∃ t, ⇑f '' t = ⇑f '' I
tactic: rw [preimage_image_eq _ f.injective]
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : ↑M.E ↪ β
I : Set ↑M.E
hI : M.Indep ↑I
⊢ M.Indep ↑I ∧ ∃ t, ⇑f '' t = ⇑f '' I
state_after: no goals
tactic: exact ⟨hI, _, rfl⟩
Theorem: Cardinal.aleph'_nat
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: n : ℕ
⊢ aleph' (succ ↑n) = ↑n.succ
state_after: no goals
tactic: rw [aleph'_succ, aleph'_nat n, nat_succ]
Theorem: Function.not_surjective_Type
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α✝ : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
⊢ ¬Surjective f
state_after: α✝ : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
⊢ False
tactic: intro hf
state_before: α✝ : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
⊢ False
state_after: α✝ : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
⊢ False
tactic: let T : Type max u v := Sigma f
Theorem: not_fermat_42
File: Mathlib/NumberTheory/FLT/Four.lean

Proof steps:
state_before: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
⊢ a ^ 4 + b ^ 4 ≠ c ^ 2
state_after: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
h : a ^ 4 + b ^ 4 = c ^ 2
⊢ False
tactic: intro h
state_before: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
h : a ^ 4 + b ^ 4 = c ^ 2
⊢ False
state_after: case intro.intro.intro.intro.intro
a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
h : a ^ 4 + b ^ 4 = c ^ 2
a0 b0 c0 : ℤ
hf : Fermat42.Minimal a0 b0 c0
h2 : a0 % 2 = 1
hp : 0 < c0
⊢ False
tactic: obtain ⟨a0, b0, c0, ⟨hf, h2, hp⟩⟩ :=
    Fermat42.exists_pos_odd_minimal (And.intro ha (And.intro hb h))
state_before: case intro.intro.intro.intro.intro
a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
h : a ^ 4 + b ^ 4 = c ^ 2
a0 b0 c0 : ℤ
hf : Fermat42.Minimal a0 b0 c0
h2 : a0 % 2 = 1
hp : 0 < c0
⊢ False
state_after: no goals
tactic: apply Fermat42.not_minimal hf h2 hp
Theorem: Set.chainHeight_eq_top_iff
File: Mathlib/Order/Height.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
⊢ s.chainHeight = ⊤ ↔ ∀ (n : ℕ), ∃ l ∈ s.subchain, l.length = n
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
h : ∀ (n : ℕ), ∃ l ∈ s.subchain, l.length = n
⊢ s.chainHeight = ⊤
tactic: refine ⟨fun h n ↦ le_chainHeight_iff.1 (le_top.trans_eq h.symm), fun h ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
h : ∀ (n : ℕ), ∃ l ∈ s.subchain, l.length = n
⊢ s.chainHeight = ⊤
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
h : s.chainHeight ≠ ⊤
⊢ ∃ n, ∀ l ∈ s.subchain, l.length ≠ n
tactic: contrapose! h
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
h : s.chainHeight ≠ ⊤
⊢ ∃ n, ∀ l ∈ s.subchain, l.length ≠ n
state_after: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
h : s.chainHeight ≠ ⊤
n : ℕ
hn : ↑n = s.chainHeight
⊢ ∃ n, ∀ l ∈ s.subchain, l.length ≠ n
tactic: obtain ⟨n, hn⟩ := WithTop.ne_top_iff_exists.1 h
state_before: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
h : s.chainHeight ≠ ⊤
n : ℕ
hn : ↑n = s.chainHeight
⊢ ∃ n, ∀ l ∈ s.subchain, l.length ≠ n
state_after: no goals
tactic: exact ⟨n + 1, fun l hs ↦ (Nat.lt_succ_iff.2 <| Nat.cast_le.1 <|
    (length_le_chainHeight_of_mem_subchain hs).trans_eq hn.symm).ne⟩
Theorem: WeierstrassCurve.Jacobian.map_addX
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ addX (map W' f) (⇑f ∘ P) (⇑f ∘ Q) = f (W'.addX P Q)
state_after: no goals
tactic: simp [addX]
Theorem: List.erase_diff_erase_sublist_of_sublist
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : b = a
⊢ (l₂.erase a).diff ((b :: l₁).erase a) <+ l₂.diff (b :: l₁)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : b = a
⊢ (l₂.erase a).diff l₁ <+ (l₂.erase a).diff l₁
tactic: simp only [heq, erase_cons_head, diff_cons]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : b = a
⊢ (l₂.erase a).diff l₁ <+ (l₂.erase a).diff l₁
state_after: no goals
tactic: rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ (l₂.erase a).diff ((b :: l₁).erase a) <+ l₂.diff (b :: l₁)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
tactic: simp only [erase_cons_head b l₁, erase_cons_tail l₁ (not_beq_of_ne heq),
        diff_cons ((List.erase l₂ a)) (List.erase l₁ a) b, diff_cons l₂ l₁ b, erase_comm a b l₂]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : (b :: l₁).erase b <+ l₂.erase b
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
tactic: have h' := h.erase b
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : (b :: l₁).erase b <+ l₂.erase b
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : l₁ <+ l₂.erase b
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
tactic: rw [erase_cons_head] at h'
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : l₁ <+ l₂.erase b
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
state_after: no goals
tactic: exact @erase_diff_erase_sublist_of_sublist _ l₁ (l₂.erase b) h'
Theorem: Topology.lawsonOpen_iff_scottOpen_of_isUpperSet'
File: Mathlib/Topology/Order/LawsonTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
L S : TopologicalSpace α
inst✝¹ : IsLawson α
inst✝ : IsScott α
s : Set α
h : IsUpperSet s
⊢ IsOpen s ↔ IsOpen s
state_after: no goals
tactic: exact lawsonOpen_iff_scottOpen_of_isUpperSet h
Theorem: Filter.Tendsto.prod_map_prod_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : SemilatticeSup γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atTop
hg : Tendsto g G atTop
⊢ Tendsto (Prod.map f g) (F ×ˢ G) atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : SemilatticeSup γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atTop
hg : Tendsto g G atTop
⊢ Tendsto (Prod.map f g) (F ×ˢ G) (atTop ×ˢ atTop)
tactic: rw [← prod_atTop_atTop_eq]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : SemilatticeSup γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atTop
hg : Tendsto g G atTop
⊢ Tendsto (Prod.map f g) (F ×ˢ G) (atTop ×ˢ atTop)
state_after: no goals
tactic: exact hf.prod_map hg
Theorem: IsAddSubgroup.add_mem_cancel_right
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
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
hs : IsSubgroup s
h : a ∈ s
hba : b * a ∈ s
⊢ b ∈ s
state_after: no goals
tactic: simpa using hs.mul_mem hba (hs.inv_mem h)
Theorem: ProbabilityTheory.variance_le_expectation_sq
File: Mathlib/Probability/Variance.lean

Proof steps:
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : Ω → ℝ
hm : AEStronglyMeasurable X ℙ
⊢ variance X ℙ ≤ ∫ (a : Ω), (X ^ 2) a
state_after: case pos
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : Ω → ℝ
hm : AEStronglyMeasurable X ℙ
hX : Memℒp X 2 ℙ
⊢ variance X ℙ ≤ ∫ (a : Ω), (X ^ 2) a

case neg
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : Ω → ℝ
hm : AEStronglyMeasurable X ℙ
hX : ¬Memℒp X 2 ℙ
⊢ variance X ℙ ≤ ∫ (a : Ω), (X ^ 2) a
tactic: by_cases hX : Memℒp X 2
state_before: case neg
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : Ω → ℝ
hm : AEStronglyMeasurable X ℙ
hX : ¬Memℒp X 2 ℙ
⊢ variance X ℙ ≤ ∫ (a : Ω), (X ^ 2) a
state_after: case neg
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : Ω → ℝ
hm : AEStronglyMeasurable X ℙ
hX : ¬Memℒp X 2 ℙ
⊢ ∫ (a : Ω), (X a - ∫ (x : Ω), X x) ^ 2 ≤ ∫ (a : Ω), (X ^ 2) a

case neg.hf
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : Ω → ℝ
hm : AEStronglyMeasurable X ℙ
hX : ¬Memℒp X 2 ℙ
⊢ 0 ≤ᶠ[ae ℙ] fun ω => (X ω - ∫ (x : Ω), X x) ^ 2

case neg.hfm
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : Ω → ℝ
hm : AEStronglyMeasurable X ℙ
hX : ¬Memℒp X 2 ℙ
⊢ AEStronglyMeasurable (fun ω => (X ω - ∫ (x : Ω), X x) ^ 2) ℙ
tactic: rw [variance, evariance_eq_lintegral_ofReal, ← integral_eq_lintegral_of_nonneg_ae]
Theorem: WeierstrassCurve.map_ψ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (W.map f).ψ n = Polynomial.map (mapRingHom f) (W.ψ n)
state_after: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ normEDS ((mapRingHom (mapRingHom f)) W.ψ₂) (C ((mapRingHom f) W.Ψ₃)) (C ((mapRingHom f) W.preΨ₄)) n =
    normEDS ((mapRingHom (mapRingHom f)) W.ψ₂) ((mapRingHom (mapRingHom f)) (C W.Ψ₃))
      ((mapRingHom (mapRingHom f)) (C W.preΨ₄)) n
tactic: simp only [ψ, map_ψ₂, map_Ψ₃, map_preΨ₄, ← coe_mapRingHom, map_normEDS]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ normEDS ((mapRingHom (mapRingHom f)) W.ψ₂) (C ((mapRingHom f) W.Ψ₃)) (C ((mapRingHom f) W.preΨ₄)) n =
    normEDS ((mapRingHom (mapRingHom f)) W.ψ₂) ((mapRingHom (mapRingHom f)) (C W.Ψ₃))
      ((mapRingHom (mapRingHom f)) (C W.preΨ₄)) n
state_after: no goals
tactic: map_simp
Theorem: Matrix.schur_complement_eq₂₂
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁷ : CommRing 𝕜
inst✝⁶ : PartialOrder 𝕜
inst✝⁵ : StarRing 𝕜
inst✝⁴ : StarOrderedRing 𝕜
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq n
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
x : m → 𝕜
y : n → 𝕜
inst✝ : Invertible D
hD : D.IsHermitian
⊢ star (x ⊕ᵥ y) ᵥ* fromBlocks A B Bᴴ D ⬝ᵥ (x ⊕ᵥ y) =
    star ((D⁻¹ * Bᴴ) *ᵥ x + y) ᵥ* D ⬝ᵥ ((D⁻¹ * Bᴴ) *ᵥ x + y) + star x ᵥ* (A - B * D⁻¹ * Bᴴ) ⬝ᵥ x
state_after: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁷ : CommRing 𝕜
inst✝⁶ : PartialOrder 𝕜
inst✝⁵ : StarRing 𝕜
inst✝⁴ : StarOrderedRing 𝕜
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq n
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
x : m → 𝕜
y : n → 𝕜
inst✝ : Invertible D
hD : D.IsHermitian
⊢ star x ᵥ* A ⬝ᵥ x + star y ᵥ* Bᴴ ⬝ᵥ x + (star x ᵥ* B ⬝ᵥ y + star y ᵥ* D ⬝ᵥ y) =
    star x ᵥ* (B * (D⁻¹ * Bᴴ)) ⬝ᵥ x + star y ᵥ* Bᴴ ⬝ᵥ x + (star x ᵥ* B ⬝ᵥ y + star y ᵥ* D ⬝ᵥ y) +
      (star x ᵥ* A ⬝ᵥ x - star x ᵥ* (B * (D⁻¹ * Bᴴ)) ⬝ᵥ x)
tactic: simp [Function.star_sum_elim, fromBlocks_mulVec, vecMul_fromBlocks, add_vecMul,
    dotProduct_mulVec, vecMul_sub, Matrix.mul_assoc, vecMul_mulVec, hD.eq,
    conjTranspose_nonsing_inv, star_mulVec]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁷ : CommRing 𝕜
inst✝⁶ : PartialOrder 𝕜
inst✝⁵ : StarRing 𝕜
inst✝⁴ : StarOrderedRing 𝕜
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq n
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
x : m → 𝕜
y : n → 𝕜
inst✝ : Invertible D
hD : D.IsHermitian
⊢ star x ᵥ* A ⬝ᵥ x + star y ᵥ* Bᴴ ⬝ᵥ x + (star x ᵥ* B ⬝ᵥ y + star y ᵥ* D ⬝ᵥ y) =
    star x ᵥ* (B * (D⁻¹ * Bᴴ)) ⬝ᵥ x + star y ᵥ* Bᴴ ⬝ᵥ x + (star x ᵥ* B ⬝ᵥ y + star y ᵥ* D ⬝ᵥ y) +
      (star x ᵥ* A ⬝ᵥ x - star x ᵥ* (B * (D⁻¹ * Bᴴ)) ⬝ᵥ x)
state_after: no goals
tactic: abel
Theorem: Monotone.map_ciSup_of_continuousAt
File: Mathlib/Topology/Order/Monotone.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
g : γ → α
Cf : ContinuousAt f (⨆ i, g i)
Mf : Monotone f
H : BddAbove (range g)
⊢ f (⨆ i, g i) = ⨆ i, f (g i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
g : γ → α
Cf : ContinuousAt f (⨆ i, g i)
Mf : Monotone f
H : BddAbove (range g)
⊢ sSup (range (f ∘ fun i => g i)) = sSup (range fun i => f (g i))
tactic: rw [iSup, Mf.map_csSup_of_continuousAt Cf (range_nonempty _) H, ← range_comp, iSup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
g : γ → α
Cf : ContinuousAt f (⨆ i, g i)
Mf : Monotone f
H : BddAbove (range g)
⊢ sSup (range (f ∘ fun i => g i)) = sSup (range fun i => f (g i))
state_after: no goals
tactic: rfl
Theorem: LieAlgebra.Orthogonal.pd_inv
File: Mathlib/Algebra/Lie/Classical.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁸ : DecidableEq n
inst✝⁷ : DecidableEq p
inst✝⁶ : DecidableEq q
inst✝⁵ : DecidableEq l
inst✝⁴ : CommRing R
inst✝³ : Fintype p
inst✝² : Fintype q
inst✝¹ : Fintype l
inst✝ : Invertible 2
⊢ PD l R * ⅟2 • (PD l R)ᵀ = 1
state_after: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁸ : DecidableEq n
inst✝⁷ : DecidableEq p
inst✝⁶ : DecidableEq q
inst✝⁵ : DecidableEq l
inst✝⁴ : CommRing R
inst✝³ : Fintype p
inst✝² : Fintype q
inst✝¹ : Fintype l
inst✝ : Invertible 2
⊢ fromBlocks (1 * ⅟2 • 1ᵀ + -1 * ⅟2 • (-1)ᵀ) (1 * ⅟2 • 1ᵀ + -1 * ⅟2 • 1ᵀ) (1 * ⅟2 • 1ᵀ + 1 * ⅟2 • (-1)ᵀ)
      (1 * ⅟2 • 1ᵀ + 1 * ⅟2 • 1ᵀ) =
    1
tactic: rw [PD, Matrix.fromBlocks_transpose, Matrix.fromBlocks_smul,
    Matrix.fromBlocks_multiply]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁸ : DecidableEq n
inst✝⁷ : DecidableEq p
inst✝⁶ : DecidableEq q
inst✝⁵ : DecidableEq l
inst✝⁴ : CommRing R
inst✝³ : Fintype p
inst✝² : Fintype q
inst✝¹ : Fintype l
inst✝ : Invertible 2
⊢ fromBlocks (1 * ⅟2 • 1ᵀ + -1 * ⅟2 • (-1)ᵀ) (1 * ⅟2 • 1ᵀ + -1 * ⅟2 • 1ᵀ) (1 * ⅟2 • 1ᵀ + 1 * ⅟2 • (-1)ᵀ)
      (1 * ⅟2 • 1ᵀ + 1 * ⅟2 • 1ᵀ) =
    1
state_after: no goals
tactic: simp
Theorem: MeasureTheory.densityToFinite_ae_lt_top
File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
⊢ ∀ᵐ (x : α) ∂μ, μ.densityToFinite x < ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ.restrict s, μ.densityToFinite x < ⊤
tactic: refine ae_of_forall_measure_lt_top_ae_restrict _ (fun s _ hμs ↦ ?_)
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ.restrict s, μ.densityToFinite x < ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ.toFinite.restrict s, μ.densityToFinite x < ⊤
tactic: suffices ∀ᵐ x ∂μ.toFinite.restrict s, μ.densityToFinite x < ∞ from
    (absolutelyContinuous_toFinite μ).restrict _ this
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ.toFinite.restrict s, μ.densityToFinite x < ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∫⁻ (x : α) in s, μ.densityToFinite x ∂μ.toFinite ≠ ⊤
tactic: refine ae_lt_top (measurable_densityToFinite μ) ?_
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∫⁻ (x : α) in s, μ.densityToFinite x ∂μ.toFinite ≠ ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ μ s ≠ ⊤
tactic: rw [← withDensity_apply', withDensity_densitytoFinite]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ μ s ≠ ⊤
state_after: no goals
tactic: exact hμs.ne