tasksource/leandojo huggingface dataset:
Theorem: Filter.IsBasis.mem_filter_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [IsBasis.filter, FilterBasis.mem_filter_iff, mem_filterBasis_iff,
  exists_exists_and_eq_and]
state_before: α : Type u_1
β : Type ?u.8994
γ : Type ?u.8997
ι : Sort u_2
ι' : Sort ?u.9003
p : ι → Prop
s : ι → Set α
h : IsBasis p s
U : Set α
⊢ U ∈ IsBasis.filter h ↔ ∃ i, p i ∧ s i ⊆ U
Theorem: mul_upperClosure
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: simp_rw [← smul_eq_mul, ← Set.iUnion_smul_set, upperClosure_iUnion, upperClosure_smul,
  UpperSet.coe_iInf₂]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ s * ↑(upperClosure t) = ↑(upperClosure (s * t))

tactic: rfl
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ (⋃ (a : α) (_ : a ∈ s), a • ↑(upperClosure t)) = ⋃ (i : α) (_ : i ∈ s), ↑(i • upperClosure t)
Theorem: mem_uniformity_of_uniformContinuous_invariant
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [UniformContinuous, uniformity_prod_eq_prod, tendsto_map'_iff] at hf
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.154319
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : UniformContinuous fun p => f p.fst p.snd
hs : s ∈ 𝓤 β
⊢ ∃ u, u ∈ 𝓤 α ∧ ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s

tactic: rcases mem_prod_iff.1 (mem_map.1 <| hf hs) with ⟨u, hu, v, hv, huvt⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.154319
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf :
  Tendsto
    ((fun x => (f x.fst.fst x.fst.snd, f x.snd.fst x.snd.snd)) ∘ fun p =>
      ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd))
    (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
⊢ ∃ u, u ∈ 𝓤 α ∧ ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s

tactic: exact ⟨u, hu, fun a b c hab => @huvt ((_, _), (_, _)) ⟨hab, refl_mem_uniformity hv⟩⟩
state_before: case intro.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.154319
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf :
  Tendsto
    ((fun x => (f x.fst.fst x.fst.snd, f x.snd.fst x.snd.snd)) ∘ fun p =>
      ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd))
    (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
u : Set (α × α)
hu : u ∈ 𝓤 α
v : Set (α × α)
hv : v ∈ 𝓤 α
huvt :
  u ×ˢ v ⊆
    ((fun x => (f x.fst.fst x.fst.snd, f x.snd.fst x.snd.snd)) ∘ fun p =>
        ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ⁻¹'
      s
⊢ ∃ u, u ∈ 𝓤 α ∧ ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
Theorem: List.map_injective_iff
File: Mathlib/Data/List/Basic.lean

tactic: constructor <;> intro h x y hxy
state_before: ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
⊢ Injective (map f) ↔ Injective f

tactic: suffices [x] = [y] by simpa using this
state_before: case mp
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective (map f)
x y : α
hxy : f x = f y
⊢ x = y

tactic: apply h
state_before: case mp
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective (map f)
x y : α
hxy : f x = f y
⊢ [x] = [y]

tactic: simp [hxy]
state_before: case mp.a
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective (map f)
x y : α
hxy : f x = f y
⊢ map f [x] = map f [y]

tactic: simpa using this
state_before: ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective (map f)
x y : α
hxy : f x = f y
this : [x] = [y]
⊢ x = y

tactic: induction' y with yh yt y_ih generalizing x
state_before: case mpr
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective f
x y : List α
hxy : map f x = map f y
⊢ x = y

tactic: cases x
state_before: case mpr.cons
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective f
x✝ y : List α
hxy✝ : map f x✝ = map f y
yh : α
yt : List α
y_ih : ∀ ⦃x : List α⦄, map f x = map f yt → x = yt
x : List α
hxy : map f x = map f (yh :: yt)
⊢ x = yh :: yt

tactic: simpa using hxy
state_before: case mpr.nil
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective f
x✝ y : List α
hxy✝ : map f x✝ = map f y
x : List α
hxy : map f x = map f []
⊢ x = []

tactic: simp at hxy
state_before: case mpr.cons.nil
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective f
x y : List α
hxy✝ : map f x = map f y
yh : α
yt : List α
y_ih : ∀ ⦃x : List α⦄, map f x = map f yt → x = yt
hxy : map f [] = map f (yh :: yt)
⊢ [] = yh :: yt

tactic: simp only [map, cons.injEq] at hxy
state_before: case mpr.cons.cons
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective f
x y : List α
hxy✝ : map f x = map f y
yh : α
yt : List α
y_ih : ∀ ⦃x : List α⦄, map f x = map f yt → x = yt
head✝ : α
tail✝ : List α
hxy : map f (head✝ :: tail✝) = map f (yh :: yt)
⊢ head✝ :: tail✝ = yh :: yt

tactic: simp [y_ih hxy.2, h hxy.1]
state_before: case mpr.cons.cons
ι : Type ?u.135734
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
h : Injective f
x y : List α
hxy✝ : map f x = map f y
yh : α
yt : List α
y_ih : ∀ ⦃x : List α⦄, map f x = map f yt → x = yt
head✝ : α
tail✝ : List α
hxy : f head✝ = f yh ∧ map f tail✝ = map f yt
⊢ head✝ :: tail✝ = yh :: yt
Theorem: List.rotate'_cons_succ
File: Mathlib/Data/List/Rotate.lean

tactic: simp [rotate']
state_before: α : Type u
l : List α
a : α
n : ℕ
⊢ rotate' (a :: l) (succ n) = rotate' (l ++ [a]) n
Theorem: CategoryTheory.NatIso.isIso_map_iff
File: Mathlib/CategoryTheory/NatIso.lean

tactic: revert F₁ F₂
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X✝ Y✝ : C
F₁ F₂ : C ⥤ D
e : F₁ ≅ F₂
X Y : C
f : X ⟶ Y
⊢ IsIso (F₁.map f) ↔ IsIso (F₂.map f)

tactic: suffices ∀ {F₁ F₂ : C ⥤ D} (_ : F₁ ≅ F₂) (_ : IsIso (F₁.map f)), IsIso (F₂.map f) by
  exact fun F₁ F₂ e => ⟨this e, this e.symm⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X✝ Y✝ X Y : C
f : X ⟶ Y
⊢ ∀ {F₁ F₂ : C ⥤ D}, (F₁ ≅ F₂) → (IsIso (F₁.map f) ↔ IsIso (F₂.map f))

tactic: intro F₁ F₂ e hf
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X✝ Y✝ X Y : C
f : X ⟶ Y
⊢ ∀ {F₁ F₂ : C ⥤ D}, (F₁ ≅ F₂) → IsIso (F₁.map f) → IsIso (F₂.map f)

tactic: refine' IsIso.mk ⟨e.inv.app Y ≫ inv (F₁.map f) ≫ e.hom.app X, _, _⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X✝ Y✝ X Y : C
f : X ⟶ Y
F₁ F₂ : C ⥤ D
e : F₁ ≅ F₂
hf : IsIso (F₁.map f)
⊢ IsIso (F₂.map f)

tactic: exact fun F₁ F₂ e => ⟨this e, this e.symm⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X✝ Y✝ X Y : C
f : X ⟶ Y
this : ∀ {F₁ F₂ : C ⥤ D}, (F₁ ≅ F₂) → IsIso (F₁.map f) → IsIso (F₂.map f)
⊢ ∀ {F₁ F₂ : C ⥤ D}, (F₁ ≅ F₂) → (IsIso (F₁.map f) ↔ IsIso (F₂.map f))

tactic: simp only [NatTrans.naturality_assoc, IsIso.hom_inv_id_assoc, Iso.inv_hom_id_app]
state_before: case refine'_1
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X✝ Y✝ X Y : C
f : X ⟶ Y
F₁ F₂ : C ⥤ D
e : F₁ ≅ F₂
hf : IsIso (F₁.map f)
⊢ F₂.map f ≫ e.inv.app Y ≫ inv (F₁.map f) ≫ e.hom.app X = 𝟙 (F₂.obj X)

tactic: simp only [assoc, ← e.hom.naturality, IsIso.inv_hom_id_assoc, Iso.inv_hom_id_app]
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X✝ Y✝ X Y : C
f : X ⟶ Y
F₁ F₂ : C ⥤ D
e : F₁ ≅ F₂
hf : IsIso (F₁.map f)
⊢ (e.inv.app Y ≫ inv (F₁.map f) ≫ e.hom.app X) ≫ F₂.map f = 𝟙 (F₂.obj Y)
Theorem: Ordinal.enum_lt_enum
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← typein_lt_typein r, typein_enum, typein_enum]
state_before: α : Type u_1
β : Type ?u.97279
γ : Type ?u.97282
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
o₁ o₂ : Ordinal
h₁ : o₁ < type r
h₂ : o₂ < type r
⊢ r (enum r o₁ h₁) (enum r o₂ h₂) ↔ o₁ < o₂
Theorem: CategoryTheory.eqToHom_map
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: cases p
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y : C
p : X = Y
⊢ F.map (eqToHom p) = eqToHom (_ : F.obj X = F.obj Y)

tactic: simp
state_before: case refl
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X : C
⊢ F.map (eqToHom (_ : X = X)) = eqToHom (_ : F.obj X = F.obj X)
Theorem: and_rotate
File: Std/Logic.lean

tactic: simp only [and_left_comm, and_comm]
state_before: a b c : Prop
⊢ a ∧ b ∧ c ↔ b ∧ c ∧ a
Theorem: PiLp.norm_equiv_symm_const'
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: simp
state_before: p : ℝ≥0∞
𝕜 : Type ?u.509175
𝕜' : Type ?u.509178
ι : Type u_2
α : ι → Type ?u.509186
β✝ : ι → Type ?u.509191
inst✝¹⁰ : Fintype ι
inst✝⁹ : Fact (1 ≤ p)
inst✝⁸ : NormedField 𝕜
inst✝⁷ : NormedField 𝕜'
inst✝⁶ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝⁵ : (i : ι) → NormedSpace 𝕜 (β✝ i)
c : 𝕜
x y : PiLp p β✝
x' y' : (i : ι) → β✝ i
i : ι
ι' : Type ?u.509387
inst✝⁴ : Fintype ι'
E : Type ?u.509393
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
β : Type u_1
inst✝¹ : SeminormedAddCommGroup β
inst✝ : Nonempty ι
b : β
⊢ ↑(↑(Fintype.card ι) ^ ENNReal.toReal (1 / p) * ‖b‖₊) = ↑(↑(Fintype.card ι) ^ ENNReal.toReal (1 / p)) * ‖b‖
Theorem: Submodule.unique_quotient_iff_eq_top
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rintro rfl
state_before: R : Type u_2
M : Type u_1
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ p = ⊤ → Nonempty (Unique (M ⧸ p))

tactic: exact ⟨QuotientTop.unique⟩
state_before: R : Type u_2
M : Type u_1
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p' : Submodule R M
⊢ Nonempty (Unique (M ⧸ ⊤))
Theorem: MonoidAlgebra.mul_apply_left
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [← Finsupp.sum_apply, ← Finsupp.sum_mul g f, f.sum_single]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1513482
inst✝¹ : Semiring k
inst✝ : Group G
f g : MonoidAlgebra k G
x : G
⊢ ↑(f * g) x = sum f fun a b => ↑(single a b * g) x

tactic: simp only [single_mul_apply, Finsupp.sum]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1513482
inst✝¹ : Semiring k
inst✝ : Group G
f g : MonoidAlgebra k G
x : G
⊢ (sum f fun a b => ↑(single a b * g) x) = sum f fun a b => b * ↑g (a⁻¹ * x)
Theorem: Polynomial.coeff_one_zero
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [← monomial_zero_one, coeff_monomial]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ coeff 1 0 = 1

tactic: simp
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ (if 0 = 0 then 1 else 0) = 1
Theorem: Function.bijOn_ptsOfPeriod
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [← comp_apply (f := f), comp_iterate_pred_of_pos f hn, hx.eq]
state_before: α : Type u_1
β : Type ?u.5460
f✝ fa : α → α
fb : β → β
x✝ y : α
m n✝ : ℕ
f : α → α
n : ℕ
hn : 0 < n
x : α
hx : x ∈ ptsOfPeriod f n
⊢ f ((f^[Nat.pred n]) x) = x
Theorem: Set.compl_iInter₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [compl_iInter]
state_before: α : Type u_1
β : Type ?u.68398
γ : Type ?u.68401
ι : Sort u_2
ι' : Sort ?u.68407
ι₂ : Sort ?u.68410
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.68420
κ₂ : ι → Sort ?u.68425
κ' : ι' → Sort ?u.68430
s : (i : ι) → κ i → Set α
⊢ (⋂ (i : ι) (j : κ i), s i j)ᶜ = ⋃ (i : ι) (j : κ i), s i jᶜ
Theorem: finprod_mem_union_inter
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: lift s to Finset α using hs
state_before: α : Type u_1
β : Type ?u.326633
ι : Type ?u.326636
G : Type ?u.326639
M : Type u_2
N : Type ?u.326645
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : Set.Finite s
ht : Set.Finite t
⊢ ((∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t), f i) =
    (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i

tactic: lift t to Finset α using ht
state_before: case intro
α : Type u_1
β : Type ?u.326633
ι : Type ?u.326636
G : Type ?u.326639
M : Type u_2
N : Type ?u.326645
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
t : Set α
ht : Set.Finite t
s : Finset α
⊢ ((∏ᶠ (i : α) (_ : i ∈ ↑s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ ↑s ∩ t), f i) =
    (∏ᶠ (i : α) (_ : i ∈ ↑s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i

tactic: classical
  rw [← Finset.coe_union, ← Finset.coe_inter]
  simp only [finprod_mem_coe_finset, Finset.prod_union_inter]
state_before: case intro.intro
α : Type u_1
β : Type ?u.326633
ι : Type ?u.326636
G : Type ?u.326639
M : Type u_2
N : Type ?u.326645
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Finset α
⊢ ((∏ᶠ (i : α) (_ : i ∈ ↑s ∪ ↑t), f i) * ∏ᶠ (i : α) (_ : i ∈ ↑s ∩ ↑t), f i) =
    (∏ᶠ (i : α) (_ : i ∈ ↑s), f i) * ∏ᶠ (i : α) (_ : i ∈ ↑t), f i

tactic: rw [← Finset.coe_union, ← Finset.coe_inter]
state_before: case intro.intro
α : Type u_1
β : Type ?u.326633
ι : Type ?u.326636
G : Type ?u.326639
M : Type u_2
N : Type ?u.326645
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Finset α
⊢ ((∏ᶠ (i : α) (_ : i ∈ ↑s ∪ ↑t), f i) * ∏ᶠ (i : α) (_ : i ∈ ↑s ∩ ↑t), f i) =
    (∏ᶠ (i : α) (_ : i ∈ ↑s), f i) * ∏ᶠ (i : α) (_ : i ∈ ↑t), f i

tactic: simp only [finprod_mem_coe_finset, Finset.prod_union_inter]
state_before: case intro.intro
α : Type u_1
β : Type ?u.326633
ι : Type ?u.326636
G : Type ?u.326639
M : Type u_2
N : Type ?u.326645
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Finset α
⊢ ((∏ᶠ (i : α) (_ : i ∈ ↑(s ∪ t)), f i) * ∏ᶠ (i : α) (_ : i ∈ ↑(s ∩ t)), f i) =
    (∏ᶠ (i : α) (_ : i ∈ ↑s), f i) * ∏ᶠ (i : α) (_ : i ∈ ↑t), f i
Theorem: Multiset.map_traverse
File: Mathlib/Data/Multiset/Functor.lean

tactic: refine' Quotient.inductionOn x _
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → G β
h : β → γ
x : Multiset α
⊢ Functor.map h <$> traverse g x = traverse (Functor.map h ∘ g) x

tactic: intro
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → G β
h : β → γ
x : Multiset α
⊢ ∀ (a : List α),
    Functor.map h <$> traverse g (Quotient.mk (isSetoid α) a) =
      traverse (Functor.map h ∘ g) (Quotient.mk (isSetoid α) a)

tactic: simp only [traverse, quot_mk_to_coe, lift_coe, Function.comp_apply, Functor.map_map, map_comp_coe]
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → G β
h : β → γ
x : Multiset α
a✝ : List α
⊢ Functor.map h <$> traverse g (Quotient.mk (isSetoid α) a✝) =
    traverse (Functor.map h ∘ g) (Quotient.mk (isSetoid α) a✝)

tactic: rw [LawfulFunctor.comp_map, Traversable.map_traverse']
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → G β
h : β → γ
x : Multiset α
a✝ : List α
⊢ (Coe.coe ∘ Functor.map h) <$> Traversable.traverse g a✝ = Coe.coe <$> Traversable.traverse (Functor.map h ∘ g) a✝

tactic: rfl
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → G β
h : β → γ
x : Multiset α
a✝ : List α
⊢ Coe.coe <$> Functor.map h <$> Traversable.traverse g a✝ =
    Coe.coe <$> (Functor.map (Functor.map h) ∘ Traversable.traverse g) a✝
Theorem: PiLp.norm_equiv_symm_const
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: simp
state_before: p : ℝ≥0∞
𝕜 : Type ?u.505702
𝕜' : Type ?u.505705
ι : Type u_2
α : ι → Type ?u.505713
β✝ : ι → Type ?u.505718
inst✝⁹ : Fintype ι
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NormedField 𝕜'
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝⁴ : (i : ι) → NormedSpace 𝕜 (β✝ i)
c : 𝕜
x y : PiLp p β✝
x' y' : (i : ι) → β✝ i
i : ι
ι' : Type ?u.505914
inst✝³ : Fintype ι'
E : Type ?u.505920
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
β : Type u_1
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
⊢ ↑(↑(Fintype.card ι) ^ ENNReal.toReal (1 / p) * ‖b‖₊) = ↑(↑(Fintype.card ι) ^ ENNReal.toReal (1 / p)) * ‖b‖
Theorem: Int.csSup_empty
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

tactic: simp
state_before: ⊢ ¬(Set.Nonempty ∅ ∧ BddAbove ∅)
Theorem: ZMod.valMinAbs_eq_zero
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases' n with n
state_before: n : ℕ
x : ZMod n
⊢ valMinAbs x = 0 ↔ x = 0

tactic: rw [← valMinAbs_zero n.succ]
state_before: case succ
n : ℕ
x : ZMod (Nat.succ n)
⊢ valMinAbs x = 0 ↔ x = 0

tactic: apply injective_valMinAbs.eq_iff
state_before: case succ
n : ℕ
x : ZMod (Nat.succ n)
⊢ valMinAbs x = valMinAbs 0 ↔ x = 0

tactic: simp
state_before: case zero
x : ZMod Nat.zero
⊢ valMinAbs x = 0 ↔ x = 0
Theorem: iSup_union
File: Mathlib/Order/CompleteLattice.lean

tactic: simp_rw [mem_union, iSup_or, iSup_sup_eq]
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.114350
γ : Type ?u.114353
ι : Sort ?u.114356
ι' : Sort ?u.114359
κ : ι → Sort ?u.114364
κ' : ι' → Sort ?u.114369
inst✝ : CompleteLattice α
f✝ g s✝ t✝ : ι → α
a b : α
f : β → α
s t : Set β
⊢ (⨆ (x : β) (_ : x ∈ s ∪ t), f x) = (⨆ (x : β) (_ : x ∈ s), f x) ⊔ ⨆ (x : β) (_ : x ∈ t), f x
Theorem: bernoulli'_spec'
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: refine' ((sum_antidiagonal_eq_sum_range_succ_mk _ n).trans _).trans (bernoulli'_spec n)
state_before: A : Type ?u.179006
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k in antidiagonal n, ↑(Nat.choose (k.fst + k.snd) k.snd) / (↑k.snd + 1) * bernoulli' k.fst = 1

tactic: refine' sum_congr rfl fun x hx => _
state_before: A : Type ?u.179006
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k in range (succ n),
      ↑(Nat.choose ((k, n - k).fst + (k, n - k).snd) (k, n - k).snd) / (↑(k, n - k).snd + 1) *
        bernoulli' (k, n - k).fst =
    ∑ k in range (succ n), ↑(Nat.choose n (n - k)) / (↑n - ↑k + 1) * bernoulli' k

tactic: simp only [add_tsub_cancel_of_le, mem_range_succ_iff.mp hx, cast_sub]
state_before: A : Type ?u.179006
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n x : ℕ
hx : x ∈ range (succ n)
⊢ ↑(Nat.choose ((x, n - x).fst + (x, n - x).snd) (x, n - x).snd) / (↑(x, n - x).snd + 1) * bernoulli' (x, n - x).fst =
    ↑(Nat.choose n (n - x)) / (↑n - ↑x + 1) * bernoulli' x
Theorem: Set.partiallyWellOrderedOn_insert
File: Mathlib/Order/WellFoundedSet.lean

tactic: simp only [← singleton_union, partiallyWellOrderedOn_union,
  partiallyWellOrderedOn_singleton, true_and_iff]
state_before: ι : Type ?u.81246
α : Type u_1
β : Type ?u.81252
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
inst✝ : IsRefl α r
⊢ PartiallyWellOrderedOn (insert a s) r ↔ PartiallyWellOrderedOn s r
Theorem: Complex.mul_I_im
File: Mathlib/Data/Complex/Basic.lean

tactic: simp
state_before: z : ℂ
⊢ (z * I).im = z.re
Theorem: Prod.swap_iInf
File: Mathlib/Order/CompleteLattice.lean

tactic: simp_rw [iInf, swap_sInf, ←range_comp, Function.comp]
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.211513
γ : Type ?u.211516
ι : Sort u_3
ι' : Sort ?u.211522
κ : ι → Sort ?u.211527
κ' : ι' → Sort ?u.211532
inst✝¹ : InfSet α
inst✝ : InfSet β
f : ι → α × β
⊢ swap (iInf f) = ⨅ (i : ι), swap (f i)
Theorem: Lagrange.interpolate_eq_add_interpolate_erase
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [interpolate_eq_sum_interpolate_insert_sdiff _ hvs ⟨i, mem_insert_self i {j}⟩ _,
  sum_insert (not_mem_singleton.mpr hij), sum_singleton, basis_pair_left hij,
  basis_pair_right hij, sdiff_insert_insert_of_mem_of_not_mem hi (not_mem_singleton.mpr hij),
  sdiff_singleton_eq_erase, pair_comm,
  sdiff_insert_insert_of_mem_of_not_mem hj (not_mem_singleton.mpr hij.symm),
  sdiff_singleton_eq_erase]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
hj : j ∈ s
hij : i ≠ j
⊢ ↑(interpolate s v) r =
    ↑(interpolate (Finset.erase s j) v) r * basisDivisor (v i) (v j) +
      ↑(interpolate (Finset.erase s i) v) r * basisDivisor (v j) (v i)

tactic: exact insert_subset.mpr ⟨hi, singleton_subset_iff.mpr hj⟩
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
hj : j ∈ s
hij : i ≠ j
⊢ {i, j} ⊆ s
Theorem: Polynomial.degree_monomial
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [degree, support_monomial n ha]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
ha : a ≠ 0
⊢ degree (↑(monomial n) a) = ↑n

tactic: rfl
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
ha : a ≠ 0
⊢ Finset.max {n} = ↑n
Theorem: Finsupp.total_comp
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: ext
state_before: α : Type u_4
M : Type u_1
N : Type ?u.445605
P : Type ?u.445608
R : Type u_2
S : Type ?u.445614
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_3
M' : Type ?u.445709
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
f : α' → α
⊢ Finsupp.total α' M R (v ∘ f) = comp (Finsupp.total α M R v) (lmapDomain R R f)

tactic: simp [total_apply]
state_before: case h.h
α : Type u_4
M : Type u_1
N : Type ?u.445605
P : Type ?u.445608
R : Type u_2
S : Type ?u.445614
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_3
M' : Type ?u.445709
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
f : α' → α
a✝ : α'
⊢ ↑(comp (Finsupp.total α' M R (v ∘ f)) (lsingle a✝)) 1 =
    ↑(comp (comp (Finsupp.total α M R v) (lmapDomain R R f)) (lsingle a✝)) 1
Theorem: CategoryTheory.Cat.HasLimits.limit_π_homDiagram_eqToHom
File: Mathlib/CategoryTheory/Category/Cat/Limit.lean

tactic: subst h
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X Y : limit (F ⋙ objects)
j : J
h : X = Y
⊢ limit.π (homDiagram X Y) j (eqToHom h) = eqToHom (_ : limit.π (F ⋙ objects) j X = limit.π (F ⋙ objects) j Y)

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X : limit (F ⋙ objects)
j : J
⊢ limit.π (homDiagram X X) j (eqToHom (_ : X = X)) = eqToHom (_ : limit.π (F ⋙ objects) j X = limit.π (F ⋙ objects) j X)
Theorem: PowerSeries.X_ne_zero
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simpa only [coeff_one_X, one_ne_zero, map_zero] using congr_arg (coeff R 1) H
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
H : X = 0
⊢ False
Theorem: Finset.product_singleton
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.70206
s s' : Finset α
t t' : Finset β
a : α
b✝ b : β
⊢ s ×ˢ {b} = map { toFun := fun i => (i, b), inj' := (_ : Function.Injective fun a => (a, b)) } s

tactic: simp [and_left_comm, eq_comm]
state_before: case a.mk
α : Type u_2
β : Type u_1
γ : Type ?u.70206
s s' : Finset α
t t' : Finset β
a : α
b✝ b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ {b} ↔ (x, y) ∈ map { toFun := fun i => (i, b), inj' := (_ : Function.Injective fun a => (a, b)) } s
Theorem: Option.map₂_comm
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp [h_comm]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
a : Option α
b : Option β
c : Option γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
⊢ map₂ f a b = map₂ g b a