ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Batteries.AssocList.toList_eraseP
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
p : α → β → Bool
l : AssocList α β
⊢ (eraseP p l).toList =
    List.eraseP
      (fun x =>
        match x with
        | (a, b) => p a b)
      l.toList
state_after: case cons
α : Type u_1
β : Type u_2
p : α → β → Bool
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ :
  (eraseP p tail✝).toList =
    List.eraseP
      (fun x =>
        match x with
        | (a, b) => p a b)
      tail✝.toList
⊢ (match p key✝ value✝ with
      | true => tail✝
      | false => cons key✝ value✝ (eraseP p tail✝)).toList =
    match p key✝ value✝ with
    | true => tail✝.toList
    | false => (key✝, value✝) :: List.eraseP (fun x => p x.fst x.snd) tail✝.toList
tactic: induction l <;> simp [List.eraseP, cond]
state_before: case cons
α : Type u_1
β : Type u_2
p : α → β → Bool
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ :
  (eraseP p tail✝).toList =
    List.eraseP
      (fun x =>
        match x with
        | (a, b) => p a b)
      tail✝.toList
⊢ (match p key✝ value✝ with
      | true => tail✝
      | false => cons key✝ value✝ (eraseP p tail✝)).toList =
    match p key✝ value✝ with
    | true => tail✝.toList
    | false => (key✝, value✝) :: List.eraseP (fun x => p x.fst x.snd) tail✝.toList
state_after: no goals
tactic: split <;> simp [*]
Theorem: Turing.PartrecToTM2.K'.elim_update_rev
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: a b c d b' : List Γ'
⊢ update (elim a b c d) rev b' = elim a b' c d
state_after: case h
a b c d b' : List Γ'
x : K'
⊢ update (elim a b c d) rev b' x = elim a b' c d x
tactic: funext x
state_before: case h
a b c d b' : List Γ'
x : K'
⊢ update (elim a b c d) rev b' x = elim a b' c d x
state_after: no goals
tactic: cases x <;> rfl
Theorem: Cardinal.mk_embedding_eq_zero_iff_lift_lt
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α β : Type u
β' : Type v
⊢ #(α ↪ β') = 0 ↔ lift.{u, v} #β' < lift.{v, u} #α
state_after: no goals
tactic: rw [mk_eq_zero_iff, ← not_nonempty_iff, ← lift_mk_le', not_le]
Theorem: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_fac
File: Mathlib/CategoryTheory/Localization/Prod.lean

Proof steps:
state_before: C₁ : Type u₁
C₂ : Type u₂
D₁ : Type u₃
D₂ : Type u₄
inst✝⁶ : Category.{v₁, u₁} C₁
inst✝⁵ : Category.{v₂, u₂} C₂
inst✝⁴ : Category.{v₃, u₃} D₁
inst✝³ : Category.{v₄, u₄} D₂
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
E : Type u₅
inst✝² : Category.{v₅, u₅} E
F : C₁ × C₂ ⥤ E
hF : (W₁.prod W₂).IsInvertedBy F
inst✝¹ : W₁.ContainsIdentities
inst✝ : W₂.ContainsIdentities
⊢ W₁.Q.prod W₂.Q ⋙ prodLift F hF = F
state_after: no goals
tactic: rw [← Functor.uncurry_obj_curry_obj_flip_flip', prod_fac₂, Functor.flip_flip, prod_fac₁,
    Functor.uncurry_obj_curry_obj]
Theorem: IsClosed.nhdsSet_le_sup
File: Mathlib/Topology/NhdsSet.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ s = 𝓝ˢ (s ∩ t ∪ s ∩ tᶜ)
state_after: no goals
tactic: rw [Set.inter_union_compl s t]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ (s ∩ t ∪ s ∩ tᶜ) = 𝓝ˢ (s ∩ t) ⊔ 𝓝ˢ (s ∩ tᶜ)
state_after: no goals
tactic: rw [nhdsSet_union]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ (s ∩ t) ⊔ 𝓝ˢ tᶜ = 𝓝ˢ (s ∩ t) ⊔ 𝓟 tᶜ
state_after: no goals
tactic: rw [h.isOpen_compl.nhdsSet_eq]
Theorem: Finset.prod_ite_one
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
h : ∀ i ∈ s, ∀ j ∈ s, p i → p j → i = j
a : β
⊢ (∏ i ∈ s, if p i then a else 1) = if ∃ i ∈ s, p i then a else 1
state_after: case pos
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
h✝ : ∀ i ∈ s, ∀ j ∈ s, p i → p j → i = j
a : β
h : ∃ i ∈ s, p i
⊢ (∏ i ∈ s, if p i then a else 1) = a

case neg
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
h✝ : ∀ i ∈ s, ∀ j ∈ s, p i → p j → i = j
a : β
h : ¬∃ i ∈ s, p i
⊢ (∏ i ∈ s, if p i then a else 1) = 1
tactic: split_ifs with h
Theorem: WithBot.lt_iff_exists_coe
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LT α
a : WithBot α
b : α
⊢ a < ↑b ↔ ∃ p, ↑b = ↑p ∧ a < ↑p
state_after: no goals
tactic: simp [coe_eq_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : LT α
a : WithBot α
⊢ ¬∃ p, ⊥ = ↑p ∧ a < ↑p
state_after: no goals
tactic: simp
Theorem: CategoryTheory.IsPullback.zero_right
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ CommSq 0 (𝟙 X) 0 0
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ ((zeroProdIso X).symm ≪≫ (pullbackZeroZeroIso 0 X).symm).hom ≫ pullback.fst 0 0 = 0
state_after: no goals
tactic: simp [eq_iff_true_of_subsingleton]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ ((zeroProdIso X).symm ≪≫ (pullbackZeroZeroIso 0 X).symm).hom ≫ pullback.snd 0 0 = 𝟙 X
state_after: no goals
tactic: simp
Theorem: ProbabilityTheory.Kernel.sum_add
File: Mathlib/Probability/Kernel/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
inst✝ : Countable ι
κ η : ι → Kernel α β
⊢ (Kernel.sum fun n => κ n + η n) = Kernel.sum κ + Kernel.sum η
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
inst✝ : Countable ι
κ η : ι → Kernel α β
a : α
s : Set β
hs : MeasurableSet s
⊢ ((Kernel.sum fun n => κ n + η n) a) s = ((Kernel.sum κ + Kernel.sum η) a) s
tactic: ext a s hs
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
inst✝ : Countable ι
κ η : ι → Kernel α β
a : α
s : Set β
hs : MeasurableSet s
⊢ ((Kernel.sum fun n => κ n + η n) a) s = ((Kernel.sum κ + Kernel.sum η) a) s
state_after: no goals
tactic: simp only [coe_add, Pi.add_apply, sum_apply, Measure.sum_apply _ hs, Pi.add_apply,
    Measure.coe_add, tsum_add ENNReal.summable ENNReal.summable]
Theorem: Set.preimage_val_eq_univ_of_subset
File: Mathlib/Data/Set/Subset.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
h : A ⊆ B
⊢ A ↓∩ B = univ
state_after: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
h : A ⊆ B
⊢ ∀ (a : α) (b : a ∈ A), ⟨a, b⟩ ∈ A ↓∩ B
tactic: rw [eq_univ_iff_forall, Subtype.forall]
state_before: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
h : A ⊆ B
⊢ ∀ (a : α) (b : a ∈ A), ⟨a, b⟩ ∈ A ↓∩ B
state_after: no goals
tactic: exact h
Theorem: UniformFun.postcomp_uniformContinuous
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : γ → β
hf : UniformContinuous f
⊢ UniformContinuous (⇑ofFun ∘ (fun x => f ∘ x) ∘ ⇑toFun)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : γ → β
hf : UniformContinuous f
⊢ uniformSpace α γ ≤ UniformSpace.comap (⇑ofFun ∘ (fun x => f ∘ x) ∘ ⇑toFun) (uniformSpace α β)
tactic: refine uniformContinuous_iff.mpr ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : γ → β
hf : UniformContinuous f
⊢ uniformSpace α γ ≤ UniformSpace.comap (⇑ofFun ∘ (fun x => f ∘ x) ∘ ⇑toFun) (uniformSpace α β)
state_after: no goals
tactic: exact (UniformFun.mono (uniformContinuous_iff.mp hf)).trans_eq UniformFun.comap_eq
Theorem: LinearMap.lTensor_id_apply
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P →ₗ[R] Q
f : N →ₗ[R] P
x : M ⊗[R] N
⊢ (lTensor M id) x = x
state_after: no goals
tactic: rw [lTensor_id, id_coe, _root_.id]
Theorem: ExteriorAlgebra.GradedAlgebra.ι_apply
File: Mathlib/LinearAlgebra/ExteriorAlgebra/Grading.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
⊢ (ι R) m ∈ ⋀[R]^1 M
state_after: no goals
tactic: simpa only [pow_one] using LinearMap.mem_range_self _ m
Theorem: Set.le_einfsep_image_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s✝ t : Set α
d : ℝ≥0∞
f : β → α
s : Set β
⊢ d ≤ (f '' s).einfsep ↔ ∀ x ∈ s, ∀ y ∈ s, f x ≠ f y → d ≤ edist (f x) (f y)
state_after: no goals
tactic: simp_rw [le_einfsep_iff, forall_mem_image]
Theorem: Set.iUnion_eq_univ_iff
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : ι → Set α
⊢ ⋃ i, f i = univ ↔ ∀ (x : α), ∃ i, x ∈ f i
state_after: no goals
tactic: simp only [eq_univ_iff_forall, mem_iUnion]
Theorem: DomMulAct.stabilizer_card
File: Mathlib/GroupTheory/Perm/DomMulAct.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
f : α → ι
inst✝³ : Fintype α
inst✝² : Fintype ι
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
⊢ Fintype.card { g // f ∘ ⇑g = f } = ∏ i : ι, (Fintype.card { a // f a = i })!
state_after: α : Type u_1
ι : Type u_2
f : α → ι
inst✝³ : Fintype α
inst✝² : Fintype ι
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
⊢ ∏ a : ι, Nat.card (Perm { a_1 // f a_1 = a }) = ∏ i : ι, (Fintype.card { a // f a = i })!

α : Type u_1
ι : Type u_2
f : α → ι
inst✝³ : Fintype α
inst✝² : Fintype ι
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
x✝ : Perm α
⊢ f ∘ ⇑x✝ = f ↔ mk x✝ ∈ stabilizer (Perm α)ᵈᵐᵃ f
tactic: rw [← Nat.card_eq_fintype_card, Nat.card_congr (subtypeEquiv mk fun _ ↦ ?_),
    Nat.card_congr MulOpposite.opEquiv,
    Nat.card_congr (DomMulAct.stabilizerMulEquiv f).toEquiv, Nat.card_pi]
Theorem: Associates.mk_ne_zero'
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
r : R
⊢ Associates.mk (Ideal.span {r}) ≠ 0 ↔ r ≠ 0
state_after: no goals
tactic: rw [Associates.mk_ne_zero, Ideal.zero_eq_bot, Ne, Ideal.span_singleton_eq_bot]
Theorem: polynomialFunctions.le_equalizer
File: Mathlib/Topology/ContinuousFunction/Polynomial.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : TopologicalSpace R
inst✝² : TopologicalSemiring R
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
s : Set R
φ ψ : C(↑s, R) →ₐ[R] A
h : φ ((toContinuousMapOnAlgHom s) X) = ψ ((toContinuousMapOnAlgHom s) X)
⊢ polynomialFunctions s ≤ AlgHom.equalizer φ ψ
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : TopologicalSpace R
inst✝² : TopologicalSemiring R
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
s : Set R
φ ψ : C(↑s, R) →ₐ[R] A
h : φ ((toContinuousMapOnAlgHom s) X) = ψ ((toContinuousMapOnAlgHom s) X)
⊢ Algebra.adjoin R {(toContinuousMapOnAlgHom s) X} ≤ AlgHom.equalizer φ ψ
tactic: rw [polynomialFunctions.eq_adjoin_X s]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : TopologicalSpace R
inst✝² : TopologicalSemiring R
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
s : Set R
φ ψ : C(↑s, R) →ₐ[R] A
h : φ ((toContinuousMapOnAlgHom s) X) = ψ ((toContinuousMapOnAlgHom s) X)
⊢ Algebra.adjoin R {(toContinuousMapOnAlgHom s) X} ≤ AlgHom.equalizer φ ψ
state_after: no goals
tactic: exact φ.adjoin_le_equalizer ψ fun x hx => (Set.mem_singleton_iff.1 hx).symm ▸ h
Theorem: List.revzip_swap
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l : List α
⊢ map Prod.swap l.revzip = l.reverse.revzip
state_after: no goals
tactic: simp [revzip]
Theorem: Finset.Ioi_mul_Ici_subset'
File: Mathlib/Data/Finset/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : PartialOrder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
inst✝ : LocallyFiniteOrderTop α
a b : α
⊢ ↑(Ioi a * Ici b) ⊆ ↑(Ioi (a * b))
state_after: no goals
tactic: simpa using Set.Ioi_mul_Ici_subset' _ _
Theorem: MeasureTheory.lintegral_prod_symm
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite μ
f : α × β → ℝ≥0∞
hf : AEMeasurable f (μ.prod ν)
⊢ ∫⁻ (z : α × β), f z ∂μ.prod ν = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y) ∂μ ∂ν
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite μ
f : α × β → ℝ≥0∞
hf : AEMeasurable f (μ.prod ν)
⊢ ∫⁻ (z : β × α), f z.swap ∂ν.prod μ = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y) ∂μ ∂ν
tactic: simp_rw [← lintegral_prod_swap f]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite μ
f : α × β → ℝ≥0∞
hf : AEMeasurable f (μ.prod ν)
⊢ ∫⁻ (z : β × α), f z.swap ∂ν.prod μ = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y) ∂μ ∂ν
state_after: no goals
tactic: exact lintegral_prod _ hf.prod_swap
Theorem: gauge_lt_one_eq_interior
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
⊢ {x | gauge s x < 1} = interior s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
x : E
hx : x ∈ {x | gauge s x < 1}
⊢ x ∈ interior s
tactic: refine Subset.antisymm (fun x hx ↦ ?_) (interior_subset_gauge_lt_one s)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
x : E
hx : x ∈ {x | gauge s x < 1}
⊢ x ∈ interior s
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
x : E
hx : x ∈ {x | gauge s x < 1}
y : E
hys : y ∈ s
hxy : x ∈ openSegment ℝ 0 y
⊢ x ∈ interior s
tactic: rcases mem_openSegment_of_gauge_lt_one (absorbent_nhds_zero hs₀) hx with ⟨y, hys, hxy⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
hc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
x : E
hx : x ∈ {x | gauge s x < 1}
y : E
hys : y ∈ s
hxy : x ∈ openSegment ℝ 0 y
⊢ x ∈ interior s
state_after: no goals
tactic: exact hc.openSegment_interior_self_subset_interior (mem_interior_iff_mem_nhds.2 hs₀) hys hxy
Theorem: continuousNeg_inf
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
ι' : Sort u_1
inst✝ : Inv G
t₁ t₂ : TopologicalSpace G
h₁ : ContinuousInv G
h₂ : ContinuousInv G
⊢ ContinuousInv G
state_after: G : Type w
H : Type x
α : Type u
β : Type v
ι' : Sort u_1
inst✝ : Inv G
t₁ t₂ : TopologicalSpace G
h₁ : ContinuousInv G
h₂ : ContinuousInv G
b : Bool
⊢ ContinuousInv G
tactic: refine continuousInv_iInf fun b => ?_
state_before: G : Type w
H : Type x
α : Type u
β : Type v
ι' : Sort u_1
inst✝ : Inv G
t₁ t₂ : TopologicalSpace G
h₁ : ContinuousInv G
h₂ : ContinuousInv G
b : Bool
⊢ ContinuousInv G
state_after: no goals
tactic: cases b <;> assumption
Theorem: AlgebraicGeometry.Scheme.OpenCover.pullbackCover'_J
File: Mathlib/AlgebraicGeometry/Cover/Open.lean

Proof steps:
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ x ∈ Set.range ⇑((fun x => pullback.snd (𝒰.map x) f) ((fun x => 𝒰.f (f.val.base x)) x)).val.base
state_after: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ x ∈
    Set.range
      ⇑((PreservesPullback.iso forgetToTop (𝒰.map (𝒰.f (f.val.base x))) f).hom ≫
          pullback.snd (forgetToTop.map (𝒰.map (𝒰.f (f.val.base x)))) (forgetToTop.map f))
tactic: rw [←
      show _ = (pullback.snd (𝒰.map (𝒰.f (f.1.base x))) f).1.base from
        PreservesPullback.iso_hom_snd Scheme.forgetToTop (𝒰.map (𝒰.f (f.1.base x))) f]
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ x ∈
    Set.range
      ⇑((PreservesPullback.iso forgetToTop (𝒰.map (𝒰.f (f.val.base x))) f).hom ≫
          pullback.snd (forgetToTop.map (𝒰.map (𝒰.f (f.val.base x)))) (forgetToTop.map f))
state_after: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ x ∈ {y | ∃ x_1, (forgetToTop.map (𝒰.map (𝒰.f (f.val.base x)))) x_1 = (forgetToTop.map f) y}

X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ Function.Surjective ⇑(PreservesPullback.iso forgetToTop (𝒰.map (𝒰.f (f.val.base x))) f).hom
tactic: rw [TopCat.coe_comp, Set.range_comp, Set.range_iff_surjective.mpr, Set.image_univ,
      TopCat.pullback_snd_range]
Theorem: CategoryTheory.Center.leftUnitor_inv_f
File: Mathlib/CategoryTheory/Monoidal/Center.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (λ_ X).inv.f = (λ_ X.fst).inv
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (λ_ X.fst).hom ≫ (λ_ X).inv.f = 𝟙 (𝟙_ (Center C) ⊗ X).fst
tactic: apply Iso.inv_ext'
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (λ_ X.fst).hom ≫ (λ_ X).inv.f = 𝟙 (𝟙_ (Center C) ⊗ X).fst
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (𝟙 (𝟙_ (Center C) ⊗ X)).f = 𝟙 (𝟙_ (Center C) ⊗ X).fst
tactic: rw [← leftUnitor_hom_f, ← comp_f, Iso.hom_inv_id]
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (𝟙 (𝟙_ (Center C) ⊗ X)).f = 𝟙 (𝟙_ (Center C) ⊗ X).fst
state_after: no goals
tactic: rfl
Theorem: Ideal.finsuppTotal_apply
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
f : ι →₀ ↥I
⊢ (finsuppTotal ι M I v) f = f.sum fun i x => ↑x • v i
state_after: ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
f : ι →₀ ↥I
⊢ (Finsupp.total ι M R v) (Finsupp.mapRange Subtype.val ⋯ f) = f.sum fun i x => ↑x • v i
tactic: dsimp [finsuppTotal]
state_before: ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
f : ι →₀ ↥I
⊢ (Finsupp.total ι M R v) (Finsupp.mapRange Subtype.val ⋯ f) = f.sum fun i x => ↑x • v i
state_after: ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
f : ι →₀ ↥I
⊢ ∀ (a : ι), 0 • v a = 0
tactic: rw [Finsupp.total_apply, Finsupp.sum_mapRange_index]
state_before: ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
f : ι →₀ ↥I
⊢ ∀ (a : ι), 0 • v a = 0
state_after: no goals
tactic: exact fun _ => zero_smul _ _
Theorem: isLindelof_open_iff_eq_countable_iUnion_of_isTopologicalBasis
File: Mathlib/Topology/Compactness/Lindelof.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : ι → Set X
hb : IsTopologicalBasis (range b)
hb' : ∀ (i : ι), IsLindelof (b i)
U : Set X
⊢ IsLindelof U ∧ IsOpen U ↔ ∃ s, s.Countable ∧ U = ⋃ i ∈ s, b i
state_after: case mp
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : ι → Set X
hb : IsTopologicalBasis (range b)
hb' : ∀ (i : ι), IsLindelof (b i)
U : Set X
⊢ IsLindelof U ∧ IsOpen U → ∃ s, s.Countable ∧ U = ⋃ i ∈ s, b i

case mpr
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : ι → Set X
hb : IsTopologicalBasis (range b)
hb' : ∀ (i : ι), IsLindelof (b i)
U : Set X
⊢ (∃ s, s.Countable ∧ U = ⋃ i ∈ s, b i) → IsLindelof U ∧ IsOpen U
tactic: constructor