tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.LebesgueDecomposition.sup_mem_measurableLE
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: simp_rw [ENNReal.sup_eq_max]
state_before: α : Type u_1
β : Type ?u.88456
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : f ∈ measurableLE μ ν
hg : g ∈ measurableLE μ ν
⊢ (fun a => f a ⊔ g a) ∈ measurableLE μ ν

tactic: refine' ⟨Measurable.max hf.1 hg.1, fun A hA => _⟩
state_before: α : Type u_1
β : Type ?u.88456
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : f ∈ measurableLE μ ν
hg : g ∈ measurableLE μ ν
⊢ (fun a => max (f a) (g a)) ∈ measurableLE μ ν

tactic: have h₁ := hA.inter (measurableSet_le hf.1 hg.1)
state_before: α : Type u_1
β : Type ?u.88456
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : f ∈ measurableLE μ ν
hg : g ∈ measurableLE μ ν
A : Set α
hA : MeasurableSet A
⊢ (∫⁻ (x : α) in A, (fun a => max (f a) (g a)) x ∂μ) ≤ ↑↑ν A

tactic: have h₂ := hA.inter (measurableSet_lt hg.1 hf.1)
state_before: α : Type u_1
β : Type ?u.88456
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : f ∈ measurableLE μ ν
hg : g ∈ measurableLE μ ν
A : Set α
hA : MeasurableSet A
h₁ : MeasurableSet (A ∩ {a | f a ≤ g a})
⊢ (∫⁻ (x : α) in A, (fun a => max (f a) (g a)) x ∂μ) ≤ ↑↑ν A

tactic: rw [set_lintegral_max hf.1 hg.1]
state_before: α : Type u_1
β : Type ?u.88456
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : f ∈ measurableLE μ ν
hg : g ∈ measurableLE μ ν
A : Set α
hA : MeasurableSet A
h₁ : MeasurableSet (A ∩ {a | f a ≤ g a})
h₂ : MeasurableSet (A ∩ {a | g a < f a})
⊢ (∫⁻ (x : α) in A, (fun a => max (f a) (g a)) x ∂μ) ≤ ↑↑ν A

tactic: refine' (add_le_add (hg.2 _ h₁) (hf.2 _ h₂)).trans_eq _
state_before: α : Type u_1
β : Type ?u.88456
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : f ∈ measurableLE μ ν
hg : g ∈ measurableLE μ ν
A : Set α
hA : MeasurableSet A
h₁ : MeasurableSet (A ∩ {a | f a ≤ g a})
h₂ : MeasurableSet (A ∩ {a | g a < f a})
⊢ ((∫⁻ (x : α) in A ∩ {x | f x ≤ g x}, g x ∂μ) + ∫⁻ (x : α) in A ∩ {x | g x < f x}, f x ∂μ) ≤ ↑↑ν A

tactic: simp only [← not_le, ← compl_setOf, ← diff_eq]
state_before: α : Type u_1
β : Type ?u.88456
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : f ∈ measurableLE μ ν
hg : g ∈ measurableLE μ ν
A : Set α
hA : MeasurableSet A
h₁ : MeasurableSet (A ∩ {a | f a ≤ g a})
h₂ : MeasurableSet (A ∩ {a | g a < f a})
⊢ ↑↑ν (A ∩ {a | f a ≤ g a}) + ↑↑ν (A ∩ {a | g a < f a}) = ↑↑ν A

tactic: exact measure_inter_add_diff _ (measurableSet_le hf.1 hg.1)
state_before: α : Type u_1
β : Type ?u.88456
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : f ∈ measurableLE μ ν
hg : g ∈ measurableLE μ ν
A : Set α
hA : MeasurableSet A
h₁ : MeasurableSet (A ∩ {a | f a ≤ g a})
h₂ : MeasurableSet (A ∩ {a | g a < f a})
⊢ ↑↑ν (A ∩ {a | f a ≤ g a}) + ↑↑ν (A \ {a | f a ≤ g a}) = ↑↑ν A
Theorem: Set.inv_mem_centralizer₀
File: Mathlib/GroupTheory/Subsemigroup/Centralizer.lean

tactic: rw [h, inv_zero]
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : GroupWithZero M
ha : a ∈ centralizer S
h : a = 0
⊢ a⁻¹ ∈ centralizer S

tactic: exact zero_mem_centralizer S
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : GroupWithZero M
ha : a ∈ centralizer S
h : a = 0
⊢ 0 ∈ centralizer S

tactic: rw [mul_inv_eq_iff_eq_mul₀ ha0, mul_assoc, eq_inv_mul_iff_mul_eq₀ ha0, ha c hc]
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : GroupWithZero M
ha : a ∈ centralizer S
ha0 : a ≠ 0
c : M
hc : c ∈ S
⊢ c * a⁻¹ = a⁻¹ * c
Theorem: Multiset.countp_eq_countp_filter_add
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp
state_before: case h.e'_3.h.e'_6
α : Type u_1
β : Type ?u.313067
γ : Type ?u.313070
p✝ : α → Prop
inst✝² : DecidablePred p✝
s : Multiset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
l : List α
⊢ countp p (filter (fun a => ¬q a) (Quot.mk Setoid.r l)) =
    List.countp (fun x => decide (p x)) (List.filter (fun a => decide ¬decide (q a) = true) l)
Theorem: TopologicalSpace.isTopologicalBasis_of_open_of_nhds
File: Mathlib/Topology/Bases.lean

tactic: refine'
  ⟨fun t₁ ht₁ t₂ ht₂ x hx => h_nhds _ _ hx (IsOpen.inter (h_open _ ht₁) (h_open _ ht₂)), _, _⟩
state_before: α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
⊢ IsTopologicalBasis s

tactic: refine' sUnion_eq_univ_iff.2 fun a => _
state_before: case refine'_1
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
⊢ ⋃₀ s = univ

tactic: rcases h_nhds a univ trivial isOpen_univ with ⟨u, h₁, h₂, -⟩
state_before: case refine'_1
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
a : α
⊢ ∃ b, b ∈ s ∧ a ∈ b

tactic: exact ⟨u, h₁, h₂⟩
state_before: case refine'_1.intro.intro.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
a : α
u : Set α
h₁ : u ∈ s
h₂ : a ∈ u
⊢ ∃ b, b ∈ s ∧ a ∈ b

tactic: refine' (le_generateFrom h_open).antisymm fun u hu => _
state_before: case refine'_2
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
⊢ t = generateFrom s

tactic: refine' (@isOpen_iff_nhds α (generateFrom s) u).mpr fun a ha => _
state_before: case refine'_2
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
u : Set α
hu : IsOpen u
⊢ IsOpen u

tactic: rcases h_nhds a u ha hu with ⟨v, hvs, hav, hvu⟩
state_before: case refine'_2
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
u : Set α
hu : IsOpen u
a : α
ha : a ∈ u
⊢ 𝓝 a ≤ 𝓟 u

tactic: rw [nhds_generateFrom]
state_before: case refine'_2.intro.intro.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
u : Set α
hu : IsOpen u
a : α
ha : a ∈ u
v : Set α
hvs : v ∈ s
hav : a ∈ v
hvu : v ⊆ u
⊢ 𝓝 a ≤ 𝓟 u

tactic: exact iInf₂_le_of_le v ⟨hav, hvs⟩ (le_principal_iff.2 hvu)
state_before: case refine'_2.intro.intro.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ (u : Set α), u ∈ s → IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ s ∧ a ∈ v ∧ v ⊆ u
u : Set α
hu : IsOpen u
a : α
ha : a ∈ u
v : Set α
hvs : v ∈ s
hav : a ∈ v
hvu : v ⊆ u
⊢ (⨅ (s_1 : Set α) (_ : s_1 ∈ {s_2 | a ∈ s_2 ∧ s_2 ∈ s}), 𝓟 s_1) ≤ 𝓟 u
Theorem: IsROrC.abs_im_div_norm_le_one
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [abs_div, abs_norm]
state_before: K : Type u_1
E : Type ?u.6921453
inst✝ : IsROrC K
z : K
⊢ abs (↑im z / ‖z‖) ≤ 1

tactic: exact div_le_one_of_le (abs_im_le_norm _) (norm_nonneg _)
state_before: K : Type u_1
E : Type ?u.6921453
inst✝ : IsROrC K
z : K
⊢ abs (↑im z) / ‖z‖ ≤ 1
Theorem: PUnit.subsingleton
File: src/lean/Init/Core.lean

tactic: cases a
state_before: a✝ b✝ c d : Prop
a b : PUnit
⊢ a = b

tactic: cases b
state_before: case unit
a b✝ c d : Prop
b : PUnit
⊢ unit = b

tactic: exact rfl
state_before: case unit.unit
a b c d : Prop
⊢ unit = unit
Theorem: le_nhds_of_cauchy_adhp_aux
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: intro s hs
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
x : α
adhs : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ t, t ∈ f ∧ t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
⊢ f ≤ 𝓝 x

tactic: rcases comp_mem_uniformity_sets (mem_nhds_uniformity_iff_right.1 hs) with ⟨U, U_mem, hU⟩
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
x : α
adhs : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ t, t ∈ f ∧ t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
⊢ s ∈ f

tactic: rcases adhs U U_mem with ⟨t, t_mem, ht, y, hxy, hy⟩
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
x : α
adhs : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ t, t ∈ f ∧ t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.fst = x → p.snd ∈ s}
⊢ s ∈ f

tactic: apply mem_of_superset t_mem
state_before: case intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
x : α
adhs : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ t, t ∈ f ∧ t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.fst = x → p.snd ∈ s}
t : Set α
t_mem : t ∈ f
ht : t ×ˢ t ⊆ U
y : α
hxy : (x, y) ∈ U
hy : y ∈ t
⊢ s ∈ f

tactic: exact fun z hz => hU (prod_mk_mem_compRel hxy (ht <| mk_mem_prod hy hz)) rfl
state_before: case intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
x : α
adhs : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ t, t ∈ f ∧ t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.fst = x → p.snd ∈ s}
t : Set α
t_mem : t ∈ f
ht : t ×ˢ t ⊆ U
y : α
hxy : (x, y) ∈ U
hy : y ∈ t
⊢ t ⊆ s
Theorem: FirstOrder.Language.Theory.CompleteType.setOf_mem_eq_univ_iff
File: Mathlib/ModelTheory/Types.lean

tactic: rw [models_iff_not_satisfiable, ← compl_empty_iff, compl_setOf_mem, ← setOf_subset_eq_empty_iff]
state_before: L : Language
T : Theory L
α : Type w
φ : Sentence (L[[α]])
⊢ {p | φ ∈ p} = Set.univ ↔ LHom.onTheory (lhomWithConstants L α) T ⊨ᵇ φ

tactic: simp
state_before: L : Language
T : Theory L
α : Type w
φ : Sentence (L[[α]])
⊢ {p | Formula.not φ ∈ p} = ∅ ↔ {p | {Formula.not φ} ⊆ ↑p} = ∅
Theorem: MeasureTheory.integrableOn_const
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [Measure.restrict_apply_univ]
state_before: α : Type u_1
β : Type ?u.1495663
E : Type u_2
F : Type ?u.1495669
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
C : E
⊢ C = 0 ∨ ↑↑(Measure.restrict μ s) univ < ⊤ ↔ C = 0 ∨ ↑↑μ s < ⊤
Theorem: Nat.Linear.Poly.denote_reverseAux
File: src/lean/Init/Data/Nat/Linear.lean

tactic: match p with
| [] => simp [List.reverseAux]
| (k, v) :: p => simp [List.reverseAux, denote_reverseAux]
state_before: ctx : Context
p q : Poly
⊢ denote ctx (List.reverseAux p q) = denote ctx (p ++ q)

tactic: simp [List.reverseAux]
state_before: ctx : Context
p q : Poly
⊢ denote ctx (List.reverseAux [] q) = denote ctx ([] ++ q)

tactic: simp [List.reverseAux, denote_reverseAux]
state_before: ctx : Context
p✝ q : Poly
k : Nat
v : Var
p : List (Nat × Var)
⊢ denote ctx (List.reverseAux ((k, v) :: p) q) = denote ctx ((k, v) :: p ++ q)
Theorem: SimpleGraph.Walk.finite_neighborSet_toSubgraph
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil =>
  rw [Walk.toSubgraph, neighborSet_singletonSubgraph]
  apply Set.toFinite
| cons ha _ ih =>
  rw [Walk.toSubgraph, Subgraph.neighborSet_sup]
  refine Set.Finite.union ?_ ih
  refine Set.Finite.subset ?_ (neighborSet_subgraphOfAdj_subset ha)
  apply Set.toFinite
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
⊢ Set.Finite (Subgraph.neighborSet (Walk.toSubgraph p) w)

tactic: rw [Walk.toSubgraph, neighborSet_singletonSubgraph]
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ : V
⊢ Set.Finite (Subgraph.neighborSet (Walk.toSubgraph nil) w)

tactic: apply Set.toFinite
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ : V
⊢ Set.Finite ∅

tactic: rw [Walk.toSubgraph, Subgraph.neighborSet_sup]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ v✝ w✝ : V
ha : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : Set.Finite (Subgraph.neighborSet (Walk.toSubgraph p✝) w)
⊢ Set.Finite (Subgraph.neighborSet (Walk.toSubgraph (cons ha p✝)) w)

tactic: refine Set.Finite.union ?_ ih
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ v✝ w✝ : V
ha : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : Set.Finite (Subgraph.neighborSet (Walk.toSubgraph p✝) w)
⊢ Set.Finite (Subgraph.neighborSet (subgraphOfAdj G ha) w ∪ Subgraph.neighborSet (Walk.toSubgraph p✝) w)

tactic: refine Set.Finite.subset ?_ (neighborSet_subgraphOfAdj_subset ha)
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ v✝ w✝ : V
ha : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : Set.Finite (Subgraph.neighborSet (Walk.toSubgraph p✝) w)
⊢ Set.Finite (Subgraph.neighborSet (subgraphOfAdj G ha) w)

tactic: apply Set.toFinite
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ v✝ w✝ : V
ha : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : Set.Finite (Subgraph.neighborSet (Walk.toSubgraph p✝) w)
⊢ Set.Finite {u✝, v✝}
Theorem: MvPolynomial.homogeneousComponent_isHomogeneous
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: intro d hd
state_before: σ : Type u_1
τ : Type ?u.181825
R : Type u_2
S : Type ?u.181831
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
⊢ IsHomogeneous (↑(homogeneousComponent n) φ) n

tactic: contrapose! hd
state_before: σ : Type u_1
τ : Type ?u.181825
R : Type u_2
S : Type ?u.181831
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
hd : coeff d (↑(homogeneousComponent n) φ) ≠ 0
⊢ ∑ i in d.support, ↑d i = n

tactic: rw [coeff_homogeneousComponent, if_neg hd]
state_before: σ : Type u_1
τ : Type ?u.181825
R : Type u_2
S : Type ?u.181831
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
hd : ∑ x in d.support, ↑d x ≠ n
⊢ coeff d (↑(homogeneousComponent n) φ) = 0
Theorem: Nat.gcd_eq_right
File: Std/Data/Nat/Gcd.lean

tactic: rw [gcd_comm, gcd_eq_left H]
state_before: m n : Nat
H : n ∣ m
⊢ gcd m n = n
Theorem: MonoidAlgebra.liftNC_smul
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: suffices :
  (liftNC (↑f) g).comp (smulAddHom k (MonoidAlgebra k G) c) =
    (AddMonoidHom.mulLeft (f c)).comp (liftNC (↑f) g)
state_before: k : Type u₁
G : Type u₂
R✝ : Type ?u.528207
inst✝² : Semiring k
inst✝¹ : MulOneClass G
R : Type u_1
inst✝ : Semiring R
f : k →+* R
g : G →* R
c : k
φ : MonoidAlgebra k G
⊢ ↑(liftNC ↑f ↑g) (c • φ) = ↑f c * ↑(liftNC ↑f ↑g) φ

tactic: exact FunLike.congr_fun this φ
state_before: k : Type u₁
G : Type u₂
R✝ : Type ?u.528207
inst✝² : Semiring k
inst✝¹ : MulOneClass G
R : Type u_1
inst✝ : Semiring R
f : k →+* R
g : G →* R
c : k
φ : MonoidAlgebra k G
this :
  AddMonoidHom.comp (liftNC ↑f ↑g) (↑(smulAddHom k (MonoidAlgebra k G)) c) =
    AddMonoidHom.comp (AddMonoidHom.mulLeft (↑f c)) (liftNC ↑f ↑g)
⊢ ↑(liftNC ↑f ↑g) (c • φ) = ↑f c * ↑(liftNC ↑f ↑g) φ

case this
k : Type u₁
G : Type u₂
R✝ : Type ?u.528207
inst✝² : Semiring k
inst✝¹ : MulOneClass G
R : Type u_1
inst✝ : Semiring R
f : k →+* R
g : G →* R
c : k
φ : MonoidAlgebra k G
⊢ AddMonoidHom.comp (liftNC ↑f ↑g) (↑(smulAddHom k (MonoidAlgebra k G)) c) =
    AddMonoidHom.comp (AddMonoidHom.mulLeft (↑f c)) (liftNC ↑f ↑g)

tactic: refine addHom_ext' fun a => AddMonoidHom.ext fun b => ?_
state_before: case this
k : Type u₁
G : Type u₂
R✝ : Type ?u.528207
inst✝² : Semiring k
inst✝¹ : MulOneClass G
R : Type u_1
inst✝ : Semiring R
f : k →+* R
g : G →* R
c : k
φ : MonoidAlgebra k G
⊢ AddMonoidHom.comp (liftNC ↑f ↑g) (↑(smulAddHom k (MonoidAlgebra k G)) c) =
    AddMonoidHom.comp (AddMonoidHom.mulLeft (↑f c)) (liftNC ↑f ↑g)

tactic: unfold MonoidAlgebra
state_before: case this
k : Type u₁
G : Type u₂
R✝ : Type ?u.528207
inst✝² : Semiring k
inst✝¹ : MulOneClass G
R : Type u_1
inst✝ : Semiring R
f : k →+* R
g : G →* R
c : k
φ : MonoidAlgebra k G
a : G
b : k
⊢ ↑(AddMonoidHom.comp (AddMonoidHom.comp (liftNC ↑f ↑g) (↑(smulAddHom k (MonoidAlgebra k G)) c)) (singleAddHom a)) b =
    ↑(AddMonoidHom.comp (AddMonoidHom.comp (AddMonoidHom.mulLeft (↑f c)) (liftNC ↑f ↑g)) (singleAddHom a)) b

tactic: simp
state_before: case this
k : Type u₁
G : Type u₂
R✝ : Type ?u.528207
inst✝² : Semiring k
inst✝¹ : MulOneClass G
R : Type u_1
inst✝ : Semiring R
f : k →+* R
g : G →* R
c : k
φ : MonoidAlgebra k G
a : G
b : k
⊢ ↑(AddMonoidHom.comp (AddMonoidHom.comp (liftNC ↑f ↑g) (↑(smulAddHom k (G →₀ k)) c)) (singleAddHom a)) b =
    ↑(AddMonoidHom.comp (AddMonoidHom.comp (AddMonoidHom.mulLeft (↑f c)) (liftNC ↑f ↑g)) (singleAddHom a)) b

tactic: rw [liftNC_single, liftNC_single, AddMonoidHom.coe_coe, map_mul, mul_assoc]
state_before: case this
k : Type u₁
G : Type u₂
R✝ : Type ?u.528207
inst✝² : Semiring k
inst✝¹ : MulOneClass G
R : Type u_1
inst✝ : Semiring R
f : k →+* R
g : G →* R
c : k
φ : MonoidAlgebra k G
a : G
b : k
⊢ ↑(liftNC ↑f ↑g) (Finsupp.single a (c * b)) = ↑f c * ↑(liftNC ↑f ↑g) (Finsupp.single a b)
Theorem: ZNum.cast_bit1
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp [ZNum.bit1, _root_.bit1, _root_.bit0]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
⊢ ↑(ZNum.bit1 0) = _root_.bit1 ↑0

tactic: rw [ZNum.bit1, cast_pos, cast_pos]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑(ZNum.bit1 (pos p)) = _root_.bit1 ↑(pos p)

tactic: rfl
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑(PosNum.bit1 p) = _root_.bit1 ↑p

tactic: rw [ZNum.bit1, cast_neg, cast_neg]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑(ZNum.bit1 (neg p)) = _root_.bit1 ↑(neg p)

tactic: cases' e : pred' p with a <;>
  have ep : p = _ := (succ'_pred' p).symm.trans (congr_arg Num.succ' e)
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ -↑(Num.casesOn (pred' p) 1 PosNum.bit1) = _root_.bit1 (-↑p)

tactic: conv at ep => change p = 1
state_before: case zero
α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
e : pred' p = Num.zero
ep : p = Num.succ' Num.zero
⊢ -↑(Num.casesOn Num.zero 1 PosNum.bit1) = _root_.bit1 (-↑p)

tactic: subst p
state_before: case zero
α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
e : pred' p = Num.zero
ep : p = 1
⊢ -↑(Num.casesOn Num.zero 1 PosNum.bit1) = _root_.bit1 (-↑p)

tactic: simp [_root_.bit1, _root_.bit0]
state_before: case zero
α : Type u_1
inst✝ : AddGroupWithOne α
e : pred' 1 = Num.zero
⊢ -↑(Num.casesOn Num.zero 1 PosNum.bit1) = _root_.bit1 (-↑1)

tactic: dsimp only [Num.succ'] at ep
state_before: case pos
α : Type u_1
inst✝ : AddGroupWithOne α
p a : PosNum
e : pred' p = Num.pos a
ep : p = Num.succ' (Num.pos a)
⊢ -↑(Num.casesOn (Num.pos a) 1 PosNum.bit1) = _root_.bit1 (-↑p)

tactic: subst p
state_before: case pos
α : Type u_1
inst✝ : AddGroupWithOne α
p a : PosNum
e : pred' p = Num.pos a
ep : p = PosNum.succ a
⊢ -↑(Num.casesOn (Num.pos a) 1 PosNum.bit1) = _root_.bit1 (-↑p)

tactic: have : (↑(-↑a : ℤ) : α) = -1 + ↑(-↑a + 1 : ℤ) := by simp [add_comm (- ↑a : ℤ) 1]
state_before: case pos
α : Type u_1
inst✝ : AddGroupWithOne α
a : PosNum
e : pred' (PosNum.succ a) = Num.pos a
⊢ -↑(Num.casesOn (Num.pos a) 1 PosNum.bit1) = _root_.bit1 (-↑(PosNum.succ a))

tactic: simpa [_root_.bit1, _root_.bit0] using this
state_before: case pos
α : Type u_1
inst✝ : AddGroupWithOne α
a : PosNum
e : pred' (PosNum.succ a) = Num.pos a
this : ↑(-↑a) = -1 + ↑(-↑a + 1)
⊢ -↑(Num.casesOn (Num.pos a) 1 PosNum.bit1) = _root_.bit1 (-↑(PosNum.succ a))

tactic: simp [add_comm (- ↑a : ℤ) 1]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
a : PosNum
e : pred' (PosNum.succ a) = Num.pos a
⊢ ↑(-↑a) = -1 + ↑(-↑a + 1)
Theorem: Finset.mem_finsupp_iff_of_support_subset
File: Mathlib/Data/Finset/Finsupp.lean

tactic: refine'
  mem_finsupp_iff.trans
    (forall_and.symm.trans <|
      forall_congr' fun i =>
        ⟨fun h => _, fun h =>
          ⟨fun hi => ht <| mem_support_iff.2 fun H => mem_support_iff.1 hi _, fun _ => h⟩⟩)
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
⊢ f ∈ Finset.finsupp s ↑t ↔ ∀ (i : ι), ↑f i ∈ ↑t i

tactic: by_cases hi : i ∈ s
state_before: case refine'_1
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → ↑f i ∈ ↑t i)
⊢ ↑f i ∈ ↑t i

tactic: exact h.2 hi
state_before: case pos
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → ↑f i ∈ ↑t i)
hi : i ∈ s
⊢ ↑f i ∈ ↑t i

tactic: rw [not_mem_support_iff.1 (mt h.1 hi), not_mem_support_iff.1 fun H => hi <| ht H]
state_before: case neg
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → ↑f i ∈ ↑t i)
hi : ¬i ∈ s
⊢ ↑f i ∈ ↑t i

tactic: exact zero_mem_zero
state_before: case neg
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → ↑f i ∈ ↑t i)
hi : ¬i ∈ s
⊢ 0 ∈ 0

tactic: rwa [H, mem_zero] at h
state_before: case refine'_2
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : ↑f i ∈ ↑t i
hi : i ∈ f.support
H : ↑t i = 0
⊢ ↑f i = 0
Theorem: WithZeroTopology.hasBasis_nhds_zero
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: rw [nhds_zero]
state_before: α : Type ?u.3501
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ HasBasis (𝓝 0) (fun γ => γ ≠ 0) Iio

tactic: refine' hasBasis_biInf_principal _ ⟨1, one_ne_zero⟩
state_before: α : Type ?u.3501
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ HasBasis (⨅ (γ : Γ₀) (_ : γ ≠ 0), 𝓟 (Iio γ)) (fun γ => γ ≠ 0) Iio

tactic: exact directedOn_iff_directed.2 (directed_of_inf fun a b hab => Iio_subset_Iio hab)
state_before: α : Type ?u.3501
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ DirectedOn ((fun γ => Iio γ) ⁻¹'o fun x x_1 => x ≥ x_1) fun γ => γ = 0 → False
Theorem: TendstoLocallyUniformlyOn.union
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [← sUnion_pair]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
s₁ s₂ : Set α
hs₁ : IsOpen s₁
hs₂ : IsOpen s₂
h₁ : TendstoLocallyUniformlyOn F f p s₁
h₂ : TendstoLocallyUniformlyOn F f p s₂
⊢ TendstoLocallyUniformlyOn F f p (s₁ ∪ s₂)

tactic: refine' tendstoLocallyUniformlyOn_sUnion _ _ _ <;> simp [*]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
s₁ s₂ : Set α
hs₁ : IsOpen s₁
hs₂ : IsOpen s₂
h₁ : TendstoLocallyUniformlyOn F f p s₁
h₂ : TendstoLocallyUniformlyOn F f p s₂
⊢ TendstoLocallyUniformlyOn F f p (⋃₀ {s₁, s₂})
Theorem: coe_finsetBasisOfLinearIndependentOfCardEqFinrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [finsetBasisOfLinearIndependentOfCardEqFinrank]
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : Finset.Nonempty s
lin_ind : LinearIndependent K Subtype.val
card_eq : Finset.card s = finrank K V
⊢ ↑(finsetBasisOfLinearIndependentOfCardEqFinrank hs lin_ind card_eq) = Subtype.val

tactic: exact Basis.coe_mk _ _
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : Finset.Nonempty s
lin_ind : LinearIndependent K Subtype.val
card_eq : Finset.card s = finrank K V
⊢ ↑(basisOfLinearIndependentOfCardEqFinrank lin_ind (_ : Fintype.card { x // x ∈ s } = finrank K V)) = Subtype.val