ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.HasBasis.eq_iInf
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis (fun x => True) s
⊢ l = ⨅ i, 𝓟 (s i)
state_after: no goals
tactic: simpa only [iInf_true] using h.eq_biInf
Theorem: Mathlib.Vector.map_id
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
v : Vector α n
⊢ (map id v).toList = v.toList
state_after: no goals
tactic: simp only [List.map_id, Vector.toList_map]
Theorem: MulAction.mem_fixedPoints_iff_card_orbit_eq_one
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ a ∈ fixedPoints M α ↔ Fintype.card ↑(orbit M a) = 1
state_after: M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ (∀ (m : M), m • a = a) ↔ ∃ x, ∀ (y : ↑(orbit M a)), y = x
tactic: rw [Fintype.card_eq_one_iff, mem_fixedPoints]
state_before: M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ (∀ (m : M), m • a = a) ↔ ∃ x, ∀ (y : ↑(orbit M a)), y = x
state_after: case mp
M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ (∀ (m : M), m • a = a) → ∃ x, ∀ (y : ↑(orbit M a)), y = x

case mpr
M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ (∃ x, ∀ (y : ↑(orbit M a)), y = x) → ∀ (m : M), m • a = a
tactic: constructor
Theorem: sup_himp_self_left
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c d a b : α
⊢ a ⊔ b ⇨ a = b ⇨ a
state_after: no goals
tactic: rw [sup_himp_distrib, himp_self, top_inf_eq]
Theorem: Ideal.multiset_prod_span_singleton
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
m : Multiset R
⊢ (Multiset.map (fun x => span {x}) 0).prod = span {Multiset.prod 0}
state_after: no goals
tactic: simp
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
m✝ : Multiset R
a : R
m : Multiset R
ih : (Multiset.map (fun x => span {x}) m).prod = span {m.prod}
⊢ (Multiset.map (fun x => span {x}) (a ::ₘ m)).prod = span {(a ::ₘ m).prod}
state_after: no goals
tactic: simp only [Multiset.map_cons, Multiset.prod_cons, ih, ← Ideal.span_singleton_mul_span_singleton]
Theorem: TopCat.epi_iff_surjective
File: Mathlib/Topology/Category/TopCat/EpiMono.lean

Proof steps:
state_before: X Y : TopCat
f : X ⟶ Y
⊢ Epi f ↔ Function.Surjective ⇑f
state_after: X Y : TopCat
f : X ⟶ Y
⊢ Epi f ↔ Epi ((forget TopCat).map f)
tactic: suffices Epi f ↔ Epi ((forget TopCat).map f) by
    rw [this, CategoryTheory.epi_iff_surjective]
    rfl
state_before: X Y : TopCat
f : X ⟶ Y
⊢ Epi f ↔ Epi ((forget TopCat).map f)
state_after: case mp
X Y : TopCat
f : X ⟶ Y
⊢ Epi f → Epi ((forget TopCat).map f)

case mpr
X Y : TopCat
f : X ⟶ Y
⊢ Epi ((forget TopCat).map f) → Epi f
tactic: constructor
Theorem: HomologicalComplex.op_X
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.17548, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex V c
i j : ι
hij : ¬c.symm.Rel i j
⊢ (fun i j => (X.d j i).op) i j = 0
state_after: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.17548, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex V c
i j : ι
hij : ¬c.symm.Rel i j
⊢ (X.d j i).op = 0
tactic: simp only
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.17548, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex V c
i j : ι
hij : ¬c.symm.Rel i j
⊢ (X.d j i).op = 0
state_after: no goals
tactic: rw [X.shape j i hij, op_zero]
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.17548, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex V c
x✝⁴ x✝³ x✝² : ι
x✝¹ : c.symm.Rel x✝⁴ x✝³
x✝ : c.symm.Rel x✝³ x✝²
⊢ (fun i j => (X.d j i).op) x✝⁴ x✝³ ≫ (fun i j => (X.d j i).op) x✝³ x✝² = 0
state_after: no goals
tactic: rw [← op_comp, X.d_comp_d, op_zero]
Theorem: RatFunc.taylor_mem_nonZeroDivisors
File: Mathlib/FieldTheory/Laurent.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
⊢ (taylor r) p ∈ R[X]⁰
state_after: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
⊢ ∀ (x : R[X]), x * (taylor r) p = 0 → x = 0
tactic: rw [mem_nonZeroDivisors_iff]
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
⊢ ∀ (x : R[X]), x * (taylor r) p = 0 → x = 0
state_after: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
x : R[X]
hx : x * (taylor r) p = 0
⊢ x = 0
tactic: intro x hx
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
x : R[X]
hx : x * (taylor r) p = 0
⊢ x = 0
state_after: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
x : R[X]
hx : x * (taylor r) p = 0
this : x = (taylor (r - r)) x
⊢ x = 0
tactic: have : x = taylor (r - r) x := by simp
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
x : R[X]
hx : x * (taylor r) p = 0
this : x = (taylor (r - r)) x
⊢ x = 0
state_after: no goals
tactic: rwa [this, sub_eq_add_neg, ← taylor_taylor, ← taylor_mul,
    LinearMap.map_eq_zero_iff _ (taylor_injective _), mul_right_mem_nonZeroDivisors_eq_zero_iff hp,
    LinearMap.map_eq_zero_iff _ (taylor_injective _)] at hx
Theorem: measurable_liftCover
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝ : Countable ι
t : ι → Set α
htm : ∀ (i : ι), MeasurableSet (t i)
f : (i : ι) → ↑(t i) → β
hfm : ∀ (i : ι), Measurable (f i)
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
htU : ⋃ i, t i = univ
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet (liftCover t f hf htU ⁻¹' s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝ : Countable ι
t : ι → Set α
htm : ∀ (i : ι), MeasurableSet (t i)
f : (i : ι) → ↑(t i) → β
hfm : ∀ (i : ι), Measurable (f i)
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
htU : ⋃ i, t i = univ
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet (⋃ i, Subtype.val '' (f i ⁻¹' s))
tactic: rw [preimage_liftCover]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝ : Countable ι
t : ι → Set α
htm : ∀ (i : ι), MeasurableSet (t i)
f : (i : ι) → ↑(t i) → β
hfm : ∀ (i : ι), Measurable (f i)
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
htU : ⋃ i, t i = univ
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet (⋃ i, Subtype.val '' (f i ⁻¹' s))
state_after: no goals
tactic: exact .iUnion fun i => .subtype_image (htm i) <| hfm i hs
Theorem: Submodule.finrank_lt
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
h : s < ⊤
⊢ finrank K ↥s < finrank K V
state_after: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
h : s < ⊤
⊢ finrank K ↥s < finrank K ↥s + finrank K (V ⧸ s)
tactic: rw [← s.finrank_quotient_add_finrank, add_comm]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
h : s < ⊤
⊢ finrank K ↥s < finrank K ↥s + finrank K (V ⧸ s)
state_after: no goals
tactic: exact Nat.lt_add_of_pos_right (finrank_pos_iff.mpr (Quotient.nontrivial_of_lt_top _ h))
Theorem: Set.mk_preimage_prod_right
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ha : a ∈ s
⊢ Prod.mk a ⁻¹' s ×ˢ t = t
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b✝ : β
ha : a ∈ s
b : β
⊢ b ∈ Prod.mk a ⁻¹' s ×ˢ t ↔ b ∈ t
tactic: ext b
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b✝ : β
ha : a ∈ s
b : β
⊢ b ∈ Prod.mk a ⁻¹' s ×ˢ t ↔ b ∈ t
state_after: no goals
tactic: simp [ha]
Theorem: HasCompactSupport.mul_right
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : HasCompactSupport f
⊢ HasCompactSupport (f * f')
state_after: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : f =ᶠ[coclosedCompact α] 0
⊢ f * f' =ᶠ[coclosedCompact α] 0
tactic: rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : f =ᶠ[coclosedCompact α] 0
⊢ f * f' =ᶠ[coclosedCompact α] 0
state_after: no goals
tactic: exact hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, zero_mul]
Theorem: ringHom_monotone
File: Mathlib/Algebra/Order/CompleteField.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : OrderedRing R
inst✝ : LinearOrderedRing S
hR : ∀ (r : R), 0 ≤ r → ∃ s, s ^ 2 = r
f : R →+* S
r : R
h : 0 ≤ r
⊢ 0 ≤ f r
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : OrderedRing R
inst✝ : LinearOrderedRing S
hR : ∀ (r : R), 0 ≤ r → ∃ s, s ^ 2 = r
f : R →+* S
s : R
h : 0 ≤ s ^ 2
⊢ 0 ≤ f (s ^ 2)
tactic: obtain ⟨s, rfl⟩ := hR r h
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : OrderedRing R
inst✝ : LinearOrderedRing S
hR : ∀ (r : R), 0 ≤ r → ∃ s, s ^ 2 = r
f : R →+* S
s : R
h : 0 ≤ s ^ 2
⊢ 0 ≤ f (s ^ 2)
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : OrderedRing R
inst✝ : LinearOrderedRing S
hR : ∀ (r : R), 0 ≤ r → ∃ s, s ^ 2 = r
f : R →+* S
s : R
h : 0 ≤ s ^ 2
⊢ 0 ≤ f s ^ 2
tactic: rw [map_pow]
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : OrderedRing R
inst✝ : LinearOrderedRing S
hR : ∀ (r : R), 0 ≤ r → ∃ s, s ^ 2 = r
f : R →+* S
s : R
h : 0 ≤ s ^ 2
⊢ 0 ≤ f s ^ 2
state_after: no goals
tactic: apply sq_nonneg
Theorem: Matrix.op_smul_eq_mul_diagonal
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n α
a : α
⊢ MulOpposite.op a • M = M * diagonal fun x => a
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n α
a : α
i✝ : m
j✝ : n
⊢ (MulOpposite.op a • M) i✝ j✝ = (M * diagonal fun x => a) i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n α
a : α
i✝ : m
j✝ : n
⊢ (MulOpposite.op a • M) i✝ j✝ = (M * diagonal fun x => a) i✝ j✝
state_after: no goals
tactic: simp
Theorem: TrivSqZeroExt.inl_pow
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : Monoid R
inst✝² : AddMonoid M
inst✝¹ : DistribMulAction R M
inst✝ : DistribMulAction Rᵐᵒᵖ M
r : R
n : ℕ
⊢ (inl r ^ n).snd = (inl (r ^ n)).snd
state_after: no goals
tactic: simp [snd_pow_eq_sum, List.map_const']
Theorem: CategoryTheory.ComposableArrows.Exact.exact'
File: Mathlib/Algebra/Homology/ExactSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S : ComposableArrows C n
hS : S.Exact
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ (S.sc' ⋯ i j k ⋯ ⋯ ⋯).Exact
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S : ComposableArrows C n
hS : S.Exact
i : ℕ
hk : autoParam (i + 1 + 1 ≤ n) _auto✝
⊢ (S.sc' ⋯ i (i + 1) (i + 1 + 1) ⋯ ⋯ ⋯).Exact
tactic: subst hij hjk
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S : ComposableArrows C n
hS : S.Exact
i : ℕ
hk : autoParam (i + 1 + 1 ≤ n) _auto✝
⊢ (S.sc' ⋯ i (i + 1) (i + 1 + 1) ⋯ ⋯ ⋯).Exact
state_after: no goals
tactic: exact hS.exact i hk
Theorem: AddSubgroup.norm_trivial_quotient_mk
File: Mathlib/Analysis/Normed/Group/Quotient.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure = univ
⊢ ‖S.normedMk‖ = 0
state_after: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure = univ
x : M
⊢ ‖S.normedMk x‖ ≤ 0 * ‖x‖
tactic: refine le_antisymm (opNorm_le_bound _ le_rfl fun x => ?_) (norm_nonneg _)
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure = univ
x : M
⊢ ‖S.normedMk x‖ ≤ 0 * ‖x‖
state_after: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure = univ
x : M
hker : x ∈ S.normedMk.ker.topologicalClosure
⊢ ‖S.normedMk x‖ ≤ 0 * ‖x‖
tactic: have hker : x ∈ S.normedMk.ker.topologicalClosure := by
    rw [S.ker_normedMk, ← SetLike.mem_coe, h]
    trivial
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure = univ
x : M
hker : x ∈ S.normedMk.ker.topologicalClosure
⊢ ‖S.normedMk x‖ ≤ 0 * ‖x‖
state_after: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure = univ
x : M
hker : x ∈ S.topologicalClosure
⊢ ‖S.normedMk x‖ ≤ 0 * ‖x‖
tactic: rw [ker_normedMk] at hker
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure = univ
x : M
hker : x ∈ S.topologicalClosure
⊢ ‖S.normedMk x‖ ≤ 0 * ‖x‖
state_after: no goals
tactic: simp only [(quotient_norm_eq_zero_iff S x).mpr hker, normedMk.apply, zero_mul, le_rfl]
Theorem: Finsupp.mem_neLocus
File: Mathlib/Data/Finsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f✝ g✝ f g : α →₀ N
a : α
⊢ a ∈ f.neLocus g ↔ f a ≠ g a
state_after: no goals
tactic: simpa only [neLocus, Finset.mem_filter, Finset.mem_union, mem_support_iff,
    and_iff_right_iff_imp] using Ne.ne_or_ne _
Theorem: Finsupp.finsuppProdLEquiv_symm_apply
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α✝ : Type u_1
M✝ : Type u_2
N : Type u_3
P : Type u_4
R✝ : Type u_5
S : Type u_6
inst✝¹⁰ : Semiring R✝
inst✝⁹ : Semiring S
inst✝⁸ : AddCommMonoid M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R✝ N
inst✝⁴ : AddCommMonoid P
inst✝³ : Module R✝ P
α : Type u_7
β : Type u_8
R : Type u_9
M : Type u_10
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : α →₀ β →₀ M
xy : α × β
⊢ ((finsuppProdLEquiv R).symm f) xy = (f xy.1) xy.2
state_after: no goals
tactic: conv_rhs =>
    rw [← (finsuppProdLEquiv R).apply_symm_apply f, finsuppProdLEquiv_apply]
Theorem: Set.preimage_add_right_singleton
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x => x * a) ⁻¹' {b} = {b * a⁻¹}
state_after: no goals
tactic: rw [← image_mul_right', image_singleton]
Theorem: pos_of_lt_add_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MulOneClass α
inst✝¹ : LT α
inst✝ : ContravariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : b < a * b
⊢ 1 * b < a * b
state_after: no goals
tactic: simpa only [one_mul]
Theorem: RieszExtension.step
File: Mathlib/Analysis/Convex/Cone/Extension.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s : ConvexCone ℝ E
f : E →ₗ.[ℝ] ℝ
nonneg : ∀ (x : ↥f.domain), ↑x ∈ s → 0 ≤ ↑f x
dense : ∀ (y : E), ∃ x, ↑x + y ∈ s
hdom : f.domain ≠ ⊤
⊢ ∃ g, f < g ∧ ∀ (x : ↥g.domain), ↑x ∈ s → 0 ≤ ↑g x
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s : ConvexCone ℝ E
f : E →ₗ.[ℝ] ℝ
nonneg : ∀ (x : ↥f.domain), ↑x ∈ s → 0 ≤ ↑f x
dense : ∀ (y : E), ∃ x, ↑x + y ∈ s
hdom : f.domain ≠ ⊤
y : E
hy : y ∉ f.domain
⊢ ∃ g, f < g ∧ ∀ (x : ↥g.domain), ↑x ∈ s → 0 ≤ ↑g x
tactic: obtain ⟨y, -, hy⟩ : ∃ y ∈ ⊤, y ∉ f.domain := SetLike.exists_of_lt (lt_top_iff_ne_top.2 hdom)
state_before: case intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s : ConvexCone ℝ E
f : E →ₗ.[ℝ] ℝ
nonneg : ∀ (x : ↥f.domain), ↑x ∈ s → 0 ≤ ↑f x
dense : ∀ (y : E), ∃ x, ↑x + y ∈ s
hdom : f.domain ≠ ⊤
y : E
hy : y ∉ f.domain
c : ℝ
le_c : ∀ (x : ↥f.domain), -↑x - y ∈ s → ↑f x ≤ c
c_le : ∀ (x : ↥f.domain), ↑x + y ∈ s → c ≤ ↑f x
⊢ ∃ g, f < g ∧ ∀ (x : ↥g.domain), ↑x ∈ s → 0 ≤ ↑g x
state_after: case intro.intro.intro.intro.refine_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s : ConvexCone ℝ E
f : E →ₗ.[ℝ] ℝ
nonneg : ∀ (x : ↥f.domain), ↑x ∈ s → 0 ≤ ↑f x
dense : ∀ (y : E), ∃ x, ↑x + y ∈ s
hdom : f.domain ≠ ⊤
y : E
hy : y ∉ f.domain
c : ℝ
le_c : ∀ (x : ↥f.domain), -↑x - y ∈ s → ↑f x ≤ c
c_le : ∀ (x : ↥f.domain), ↑x + y ∈ s → c ≤ ↑f x
⊢ f < f.supSpanSingleton y (-c) hy

case intro.intro.intro.intro.refine_2
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s : ConvexCone ℝ E
f : E →ₗ.[ℝ] ℝ
nonneg : ∀ (x : ↥f.domain), ↑x ∈ s → 0 ≤ ↑f x
dense : ∀ (y : E), ∃ x, ↑x + y ∈ s
hdom : f.domain ≠ ⊤
y : E
hy : y ∉ f.domain
c : ℝ
le_c : ∀ (x : ↥f.domain), -↑x - y ∈ s → ↑f x ≤ c
c_le : ∀ (x : ↥f.domain), ↑x + y ∈ s → c ≤ ↑f x
⊢ ∀ (x : ↥(f.supSpanSingleton y (-c) hy).domain), ↑x ∈ s → 0 ≤ ↑(f.supSpanSingleton y (-c) hy) x
tactic: refine ⟨f.supSpanSingleton y (-c) hy, ?_, ?_⟩
Theorem: CategoryTheory.SingleFunctors.shiftIso_add_inv_app
File: Mathlib/CategoryTheory/Shift/SingleFunctors.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁷ : Category.{?u.9364, u_1} C
inst✝⁶ : Category.{?u.9368, u_2} D
inst✝⁵ : Category.{?u.9372, u_3} E
inst✝⁴ : Category.{?u.9376, u_4} E'
A : Type u_5
inst✝³ : AddMonoid A
inst✝² : HasShift D A
inst✝¹ : HasShift E A
inst✝ : HasShift E' A
F G H : SingleFunctors C D A
n m a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ m + n + a = a''
state_after: no goals
tactic: rw [add_assoc, ha', ha'']
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁷ : Category.{u_7, u_1} C
inst✝⁶ : Category.{u_6, u_2} D
inst✝⁵ : Category.{?u.9372, u_3} E
inst✝⁴ : Category.{?u.9376, u_4} E'
A : Type u_5
inst✝³ : AddMonoid A
inst✝² : HasShift D A
inst✝¹ : HasShift E A
inst✝ : HasShift E' A
F G H : SingleFunctors C D A
n m a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ (F.shiftIso (m + n) a a'' ⋯).inv.app X =
    (F.shiftIso n a a' ha').inv.app X ≫
      (shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').inv.app X) ≫
        (shiftFunctorAdd D m n).inv.app ((F.functor a'').obj X)
state_after: no goals
tactic: simp [F.shiftIso_add n m a a' a'' ha' ha'']
Theorem: Finset.strictMono_iff_forall_lt_cons
File: Mathlib/Data/Finset/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder β
s t : Finset α
f : Finset α → β
⊢ StrictMono f ↔ ∀ (s : Finset α) ⦃a : α⦄ (ha : a ∉ s), f s < f (cons a s ha)
state_after: no goals
tactic: classical simp [strictMono_iff_forall_covBy, covBy_iff_exists_cons]
Theorem: ProbabilityTheory.Kernel.indepSet_empty_right
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s : Set Ω
⊢ IndepSet s ∅ κ μ
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s : Set Ω
⊢ Indep (generateFrom {s}) ⊥ κ μ
tactic: simp only [IndepSet, generateFrom_singleton_empty]
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s : Set Ω
⊢ Indep (generateFrom {s}) ⊥ κ μ
state_after: no goals
tactic: exact indep_bot_right _
Theorem: RCLike.norm_sq_re_add_conj
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z x : K
⊢ ‖x + (starRingEnd K) x‖ ^ 2 = re (x + (starRingEnd K) x) ^ 2
state_after: no goals
tactic: rw [add_conj, ← ofReal_ofNat, ← ofReal_mul, norm_ofReal, sq_abs, ofReal_re]
Theorem: Finset.powersetCard_self
File: Mathlib/Data/Finset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28461
s✝ t s : Finset α
⊢ powersetCard s.card s = {s}
state_after: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28461
s✝ t s a✝ : Finset α
⊢ a✝ ∈ powersetCard s.card s ↔ a✝ ∈ {s}
tactic: ext
state_before: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28461
s✝ t s a✝ : Finset α
⊢ a✝ ∈ powersetCard s.card s ↔ a✝ ∈ {s}
state_after: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28461
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝.card = s.card ↔ a✝ = s
tactic: rw [mem_powersetCard, mem_singleton]
state_before: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28461
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝.card = s.card ↔ a✝ = s
state_after: case a.mp
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28461
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝.card = s.card → a✝ = s

case a.mpr
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28461
s✝ t s a✝ : Finset α
⊢ a✝ = s → a✝ ⊆ s ∧ a✝.card = s.card
tactic: constructor