ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: NoZeroSMulDivisors.isReduced
File: Mathlib/RingTheory/Nilpotent/Basic.lean

Proof steps:
state_before: R✝ : Type u_1
S : Type u_2
x y : R✝
R : Type u_3
M : Type u_4
inst✝⁴ : MonoidWithZero R
inst✝³ : Zero M
inst✝² : MulActionWithZero R M
inst✝¹ : Nontrivial M
inst✝ : NoZeroSMulDivisors R M
⊢ IsReduced R
state_after: R✝ : Type u_1
S : Type u_2
x✝¹ y : R✝
R : Type u_3
M : Type u_4
inst✝⁴ : MonoidWithZero R
inst✝³ : Zero M
inst✝² : MulActionWithZero R M
inst✝¹ : Nontrivial M
inst✝ : NoZeroSMulDivisors R M
x : R
x✝ : IsNilpotent x
k : ℕ
hk : x ^ k = 0
⊢ x = 0
tactic: refine ⟨fun x ⟨k, hk⟩ ↦ ?_⟩
state_before: R✝ : Type u_1
S : Type u_2
x✝¹ y : R✝
R : Type u_3
M : Type u_4
inst✝⁴ : MonoidWithZero R
inst✝³ : Zero M
inst✝² : MulActionWithZero R M
inst✝¹ : Nontrivial M
inst✝ : NoZeroSMulDivisors R M
x : R
x✝ : IsNilpotent x
k : ℕ
hk : x ^ k = 0
⊢ x = 0
state_after: case zero
R✝ : Type u_1
S : Type u_2
x✝¹ y : R✝
R : Type u_3
M : Type u_4
inst✝⁴ : MonoidWithZero R
inst✝³ : Zero M
inst✝² : MulActionWithZero R M
inst✝¹ : Nontrivial M
inst✝ : NoZeroSMulDivisors R M
x : R
x✝ : IsNilpotent x
hk : x ^ 0 = 0
⊢ x = 0

case succ
R✝ : Type u_1
S : Type u_2
x✝¹ y : R✝
R : Type u_3
M : Type u_4
inst✝⁴ : MonoidWithZero R
inst✝³ : Zero M
inst✝² : MulActionWithZero R M
inst✝¹ : Nontrivial M
inst✝ : NoZeroSMulDivisors R M
x : R
x✝ : IsNilpotent x
k : ℕ
ih : x ^ k = 0 → x = 0
hk : x ^ (k + 1) = 0
⊢ x = 0
tactic: induction' k with k ih
Theorem: RingQuot.eq_liftAlgHom_comp_mkAlgHom
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ f = (liftAlgHom S) ⟨f.comp (mkAlgHom S s), ⋯⟩
state_after: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ (liftAlgHom S) ((liftAlgHom S).symm f) = (liftAlgHom S) ⟨f.comp (mkAlgHom S s), ⋯⟩
tactic: conv_lhs => rw [← (liftAlgHom S).apply_symm_apply f]
state_before: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ (liftAlgHom S) ((liftAlgHom S).symm f) = (liftAlgHom S) ⟨f.comp (mkAlgHom S s), ⋯⟩
state_after: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ { toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
      ({ toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯,
            right_inv := ⋯ }.symm
        f) =
    { toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯,
        right_inv := ⋯ }
      ⟨f.comp (mkAlgHom S s), ⋯⟩
tactic: rw [liftAlgHom]
state_before: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ { toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
      ({ toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯,
            right_inv := ⋯ }.symm
        f) =
    { toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯,
        right_inv := ⋯ }
      ⟨f.comp (mkAlgHom S s), ⋯⟩
state_after: no goals
tactic: rfl
Theorem: QuotientGroup.eq
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
a b : α
⊢ Setoid.r a b ↔ a⁻¹ * b ∈ s
state_after: no goals
tactic: rw [leftRel_apply]
Theorem: Directed.finset_le
File: Mathlib/Data/Finset/Order.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝ : IsTrans α r
ι : Type u_1
hι : Nonempty ι
f : ι → α
D : Directed r f
s : Finset ι
z x✝ : ι
⊢ x✝ ∈ 0 → r (f x✝) (f z)
state_after: no goals
tactic: simp
Theorem: Function.partialInv_of_injective
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
a : α
b : β
h : partialInv f b = some a
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
⊢ f a = b
state_after: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
a : α
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
h : some (Classical.choose h') = some a
⊢ f a = b
tactic: rw [hpi, dif_pos h'] at h
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
a : α
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
h : some (Classical.choose h') = some a
⊢ f a = b
state_after: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
a : α
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
h : Classical.choose h' = a
⊢ f a = b
tactic: injection h with h
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
a : α
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
h : Classical.choose h' = a
⊢ f a = b
state_after: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
⊢ f (Classical.choose h') = b
tactic: subst h
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
⊢ f (Classical.choose h') = b
state_after: no goals
tactic: apply Classical.choose_spec h'
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
a : α
b : β
h : partialInv f b = some a
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ¬∃ a, f a = b
⊢ f a = b
state_after: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
a : α
b : β
h : none = some a
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ¬∃ a, f a = b
⊢ f a = b
tactic: rw [hpi, dif_neg h'] at h
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
f✝ : α✝ → β✝
α : Type u_4
β : Sort u_5
f : α → β
I : Injective f
a : α
b : β
h : none = some a
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ¬∃ a, f a = b
⊢ f a = b
state_after: no goals
tactic: contradiction
Theorem: Finset.compls_infs_eq_diffs
File: Mathlib/Data/Finset/Sups.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : BooleanAlgebra α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b c : α
s t : Finset α
⊢ sᶜˢ ⊼ t = t \\ s
state_after: no goals
tactic: rw [infs_comm, infs_compls_eq_diffs]
Theorem: Matrix.submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det
File: Mathlib/LinearAlgebra/Matrix/Determinant/Misc.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
M : Matrix (Fin (n + 1)) (Fin n) R
hv : ∑ j : Fin (n + 1), M j = 0
j₁ j₂ : Fin (n + 1)
⊢ (M.submatrix j₁.succAbove id).det = (↑↑j₁ - ↑↑j₂).negOnePow • (M.submatrix j₂.succAbove id).det
state_after: R : Type u_1
inst✝ : CommRing R
n : ℕ
M : Matrix (Fin (n + 1)) (Fin n) R
hv : ∑ j : Fin (n + 1), M j = 0
j₁ j₂ : Fin (n + 1)
⊢ ∀ (j : Fin (n + 1)), (M.submatrix j.succAbove id).det = (↑↑j).negOnePow • (M.submatrix (Fin.succAbove 0) id).det
tactic: suffices ∀ j, (M.submatrix (Fin.succAbove j) id).det =
      Int.negOnePow j • (M.submatrix (Fin.succAbove 0) id).det by
    rw [this j₁, this j₂, smul_smul, ← Int.negOnePow_add, sub_add_cancel]
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
M : Matrix (Fin (n + 1)) (Fin n) R
hv : ∑ j : Fin (n + 1), M j = 0
j₁ j₂ : Fin (n + 1)
⊢ ∀ (j : Fin (n + 1)), (M.submatrix j.succAbove id).det = (↑↑j).negOnePow • (M.submatrix (Fin.succAbove 0) id).det
state_after: R : Type u_1
inst✝ : CommRing R
n : ℕ
M : Matrix (Fin (n + 1)) (Fin n) R
hv : ∑ j : Fin (n + 1), M j = 0
j₁ j₂ j : Fin (n + 1)
⊢ (M.submatrix j.succAbove id).det = (↑↑j).negOnePow • (M.submatrix (Fin.succAbove 0) id).det
tactic: intro j
Theorem: Complex.polarCoord_symm_apply
File: Mathlib/Analysis/SpecialFunctions/PolarCoord.lean

Proof steps:
state_before: p : ℝ × ℝ
⊢ ↑Complex.polarCoord.symm p = ↑p.1 * (↑(Real.cos p.2) + ↑(Real.sin p.2) * I)
state_after: no goals
tactic: simp [Complex.polarCoord, equivRealProdCLM_symm_apply, mul_add, mul_assoc]
Theorem: IsAddUnit.sub_add_left
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit b
⊢ b / (a * b) = 1 / a
state_after: no goals
tactic: rw [h.div_mul_cancel_right, one_div]
Theorem: MeasureTheory.OuterMeasure.top_apply'
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : OuterMeasure α
s : Set α
h : s = ∅
⊢ ⊤ s = ⨅ (_ : s = ∅), 0
state_after: no goals
tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
m : OuterMeasure α
s : Set α
h : s.Nonempty
⊢ ⊤ s = ⨅ (_ : s = ∅), 0
state_after: no goals
tactic: simp [h, h.ne_empty]
Theorem: CoxeterSystem.IsReduced.nodup_leftInvSeq
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
rω : cs.IsReduced ω
⊢ (cs.leftInvSeq ω).Nodup
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
rω : cs.IsReduced ω
⊢ (cs.rightInvSeq ω.reverse).Nodup
tactic: simp only [leftInvSeq_eq_reverse_rightInvSeq_reverse, nodup_reverse]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
rω : cs.IsReduced ω
⊢ (cs.rightInvSeq ω.reverse).Nodup
state_after: case rω
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
rω : cs.IsReduced ω
⊢ cs.IsReduced ω.reverse
tactic: apply nodup_rightInvSeq
state_before: case rω
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
rω : cs.IsReduced ω
⊢ cs.IsReduced ω.reverse
state_after: no goals
tactic: rwa [isReduced_reverse]
Theorem: AddGroupFilterBasis.mem_nhds_zero
File: Mathlib/Topology/Algebra/FilterBasis.lean

Proof steps:
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
U : Set G
hU : U ∈ B
⊢ U ∈ 𝓝 1
state_after: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
U : Set G
hU : U ∈ B
⊢ ∃ i ∈ B, id i ⊆ U
tactic: rw [B.nhds_one_hasBasis.mem_iff]
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
U : Set G
hU : U ∈ B
⊢ ∃ i ∈ B, id i ⊆ U
state_after: no goals
tactic: exact ⟨U, hU, rfl.subset⟩
Theorem: toIcoDiv_sub_eq_toIcoDiv_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ toIcoDiv hp a (b - c) = toIcoDiv hp (a + c) b
state_after: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ b - c - toIcoDiv hp (a + c) b • p ∈ Set.Ico a (a + p)
tactic: apply toIcoDiv_eq_of_sub_zsmul_mem_Ico
state_before: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ b - c - toIcoDiv hp (a + c) b • p ∈ Set.Ico a (a + p)
state_after: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ b - toIcoDiv hp (a + c) b • p ∈ Set.Ico (a + c) (a + c + p)
tactic: rw [← sub_right_comm, Set.sub_mem_Ico_iff_left, add_right_comm]
state_before: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ b - toIcoDiv hp (a + c) b • p ∈ Set.Ico (a + c) (a + c + p)
state_after: no goals
tactic: exact sub_toIcoDiv_zsmul_mem_Ico hp (a + c) b
Theorem: Option.mem_pmem
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f : (a : α) → p a → β
x : Option α
a : α
h : ∀ (a : α), a ∈ x → p a
ha : a ∈ x
⊢ f a ⋯ ∈ pmap f x h
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f : (a : α) → p a → β
x : Option α
a : α
h : ∀ (a : α), a ∈ x → p a
ha✝ : a ∈ x
ha : x = some a
⊢ pmap f x h = some (f a ⋯)
tactic: rw [mem_def] at ha ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f : (a : α) → p a → β
x : Option α
a : α
h : ∀ (a : α), a ∈ x → p a
ha✝ : a ∈ x
ha : x = some a
⊢ pmap f x h = some (f a ⋯)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f : (a : α) → p a → β
a : α
h : ∀ (a_1 : α), a_1 ∈ some a → p a_1
ha : a ∈ some a
⊢ pmap f (some a) h = some (f a ⋯)
tactic: subst ha
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f : (a : α) → p a → β
a : α
h : ∀ (a_1 : α), a_1 ∈ some a → p a_1
ha : a ∈ some a
⊢ pmap f (some a) h = some (f a ⋯)
state_after: no goals
tactic: rfl
Theorem: RelSeries.mem_toList
File: Mathlib/Order/RelSeries.lean

Proof steps:
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s✝ : Rel β β
s : RelSeries r
x : α
⊢ x ∈ s.toList ↔ x ∈ s
state_after: no goals
tactic: rw [RelSeries.toList, List.mem_ofFn, RelSeries.mem_def]
Theorem: OrderIso.mulRight_symm
File: Mathlib/Algebra/Order/Group/OrderIso.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c d a : α
⊢ (mulRight a).symm = mulRight a⁻¹
state_after: case h.h
α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c d a x : α
⊢ (mulRight a).symm x = (mulRight a⁻¹) x
tactic: ext x
state_before: case h.h
α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c d a x : α
⊢ (mulRight a).symm x = (mulRight a⁻¹) x
state_after: no goals
tactic: rfl
Theorem: MonovaryOn.sum_mul_sum_le_card_mul_sum
File: Mathlib/Algebra/Order/Chebyshev.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
hfg : MonovaryOn f g ↑s
⊢ (∑ i ∈ s, f i) * ∑ i ∈ s, g i ≤ ↑s.card * ∑ i ∈ s, f i * g i
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
hfg : MonovaryOn f g ↑s
⊢ (∑ i ∈ s, f i) * ∑ i ∈ s, g i ≤ s.card • ∑ i ∈ s, f i * g i
tactic: rw [← nsmul_eq_mul]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
hfg : MonovaryOn f g ↑s
⊢ (∑ i ∈ s, f i) * ∑ i ∈ s, g i ≤ s.card • ∑ i ∈ s, f i * g i
state_after: no goals
tactic: exact hfg.sum_smul_sum_le_card_smul_sum
Theorem: BumpCovering.toPOUFun_zero_of_zero
File: Mathlib/Topology/PartitionOfUnity.lean

Proof steps:
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
h : (f i) x = 0
⊢ f.toPOUFun i x = 0
state_after: no goals
tactic: rw [toPOUFun, h, zero_mul]
Theorem: exists_pow_lt_of_lt_one
File: Mathlib/Algebra/Order/Archimedean.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : y < 1
⊢ ∃ n, y ^ n < x
state_after: case pos
α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : y < 1
y_pos : y ≤ 0
⊢ ∃ n, y ^ n < x

case neg
α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : y < 1
y_pos : ¬y ≤ 0
⊢ ∃ n, y ^ n < x
tactic: by_cases y_pos : y ≤ 0
state_before: case neg
α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : y < 1
y_pos : ¬y ≤ 0
⊢ ∃ n, y ^ n < x
state_after: case neg
α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : y < 1
y_pos : 0 < y
⊢ ∃ n, y ^ n < x
tactic: rw [not_le] at y_pos
state_before: case neg
α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : y < 1
y_pos : 0 < y
⊢ ∃ n, y ^ n < x
state_after: case neg.intro
α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : y < 1
y_pos : 0 < y
q : ℕ
hq : x⁻¹ < y⁻¹ ^ q
⊢ ∃ n, y ^ n < x
tactic: rcases pow_unbounded_of_one_lt x⁻¹ (one_lt_inv y_pos hy) with ⟨q, hq⟩
state_before: case neg.intro
α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : y < 1
y_pos : 0 < y
q : ℕ
hq : x⁻¹ < y⁻¹ ^ q
⊢ ∃ n, y ^ n < x
state_after: no goals
tactic: exact ⟨q, by rwa [inv_pow, inv_lt_inv hx (pow_pos y_pos _)] at hq⟩
Theorem: Set.LeftInvOn.filter_map_Iic
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInvOn g f s
F : Filter α
hF : F ≤ 𝓟 s
⊢ map g (map f F) = F
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInvOn g f s
F : Filter α
hF : F ≤ 𝓟 s
this : g ∘ f =ᶠ[𝓟 s] id
⊢ map g (map f F) = F
tactic: have : (g ∘ f) =ᶠ[𝓟 s] id := by simpa only [eventuallyEq_principal] using hfg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInvOn g f s
F : Filter α
hF : F ≤ 𝓟 s
this : g ∘ f =ᶠ[𝓟 s] id
⊢ map g (map f F) = F
state_after: no goals
tactic: rw [map_map, map_congr (this.filter_mono hF), map_id]
Theorem: Complex.lift_symm_apply_coe
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
F : ℂ →ₐ[ℝ] A
⊢ F I * F I = -1
state_after: no goals
tactic: rw [← map_mul, I_mul_I, map_neg, map_one]
Theorem: MeasureTheory.Measure.WeaklyRegular.restrict_of_measure_ne_top
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : BorelSpace α
inst✝ : μ.WeaklyRegular
A : Set α
h'A : μ A ≠ ⊤
⊢ (μ.restrict A).WeaklyRegular
state_after: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : BorelSpace α
inst✝ : μ.WeaklyRegular
A : Set α
h'A : μ A ≠ ⊤
this : Fact (μ A < ⊤)
⊢ (μ.restrict A).WeaklyRegular
tactic: haveI : Fact (μ A < ∞) := ⟨h'A.lt_top⟩
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : BorelSpace α
inst✝ : μ.WeaklyRegular
A : Set α
h'A : μ A ≠ ⊤
this : Fact (μ A < ⊤)
⊢ (μ.restrict A).WeaklyRegular
state_after: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : BorelSpace α
inst✝ : μ.WeaklyRegular
A : Set α
h'A : μ A ≠ ⊤
this : Fact (μ A < ⊤)
V : Set α
V_open : IsOpen V
r : ℝ≥0∞
hr : r < (μ.restrict A) V
⊢ ∃ K ⊆ V, IsClosed K ∧ r < (μ.restrict A) K
tactic: refine InnerRegularWRT.weaklyRegular_of_finite (μ.restrict A) (fun V V_open r hr ↦ ?_)
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : BorelSpace α
inst✝ : μ.WeaklyRegular
A : Set α
h'A : μ A ≠ ⊤
this : Fact (μ A < ⊤)
V : Set α
V_open : IsOpen V
r : ℝ≥0∞
hr : r < (μ.restrict A) V
⊢ ∃ K ⊆ V, IsClosed K ∧ r < (μ.restrict A) K
state_after: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : BorelSpace α
inst✝ : μ.WeaklyRegular
A : Set α
h'A : μ A ≠ ⊤
this✝ : Fact (μ A < ⊤)
V : Set α
V_open : IsOpen V
r : ℝ≥0∞
hr : r < (μ.restrict A) V
this : (μ.restrict A).InnerRegularWRT IsClosed fun s => MeasurableSet s
⊢ ∃ K ⊆ V, IsClosed K ∧ r < (μ.restrict A) K
tactic: have : InnerRegularWRT (μ.restrict A) IsClosed (fun s ↦ MeasurableSet s) :=
    InnerRegularWRT.restrict_of_measure_ne_top innerRegular_measurable h'A
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : TopologicalSpace α
μ : Measure α
inst✝¹ : BorelSpace α
inst✝ : μ.WeaklyRegular
A : Set α
h'A : μ A ≠ ⊤
this✝ : Fact (μ A < ⊤)
V : Set α
V_open : IsOpen V
r : ℝ≥0∞
hr : r < (μ.restrict A) V
this : (μ.restrict A).InnerRegularWRT IsClosed fun s => MeasurableSet s
⊢ ∃ K ⊆ V, IsClosed K ∧ r < (μ.restrict A) K
state_after: no goals
tactic: exact this V_open.measurableSet r hr
Theorem: mem_openSegment_of_ne_left_right
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s : Set E
x y z : E
hx : x ≠ z
hy : y ≠ z
hz : z ∈ [x-[𝕜]y]
⊢ z ∈ openSegment 𝕜 x y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s : Set E
x y z : E
hx : x ≠ z
hy : y ≠ z
hz : z ∈ insert x (insert y (openSegment 𝕜 x y))
⊢ z ∈ openSegment 𝕜 x y
tactic: rw [← insert_endpoints_openSegment] at hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s : Set E
x y z : E
hx : x ≠ z
hy : y ≠ z
hz : z ∈ insert x (insert y (openSegment 𝕜 x y))
⊢ z ∈ openSegment 𝕜 x y
state_after: no goals
tactic: exact (hz.resolve_left hx.symm).resolve_left hy.symm