1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: sInfHom.continuous
File: Mathlib/Topology/Order/LowerUpperTopology.lean

tactic: refine IsLower.continuous_iff_Ici.2 fun b => ?_
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
⊢ Continuous ⇑f
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
b : β
⊢ IsClosed (⇑f ⁻¹' Ici b)

tactic: convert isClosed_Ici (a := sInf <| f ⁻¹' Ici b)
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
b : β
⊢ IsClosed (⇑f ⁻¹' Ici b)
state_after: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
b : β
⊢ ⇑f ⁻¹' Ici b = Ici (sInf (⇑f ⁻¹' Ici b))

tactic: refine Subset.antisymm (fun a => sInf_le) fun a ha => le_trans ?_ <|
  OrderHomClass.mono (f : α →o β) ha
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
b : β
⊢ ⇑f ⁻¹' Ici b = Ici (sInf (⇑f ⁻¹' Ici b))
state_after: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
b : β
a : α
ha : a ∈ Ici (sInf (⇑f ⁻¹' Ici b))
⊢ b ≤ ↑f (sInf (⇑f ⁻¹' Ici b))

tactic: refine LE.le.trans ?_ (map_sInf f _).ge
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
b : β
a : α
ha : a ∈ Ici (sInf (⇑f ⁻¹' Ici b))
⊢ b ≤ ↑f (sInf (⇑f ⁻¹' Ici b))
state_after: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
b : β
a : α
ha : a ∈ Ici (sInf (⇑f ⁻¹' Ici b))
⊢ b ≤ sInf (⇑f '' (⇑f ⁻¹' Ici b))

tactic: simp
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : IsLower α
inst✝¹ : TopologicalSpace β
inst✝ : IsLower β
f : sInfHom α β
b : β
a : α
ha : a ∈ Ici (sInf (⇑f ⁻¹' Ici b))
⊢ b ≤ sInf (⇑f '' (⇑f ⁻¹' Ici b))
state_after: no goals
Theorem: SetTheory.PGame.birthday_one_add
File: Mathlib/SetTheory/Game/Birthday.lean

tactic: simp
state_before: a b x : PGame
⊢ (1 + a).birthday = Order.succ a.birthday
state_after: no goals
Theorem: List.sublistsAux_eq_array_foldl
File: Mathlib/Data/List/Sublists.lean

tactic: funext a r
state_before: α : Type u
β : Type v
γ : Type w
⊢ sublistsAux = fun a r => (Array.foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r) 0).toList
state_after: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ sublistsAux a r = (Array.foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r) 0).toList

tactic: simp only [sublistsAux, Array.foldl_eq_foldl_data, Array.mkEmpty]
state_before: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ sublistsAux a r = (Array.foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r) 0).toList
state_after: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ foldl (fun r l => r ++ [l, a :: l]) [] r = (foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r).data).toList

tactic: have := foldl_hom Array.toList (fun r l => (r.push l).push (a :: l))
  (fun (r : List (List α)) l => r ++ [l, a :: l]) r #[]
  (by simp)
state_before: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ foldl (fun r l => r ++ [l, a :: l]) [] r = (foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r).data).toList
state_after: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
this : foldl (fun r l => r ++ [l, a :: l]) #[].toList r = (foldl (fun r l => (r.push l).push (a :: l)) #[] r).toList
⊢ foldl (fun r l => r ++ [l, a :: l]) [] r = (foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r).data).toList

tactic: simpa using this
state_before: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
this : foldl (fun r l => r ++ [l, a :: l]) #[].toList r = (foldl (fun r l => (r.push l).push (a :: l)) #[] r).toList
⊢ foldl (fun r l => r ++ [l, a :: l]) [] r = (foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r).data).toList
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ ∀ (x : Array (List α)) (y : List α),
    (fun r l => r ++ [l, a :: l]) x.toList y = ((fun r l => (r.push l).push (a :: l)) x y).toList
state_after: no goals
Theorem: rank_fun'
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: rw [rank_fun_eq_lift_mul, rank_self, Cardinal.lift_one, mul_one]
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹³ : Ring R
inst✝¹² : CommRing S
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R M
inst✝⁷ : Module R M'
inst✝⁶ : Module R M₁
inst✝⁵ : StrongRankCondition R
inst✝⁴ : Module.Free R M
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module R (φ i)
inst✝¹ : ∀ (i : η), Module.Free R (φ i)
inst✝ : Fintype η
⊢ Module.rank R (η → R) = ↑(Fintype.card η)
state_after: no goals
Theorem: SimpleGraph.dart_fst_fiber_card_eq_degree
File: Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean

tactic: simpa only [dart_fst_fiber, Finset.card_univ, card_neighborSet_eq_degree] using
  card_image_of_injective univ (G.dartOfNeighborSet_injective v)
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
v : V
⊢ (filter (fun d => d.toProd.1 = v) univ).card = G.degree v
state_after: no goals
Theorem: isCompact_range_of_mulSupport_subset_isCompact
File: Mathlib/Topology/Support.lean

tactic: cases' range_eq_image_or_of_mulSupport_subset h'f with h2 h2 <;> rw [h2]
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✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
⊢ IsCompact (range f)
state_after: case inl
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✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
h2 : range f = f '' k
⊢ IsCompact (f '' k)

case inr
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✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
h2 : range f = insert 1 (f '' k)
⊢ IsCompact (insert 1 (f '' k))

tactic: exacts [hk.image hf, (hk.image hf).insert 1]
state_before: case inl
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✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
h2 : range f = f '' k
⊢ IsCompact (f '' k)

case inr
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✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
h2 : range f = insert 1 (f '' k)
⊢ IsCompact (insert 1 (f '' k))
state_after: no goals
Theorem: wittPolynomial_zero
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: simp only [wittPolynomial, X, sum_singleton, range_one, pow_zero, zero_add, tsub_self]
state_before: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type u_2
inst✝ : CommRing S
⊢ W_ R 0 = X 0
state_after: no goals
Theorem: Relation.comp_assoc
File: Mathlib/Logic/Relation.lean

tactic: funext a d
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
⊢ (r ∘r p) ∘r q = r ∘r p ∘r q
state_after: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d = (r ∘r p ∘r q) a d

tactic: apply propext
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d = (r ∘r p ∘r q) a d
state_after: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d ↔ (r ∘r p ∘r q) a d

tactic: constructor
state_before: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d ↔ (r ∘r p ∘r q) a d
state_after: case h.h.a.mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d → (r ∘r p ∘r q) a d

case h.h.a.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ (r ∘r p ∘r q) a d → ((r ∘r p) ∘r q) a d

tactic: exact fun ⟨c, ⟨b, hab, hbc⟩, hcd⟩ ↦ ⟨b, hab, c, hbc, hcd⟩
state_before: case h.h.a.mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d → (r ∘r p ∘r q) a d
state_after: no goals

tactic: exact fun ⟨b, hab, c, hbc, hcd⟩ ↦ ⟨c, ⟨b, hab, hbc⟩, hcd⟩
state_before: case h.h.a.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ (r ∘r p ∘r q) a d → ((r ∘r p) ∘r q) a d
state_after: no goals
Theorem: Algebra.PowerBasis.norm_gen_eq_coeff_zero_minpoly
File: Mathlib/RingTheory/Norm.lean

tactic: rw [norm_eq_matrix_det pb.basis, det_eq_sign_charpoly_coeff, charpoly_leftMulMatrix,
  Fintype.card_fin]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Ring S
inst✝⁵ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K L
inst✝ : Algebra K F
ι : Type w
pb : PowerBasis R S
⊢ (norm R) pb.gen = (-1) ^ pb.dim * (minpoly R pb.gen).coeff 0
state_after: no goals
Theorem: CategoryTheory.CommSq.right_adjoint_hasLift_iff
File: Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean

tactic: simp only [HasLift.iff]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
⊢ ⋯.HasLift ↔ sq.HasLift
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
⊢ Nonempty ⋯.LiftStruct ↔ Nonempty sq.LiftStruct

tactic: exact Equiv.nonempty_congr (sq.rightAdjointLiftStructEquiv adj).symm
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
⊢ Nonempty ⋯.LiftStruct ↔ Nonempty sq.LiftStruct
state_after: no goals
Theorem: FreeSemigroup.length_mul
File: Mathlib/Algebra/Free.lean

tactic: simp [length, Nat.add_right_comm, List.length, List.length_append]
state_before: α : Type u
x y : FreeSemigroup α
⊢ (x * y).length = x.length + y.length
state_after: no goals
Theorem: differentiableWithinAt_neg_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [neg_neg] using h.neg
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : DifferentiableWithinAt 𝕜 (fun y => -f y) s x
⊢ DifferentiableWithinAt 𝕜 f s x
state_after: no goals
Theorem: ENNReal.log_pos_real'
File: Mathlib/Analysis/SpecialFunctions/Log/ENNReal.lean

tactic: simp [log, Ne.symm (ne_of_lt (ENNReal.toReal_pos_iff.1 h).1),
  ne_of_lt (ENNReal.toReal_pos_iff.1 h).2]
state_before: x : ℝ≥0∞
h : 0 < x.toReal
⊢ x.log = ↑(Real.log x.toReal)
state_after: no goals
Theorem: orbit_fixingSubgroup_compl_subset
File: Mathlib/GroupTheory/GroupAction/FixingSubgroup.lean

tactic: intro b b_in_orbit
state_before: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
⊢ orbit (↥(fixingSubgroup M sᶜ)) a ⊆ s
state_after: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
b : α
b_in_orbit : b ∈ orbit (↥(fixingSubgroup M sᶜ)) a
⊢ b ∈ s

tactic: let ⟨⟨g, g_fixing⟩, g_eq⟩ := MulAction.mem_orbit_iff.mp b_in_orbit
state_before: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
b : α
b_in_orbit : b ∈ orbit (↥(fixingSubgroup M sᶜ)) a
⊢ b ∈ s
state_after: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
b : α
b_in_orbit : b ∈ orbit (↥(fixingSubgroup M sᶜ)) a
g : M
g_fixing : g ∈ fixingSubgroup M sᶜ
g_eq : ⟨g, g_fixing⟩ • a = b
⊢ b ∈ s

tactic: rw [Submonoid.mk_smul] at g_eq
state_before: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
b : α
b_in_orbit : b ∈ orbit (↥(fixingSubgroup M sᶜ)) a
g : M
g_fixing : g ∈ fixingSubgroup M sᶜ
g_eq : ⟨g, g_fixing⟩ • a = b
⊢ b ∈ s
state_after: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
b : α
b_in_orbit : b ∈ orbit (↥(fixingSubgroup M sᶜ)) a
g : M
g_fixing : g ∈ fixingSubgroup M sᶜ
g_eq : g • a = b
⊢ b ∈ s

tactic: rw [mem_fixingSubgroup_compl_iff_movedBy_subset] at g_fixing
state_before: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
b : α
b_in_orbit : b ∈ orbit (↥(fixingSubgroup M sᶜ)) a
g : M
g_fixing : g ∈ fixingSubgroup M sᶜ
g_eq : g • a = b
⊢ b ∈ s
state_after: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
b : α
b_in_orbit : b ∈ orbit (↥(fixingSubgroup M sᶜ)) a
g : M
g_fixing : (fixedBy α g)ᶜ ⊆ s
g_eq : g • a = b
⊢ b ∈ s

tactic: rwa [← g_eq, smul_mem_of_set_mem_fixedBy (set_mem_fixedBy_of_movedBy_subset g_fixing)]
state_before: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
a : α
a_in_s : a ∈ s
b : α
b_in_orbit : b ∈ orbit (↥(fixingSubgroup M sᶜ)) a
g : M
g_fixing : (fixedBy α g)ᶜ ⊆ s
g_eq : g • a = b
⊢ b ∈ s
state_after: no goals
Theorem: real_inner_I_smul_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp [real_inner_eq_re_inner 𝕜, inner_smul_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
G : Type u_4
x : E
⊢ ⟪x, I • x⟫_ℝ = 0
state_after: no goals
Theorem: Rat.mkRat_eq_div
File: Mathlib/Algebra/Ring/Rat.lean

tactic: simp only [mkRat_eq_divInt, divInt_eq_div, Int.cast_natCast]
state_before: n : ℤ
d : ℕ
⊢ mkRat n d = ↑n / ↑d
state_after: no goals
Theorem: DFinsupp.neLocus_self_add_left
File: Mathlib/Data/DFinsupp/NeLocus.lean

tactic: rw [neLocus_comm, neLocus_self_add_right]
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ (f + g).neLocus f = g.support
state_after: no goals
Theorem: Finset.eraseNone_empty
File: Mathlib/Data/Finset/Option.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
⊢ eraseNone ∅ = ∅
state_after: case a
α : Type u_1
β : Type u_2
a✝ : α
⊢ a✝ ∈ eraseNone ∅ ↔ a✝ ∈ ∅

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
a✝ : α
⊢ a✝ ∈ eraseNone ∅ ↔ a✝ ∈ ∅
state_after: no goals
Theorem: MeasureTheory.exists_not_mem_null_lintegral_le
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: simpa only [laverage_eq_lintegral] using
  exists_not_mem_null_laverage_le (IsProbabilityMeasure.ne_zero μ) hint hN
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t N : Set α
f : α → ℝ≥0∞
inst✝ : IsProbabilityMeasure μ
hint : ∫⁻ (a : α), f a ∂μ ≠ ⊤
hN : μ N = 0
⊢ ∃ x ∉ N, ∫⁻ (a : α), f a ∂μ ≤ f x
state_after: no goals
Theorem: MeasureTheory.measure_union_eq_top_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simp only [← lt_top_iff_ne_top, ← Ne.eq_def, not_or, measure_union_lt_top_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ ¬μ (s ∪ t) = ⊤ ↔ ¬(μ s = ⊤ ∨ μ t = ⊤)
state_after: no goals
Theorem: NormedCommGroup.nhds_one_basis_norm_lt
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: convert NormedCommGroup.nhds_basis_norm_lt (1 : E)
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ (𝓝 1).HasBasis (fun ε => 0 < ε) fun ε => {y | ‖y‖ < ε}
state_after: case h.e'_5.h.h.e'_2.h.h.e'_3.h.e'_3
𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ x✝¹ : ℝ
x✝ : E
⊢ x✝ = x✝ / 1

tactic: simp
state_before: case h.e'_5.h.h.e'_2.h.h.e'_3.h.e'_3
𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ x✝¹ : ℝ
x✝ : E
⊢ x✝ = x✝ / 1
state_after: no goals
Theorem: finprod_mem_one
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s✝ t s : Set α
⊢ ∏ᶠ (i : α) (_ : i ∈ s), 1 = 1
state_after: no goals
Theorem: TopCat.colimit_isOpen_iff
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: exact isOpen_iSup_iff
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
U : Set ↑(colimit F)
⊢ IsOpen U ↔ ∀ (j : J), IsOpen (⇑(colimit.ι F j) ⁻¹' U)
state_after: no goals
Theorem: polynomialFunctions_closure_eq_top'
File: Mathlib/Topology/ContinuousFunction/Weierstrass.lean

tactic: rw [eq_top_iff]
state_before: ⊢ (polynomialFunctions I).topologicalClosure = ⊤
state_after: ⊢ ⊤ ≤ (polynomialFunctions I).topologicalClosure

tactic: rintro f -
state_before: ⊢ ⊤ ≤ (polynomialFunctions I).topologicalClosure
state_after: f : C(↑I, ℝ)
⊢ f ∈ (polynomialFunctions I).topologicalClosure

tactic: refine Filter.Frequently.mem_closure ?_
state_before: f : C(↑I, ℝ)
⊢ f ∈ (polynomialFunctions I).topologicalClosure
state_after: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : C(↑I, ℝ)) in nhds f, x ∈ ↑(polynomialFunctions I)

tactic: refine Filter.Tendsto.frequently (bernsteinApproximation_uniform f) ?_
state_before: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : C(↑I, ℝ)) in nhds f, x ∈ ↑(polynomialFunctions I)
state_after: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : ℕ) in atTop, bernsteinApproximation x f ∈ ↑(polynomialFunctions I)

tactic: apply frequently_of_forall
state_before: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : ℕ) in atTop, bernsteinApproximation x f ∈ ↑(polynomialFunctions I)
state_after: case h
f : C(↑I, ℝ)
⊢ ∀ (x : ℕ), bernsteinApproximation x f ∈ ↑(polynomialFunctions I)

tactic: intro n
state_before: case h
f : C(↑I, ℝ)
⊢ ∀ (x : ℕ), bernsteinApproximation x f ∈ ↑(polynomialFunctions I)
state_after: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ ↑(polynomialFunctions I)

tactic: simp only [SetLike.mem_coe]
state_before: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ ↑(polynomialFunctions I)
state_after: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ polynomialFunctions I

tactic: apply Subalgebra.sum_mem
state_before: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ polynomialFunctions I
state_after: case h.h
f : C(↑I, ℝ)
n : ℕ
⊢ ∀ x ∈ Finset.univ, f (bernstein.z x) • bernstein n ↑x ∈ polynomialFunctions I

tactic: rintro n -
state_before: case h.h
f : C(↑I, ℝ)
n : ℕ
⊢ ∀ x ∈ Finset.univ, f (bernstein.z x) • bernstein n ↑x ∈ polynomialFunctions I
state_after: case h.h
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ f (bernstein.z n) • bernstein n✝ ↑n ∈ polynomialFunctions I

tactic: apply Subalgebra.smul_mem
state_before: case h.h
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ f (bernstein.z n) • bernstein n✝ ↑n ∈ polynomialFunctions I
state_after: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ bernstein n✝ ↑n ∈ polynomialFunctions I

tactic: dsimp [bernstein, polynomialFunctions]
state_before: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ bernstein n✝ ↑n ∈ polynomialFunctions I
state_after: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ (bernsteinPolynomial ℝ n✝ ↑n).toContinuousMapOn I ∈ Subalgebra.map (Polynomial.toContinuousMapOnAlgHom I) ⊤

tactic: simp
state_before: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ (bernsteinPolynomial ℝ n✝ ↑n).toContinuousMapOn I ∈ Subalgebra.map (Polynomial.toContinuousMapOnAlgHom I) ⊤
state_after: no goals
Theorem: CategoryTheory.ProjectiveResolution.lift_commutes
File: Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean

tactic: ext
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Y ⟶ Z
P : ProjectiveResolution Y
Q : ProjectiveResolution Z
⊢ lift f P Q ≫ Q.π = P.π ≫ (ChainComplex.single₀ C).map f
state_after: case hfg
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Y ⟶ Z
P : ProjectiveResolution Y
Q : ProjectiveResolution Z
⊢ (lift f P Q ≫ Q.π).f 0 = (P.π ≫ (ChainComplex.single₀ C).map f).f 0

tactic: simp [lift, liftFZero, liftFOne]
state_before: case hfg
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Y ⟶ Z
P : ProjectiveResolution Y
Q : ProjectiveResolution Z
⊢ (lift f P Q ≫ Q.π).f 0 = (P.π ≫ (ChainComplex.single₀ C).map f).f 0
state_after: no goals