tasksource/leandojo huggingface dataset:
Theorem: IsPGroup.nontrivial_iff_card
File: Mathlib/GroupTheory/PGroup.lean

tactic: rw [hk0, pow_zero] at hk
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
inst✝ : Fintype G
hGnt : Nontrivial G
k : ℕ
hk : card G = p ^ k
hk0 : k = 0
⊢ False

tactic: exact Fintype.one_lt_card.ne' hk
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
inst✝ : Fintype G
hGnt : Nontrivial G
k : ℕ
hk : card G = 1
hk0 : k = 0
⊢ False
Theorem: finprod_eq_single
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: have : mulSupport (f ∘ PLift.down) ⊆ ({PLift.up a} : Finset (PLift α)) := by
  intro x
  contrapose
  simpa [PLift.eq_up_iff_down_eq] using ha x.down
state_before: G : Type ?u.34693
M : Type u_2
N : Type ?u.34699
α : Sort u_1
β : Sort ?u.34705
ι : Sort ?u.34708
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
a : α
ha : ∀ (x : α), x ≠ a → f x = 1
⊢ (∏ᶠ (x : α), f x) = f a

tactic: rw [finprod_eq_prod_pLift_of_mulSupport_subset this, Finset.prod_singleton]
state_before: G : Type ?u.34693
M : Type u_2
N : Type ?u.34699
α : Sort u_1
β : Sort ?u.34705
ι : Sort ?u.34708
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
a : α
ha : ∀ (x : α), x ≠ a → f x = 1
this : mulSupport (f ∘ PLift.down) ⊆ ↑{{ down := a }}
⊢ (∏ᶠ (x : α), f x) = f a

tactic: intro x
state_before: G : Type ?u.34693
M : Type u_2
N : Type ?u.34699
α : Sort u_1
β : Sort ?u.34705
ι : Sort ?u.34708
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
a : α
ha : ∀ (x : α), x ≠ a → f x = 1
⊢ mulSupport (f ∘ PLift.down) ⊆ ↑{{ down := a }}

tactic: contrapose
state_before: G : Type ?u.34693
M : Type u_2
N : Type ?u.34699
α : Sort u_1
β : Sort ?u.34705
ι : Sort ?u.34708
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
a : α
ha : ∀ (x : α), x ≠ a → f x = 1
x : PLift α
⊢ x ∈ mulSupport (f ∘ PLift.down) → x ∈ ↑{{ down := a }}

tactic: simpa [PLift.eq_up_iff_down_eq] using ha x.down
state_before: G : Type ?u.34693
M : Type u_2
N : Type ?u.34699
α : Sort u_1
β : Sort ?u.34705
ι : Sort ?u.34708
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
a : α
ha : ∀ (x : α), x ≠ a → f x = 1
x : PLift α
⊢ ¬x ∈ ↑{{ down := a }} → ¬x ∈ mulSupport (f ∘ PLift.down)
Theorem: preimage_find_eq_disjointed
File: Mathlib/Order/Disjointed.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.14611
s : ℕ → Set α
H : ∀ (x : α), ∃ n, x ∈ s n
inst✝ : (x : α) → (n : ℕ) → Decidable (x ∈ s n)
n : ℕ
⊢ (fun x => Nat.find (_ : ∃ n, x ∈ s n)) ⁻¹' {n} = disjointed s n

tactic: simp [Nat.find_eq_iff, disjointed_eq_inter_compl]
state_before: case h
α : Type u_1
β : Type ?u.14611
s : ℕ → Set α
H : ∀ (x : α), ∃ n, x ∈ s n
inst✝ : (x : α) → (n : ℕ) → Decidable (x ∈ s n)
n : ℕ
x : α
⊢ x ∈ (fun x => Nat.find (_ : ∃ n, x ∈ s n)) ⁻¹' {n} ↔ x ∈ disjointed s n
Theorem: MvQPF.supp_eq_of_isUniform
File: Mathlib/Data/QPF/Multivariate/Basic.lean

tactic: intro
state_before: n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ ∀ (i : Fin2 n), supp (abs { fst := a, snd := f }) i = f i '' univ

tactic: ext u
state_before: n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
⊢ supp (abs { fst := a, snd := f }) i✝ = f i✝ '' univ

tactic: rw [mem_supp]
state_before: case h
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
⊢ u ∈ supp (abs { fst := a, snd := f }) i✝ ↔ u ∈ f i✝ '' univ

tactic: constructor
state_before: case h
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
⊢ (∀ (a_1 : (P F).A) (f_1 : MvPFunctor.B (P F) a_1 ⟹ α),
      abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 i✝ '' univ) ↔
    u ∈ f i✝ '' univ

tactic: intro h' a' f' e
state_before: case h.mpr
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
⊢ u ∈ f i✝ '' univ →
    ∀ (a_2 : (P F).A) (f_1 : MvPFunctor.B (P F) a_2 ⟹ α),
      abs { fst := a_2, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 i✝ '' univ

tactic: rw [← h _ _ _ _ e.symm]
state_before: case h.mpr
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
h' : u ∈ f i✝ '' univ
a' : (P F).A
f' : MvPFunctor.B (P F) a' ⟹ α
e : abs { fst := a', snd := f' } = abs { fst := a, snd := f }
⊢ u ∈ f' i✝ '' univ

tactic: apply h'
state_before: case h.mpr
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
h' : u ∈ f i✝ '' univ
a' : (P F).A
f' : MvPFunctor.B (P F) a' ⟹ α
e : abs { fst := a', snd := f' } = abs { fst := a, snd := f }
⊢ u ∈ f i✝ '' univ

tactic: intro h'
state_before: case h.mp
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
⊢ (∀ (a_1 : (P F).A) (f_1 : MvPFunctor.B (P F) a_1 ⟹ α),
      abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 i✝ '' univ) →
    u ∈ f i✝ '' univ

tactic: apply h' _ _ rfl
state_before: case h.mp
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
h' :
  ∀ (a_1 : (P F).A) (f_1 : MvPFunctor.B (P F) a_1 ⟹ α),
    abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 i✝ '' univ
⊢ u ∈ f i✝ '' univ
Theorem: CategoryTheory.Abelian.exact_iff_image_eq_kernel
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: constructor
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g ↔ imageSubobject f = kernelSubobject g

tactic: intro h
state_before: case mp
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g → imageSubobject f = kernelSubobject g

tactic: have : IsIso (imageToKernel f g h.w) := have := h.epi; isIso_of_mono_of_epi _
state_before: case mp
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ imageSubobject f = kernelSubobject g

tactic: refine Subobject.eq_of_comm (asIso (imageToKernel _ _ h.w)) ?_
state_before: case mp
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
this : IsIso (imageToKernel f g (_ : f ≫ g = 0))
⊢ imageSubobject f = kernelSubobject g

tactic: simp
state_before: case mp
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
this : IsIso (imageToKernel f g (_ : f ≫ g = 0))
⊢ (asIso (imageToKernel f g (_ : f ≫ g = 0))).hom ≫ Subobject.arrow (kernelSubobject g) =
    Subobject.arrow (imageSubobject f)

tactic: apply exact_of_image_eq_kernel
state_before: case mpr
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ imageSubobject f = kernelSubobject g → Exact f g
Theorem: Algebra.TensorProduct.productMap_left
File: Mathlib/RingTheory/TensorProduct.lean

tactic: simp
state_before: R : Type u_3
A : Type u_1
B : Type u_4
S : Type u_2
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Semiring B
inst✝³ : CommSemiring S
inst✝² : Algebra R A
inst✝¹ : Algebra R B
inst✝ : Algebra R S
f : A →ₐ[R] S
g : B →ₐ[R] S
⊢ ∀ (x : A), ↑(AlgHom.comp (productMap f g) includeLeft) x = ↑f x
Theorem: id_eq_sum_orthogonalProjection_self_orthogonalComplement
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: ext w
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.968584
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace { x // x ∈ K }
⊢ ContinuousLinearMap.id 𝕜 E =
    ContinuousLinearMap.comp (Submodule.subtypeL K) (orthogonalProjection K) +
      ContinuousLinearMap.comp (Submodule.subtypeL Kᗮ) (orthogonalProjection Kᗮ)

tactic: exact eq_sum_orthogonalProjection_self_orthogonalComplement K w
state_before: case h
𝕜 : Type u_2
E : Type u_1
F : Type ?u.968584
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace { x // x ∈ K }
w : E
⊢ ↑(ContinuousLinearMap.id 𝕜 E) w =
    ↑(ContinuousLinearMap.comp (Submodule.subtypeL K) (orthogonalProjection K) +
          ContinuousLinearMap.comp (Submodule.subtypeL Kᗮ) (orthogonalProjection Kᗮ))
      w
Theorem: WittVector.mapFun.one
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: map_fun_tac
state_before: p : ℕ
R : Type u_2
S : Type u_1
T : Type ?u.54735
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.54750
β : Type ?u.54753
f : R →+* S
x y : 𝕎 R
⊢ mapFun (↑f) 1 = 1
Theorem: Polynomial.prod_X_sub_C_coeff_card_pred
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simpa using multiset_prod_X_sub_C_coeff_card_pred (s.1.map f) (by simpa using hs)
state_before: R : Type u
ι : Type w
s✝ : Finset ι
inst✝ : CommRing R
s : Finset ι
f : ι → R
hs : 0 < Finset.card s
⊢ coeff (∏ i in s, (X - ↑C (f i))) (Finset.card s - 1) = -∑ i in s, f i

tactic: simpa using hs
state_before: R : Type u
ι : Type w
s✝ : Finset ι
inst✝ : CommRing R
s : Finset ι
f : ι → R
hs : 0 < Finset.card s
⊢ 0 < ↑Multiset.card (Multiset.map f s.val)
Theorem: Submonoid.eq_bot_iff_forall
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simp (config := { contextual := true }) [iff_def, S.one_mem]
state_before: M : Type u_1
N : Type ?u.160395
P : Type ?u.160398
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.160419
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ (∀ (x : M), x ∈ S ↔ x ∈ ⊥) ↔ ∀ (x : M), x ∈ S → x = 1
Theorem: Sum.map_surjective
File: Mathlib/Data/Sum/Basic.lean

tactic: obtain ⟨a | b, h⟩ := h (inl c)
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_2
δ : Type u_1
f : α → γ
g : β → δ
h : Surjective (Sum.map f g)
c : γ
⊢ ∃ a, f a = c

tactic: exact ⟨a, inl_injective h⟩
state_before: case intro.inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_2
δ : Type u_1
f : α → γ
g : β → δ
h✝ : Surjective (Sum.map f g)
c : γ
a : α
h : Sum.map f g (inl a) = inl c
⊢ ∃ a, f a = c

tactic: cases h
state_before: case intro.inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_2
δ : Type u_1
f : α → γ
g : β → δ
h✝ : Surjective (Sum.map f g)
c : γ
b : β
h : Sum.map f g (inr b) = inl c
⊢ ∃ a, f a = c

tactic: obtain ⟨a | b, h⟩ := h (inr d)
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_2
δ : Type u_1
f : α → γ
g : β → δ
h : Surjective (Sum.map f g)
d : δ
⊢ ∃ a, g a = d

tactic: cases h
state_before: case intro.inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_2
δ : Type u_1
f : α → γ
g : β → δ
h✝ : Surjective (Sum.map f g)
d : δ
a : α
h : Sum.map f g (inl a) = inr d
⊢ ∃ a, g a = d

tactic: exact ⟨b, inr_injective h⟩
state_before: case intro.inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_2
δ : Type u_1
f : α → γ
g : β → δ
h✝ : Surjective (Sum.map f g)
d : δ
b : β
h : Sum.map f g (inr b) = inr d
⊢ ∃ a, g a = d
Theorem: IsUnit.div
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [div_eq_mul_inv]
state_before: F : Type ?u.56333
G : Type ?u.56336
α : Type u_1
M : Type ?u.56342
N : Type ?u.56345
inst✝ : DivisionMonoid α
a b c : α
ha : IsUnit a
hb : IsUnit b
⊢ IsUnit (a / b)

tactic: exact ha.mul hb.inv
state_before: F : Type ?u.56333
G : Type ?u.56336
α : Type u_1
M : Type ?u.56342
N : Type ?u.56345
inst✝ : DivisionMonoid α
a b c : α
ha : IsUnit a
hb : IsUnit b
⊢ IsUnit (a * b⁻¹)
Theorem: tsub_add_cancel_iff_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_comm]
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ b - a + a = b ↔ a ≤ b

tactic: exact add_tsub_cancel_iff_le
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a + (b - a) = b ↔ a ≤ b
Theorem: LaurentPolynomial.exists_T_pow
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: refine f.induction_on' ?_ fun n a => ?_ <;> clear f
state_before: R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
⊢ ∃ n f', ↑toLaurent f' = f * T ↑n

tactic: rintro f g ⟨m, fn, hf⟩ ⟨n, gn, hg⟩
state_before: case refine_1
R : Type u_1
inst✝ : Semiring R
⊢ ∀ (p q : R[T;T⁻¹]),
    (∃ n f', ↑toLaurent f' = p * T ↑n) → (∃ n f', ↑toLaurent f' = q * T ↑n) → ∃ n f', ↑toLaurent f' = (p + q) * T ↑n

tactic: refine' ⟨m + n, fn * X ^ n + gn * X ^ m, _⟩
state_before: case refine_1.intro.intro.intro.intro
R : Type u_1
inst✝ : Semiring R
f g : R[T;T⁻¹]
m : ℕ
fn : R[X]
hf : ↑toLaurent fn = f * T ↑m
n : ℕ
gn : R[X]
hg : ↑toLaurent gn = g * T ↑n
⊢ ∃ n f', ↑toLaurent f' = (f + g) * T ↑n

tactic: simp only [hf, hg, add_mul, add_comm (n : ℤ), map_add, map_mul, Polynomial.toLaurent_X_pow,
  mul_T_assoc, Int.ofNat_add]
state_before: case refine_1.intro.intro.intro.intro
R : Type u_1
inst✝ : Semiring R
f g : R[T;T⁻¹]
m : ℕ
fn : R[X]
hf : ↑toLaurent fn = f * T ↑m
n : ℕ
gn : R[X]
hg : ↑toLaurent gn = g * T ↑n
⊢ ↑toLaurent (fn * X ^ n + gn * X ^ m) = (f + g) * T ↑(m + n)

tactic: cases' n with n n
state_before: case refine_2
R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
⊢ ∃ n_1 f', ↑toLaurent f' = ↑C a * T n * T ↑n_1

tactic: exact ⟨0, Polynomial.C a * X ^ n, by simp⟩
state_before: case refine_2.ofNat
R : Type u_1
inst✝ : Semiring R
a : R
n : ℕ
⊢ ∃ n_1 f', ↑toLaurent f' = ↑C a * T (Int.ofNat n) * T ↑n_1

tactic: simp
state_before: R : Type u_1
inst✝ : Semiring R
a : R
n : ℕ
⊢ ↑toLaurent (↑Polynomial.C a * X ^ n) = ↑C a * T (Int.ofNat n) * T ↑0

tactic: refine' ⟨n + 1, Polynomial.C a, _⟩
state_before: case refine_2.negSucc
R : Type u_1
inst✝ : Semiring R
a : R
n : ℕ
⊢ ∃ n_1 f', ↑toLaurent f' = ↑C a * T (Int.negSucc n) * T ↑n_1

tactic: simp only [Int.negSucc_eq, Polynomial.toLaurent_C, Int.ofNat_succ, mul_T_assoc, add_left_neg,
  T_zero, mul_one]
state_before: case refine_2.negSucc
R : Type u_1
inst✝ : Semiring R
a : R
n : ℕ
⊢ ↑toLaurent (↑Polynomial.C a) = ↑C a * T (Int.negSucc n) * T ↑(n + 1)
Theorem: one_div_ne_zero
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: simpa only [one_div] using inv_ne_zero h
state_before: α : Type ?u.27916
M₀ : Type ?u.27919
G₀ : Type u_1
M₀' : Type ?u.27925
G₀' : Type ?u.27928
F : Type ?u.27931
F' : Type ?u.27934
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
h : a ≠ 0
⊢ 1 / a ≠ 0
Theorem: Nat.filter_coprime_Ico_eq_totient
File: Mathlib/Data/Nat/Totient.lean

tactic: rw [totient, filter_Ico_card_eq_of_periodic, count_eq_card_filter_range]
state_before: a n : ℕ
⊢ card (filter (coprime a) (Ico n (n + a))) = φ a

tactic: exact periodic_coprime a
state_before: case pp
a n : ℕ
⊢ Function.Periodic (coprime a) a
Theorem: Filter.biInter_mem
File: Mathlib/Order/Filter/Basic.lean

tactic: simp
state_before: α : Type u
f g : Filter α
s✝ t : Set α
β : Type v
s : β → Set α
is : Set β
hf : Set.Finite is
⊢ (⋂ (i : β) (_ : i ∈ ∅), s i) ∈ f ↔ ∀ (i : β), i ∈ ∅ → s i ∈ f

tactic: simp [hs]
state_before: α : Type u
f g : Filter α
s✝¹ t : Set α
β : Type v
s : β → Set α
is : Set β
hf : Set.Finite is
a✝ : β
s✝ : Set β
x✝¹ : ¬a✝ ∈ s✝
x✝ : Set.Finite s✝
hs : (⋂ (i : β) (_ : i ∈ s✝), s i) ∈ f ↔ ∀ (i : β), i ∈ s✝ → s i ∈ f
⊢ (⋂ (i : β) (_ : i ∈ insert a✝ s✝), s i) ∈ f ↔ ∀ (i : β), i ∈ insert a✝ s✝ → s i ∈ f
Theorem: Matrix.toLinearMapRight'_one
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: ext
state_before: R : Type u_1
inst✝² : Semiring R
l : Type ?u.170495
m : Type u_2
n : Type ?u.170501
inst✝¹ : Fintype m
inst✝ : DecidableEq m
⊢ ↑toLinearMapRight' 1 = LinearMap.id

tactic: simp [LinearMap.one_apply, stdBasis_apply]
state_before: case h.h.h
R : Type u_1
inst✝² : Semiring R
l : Type ?u.170495
m : Type u_2
n : Type ?u.170501
inst✝¹ : Fintype m
inst✝ : DecidableEq m
i✝ x✝ : m
⊢ ↑(comp (↑toLinearMapRight' 1) (single i✝)) 1 x✝ = ↑(comp LinearMap.id (single i✝)) 1 x✝
Theorem: exists_measurable_piecewise_nat
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: simp only [h.inter_eq, eqOn_empty]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.100202
δ : Type ?u.100205
δ' : Type ?u.100208
ι : Sort uι
s t✝ u : Set α
m✝ : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
m : MeasurableSpace α
t : ℕ → Set β
t_meas : ∀ (n : ℕ), MeasurableSet (t n)
t_disj : Pairwise (Disjoint on t)
g : ℕ → β → α
hg : ∀ (n : ℕ), Measurable (g n)
i j : ℕ
h : (Disjoint on t) i j
⊢ EqOn (g i) (g j) (t i ∩ t j)
Theorem: ball_mul_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [mul_comm, singleton_mul_ball, mul_comm y]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball x δ * {y} = ball (x * y) δ
Theorem: nhdsSet_diagonal_eq_uniformity
File: Mathlib/Topology/UniformSpace/Compact.lean

tactic: refine' nhdsSet_diagonal_le_uniformity.antisymm _
state_before: α : Type u_1
β : Type ?u.20
γ : Type ?u.23
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompactSpace α
⊢ 𝓝ˢ (diagonal α) = 𝓤 α

tactic: have :
  (𝓤 (α × α)).HasBasis (fun U => U ∈ 𝓤 α) fun U =>
    (fun p : (α × α) × α × α => ((p.1.1, p.2.1), p.1.2, p.2.2)) ⁻¹' U ×ˢ U := by
  rw [uniformity_prod_eq_comap_prod]
  exact (𝓤 α).basis_sets.prod_self.comap _
state_before: α : Type u_1
β : Type ?u.20
γ : Type ?u.23
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompactSpace α
⊢ 𝓤 α ≤ 𝓝ˢ (diagonal α)

tactic: refine' (isCompact_diagonal.nhdsSet_basis_uniformity this).ge_iff.2 fun U hU => _
state_before: α : Type u_1
β : Type ?u.20
γ : Type ?u.23
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompactSpace α
this :
  HasBasis (𝓤 (α × α)) (fun U => U ∈ 𝓤 α) fun U => (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ⁻¹' U ×ˢ U
⊢ 𝓤 α ≤ 𝓝ˢ (diagonal α)

tactic: exact mem_of_superset hU fun ⟨x, y⟩ hxy => mem_iUnion₂.2
  ⟨(x, x), rfl, refl_mem_uniformity hU, hxy⟩
state_before: α : Type u_1
β : Type ?u.20
γ : Type ?u.23
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompactSpace α
this :
  HasBasis (𝓤 (α × α)) (fun U => U ∈ 𝓤 α) fun U => (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ⁻¹' U ×ˢ U
U : Set (α × α)
hU : U ∈ 𝓤 α
⊢ (⋃ (x : α × α) (_ : x ∈ diagonal α), ball x ((fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ⁻¹' U ×ˢ U)) ∈
    𝓤 α

tactic: rw [uniformity_prod_eq_comap_prod]
state_before: α : Type u_1
β : Type ?u.20
γ : Type ?u.23
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompactSpace α
⊢ HasBasis (𝓤 (α × α)) (fun U => U ∈ 𝓤 α) fun U => (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ⁻¹' U ×ˢ U

tactic: exact (𝓤 α).basis_sets.prod_self.comap _
state_before: α : Type u_1
β : Type ?u.20
γ : Type ?u.23
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompactSpace α
⊢ HasBasis (Filter.comap (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) (𝓤 α ×ˢ 𝓤 α)) (fun U => U ∈ 𝓤 α)
    fun U => (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ⁻¹' U ×ˢ U
Theorem: CategoryTheory.CommSq.left_adjoint
File: Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean

tactic: simp only [Adjunction.homEquiv_counit, assoc, ← G.map_comp_assoc, ← sq.w]
state_before: C : Type u_4
D : Type u_1
inst✝¹ : Category C
inst✝ : Category D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ ↑(Adjunction.homEquiv adj A X).symm u ≫ p = G.map i ≫ ↑(Adjunction.homEquiv adj B Y).symm v

tactic: rw [G.map_comp, assoc, Adjunction.counit_naturality]
state_before: C : Type u_4
D : Type u_1
inst✝¹ : Category C
inst✝ : Category D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ G.map u ≫ adj.counit.app X ≫ p = G.map (u ≫ F.map p) ≫ adj.counit.app Y
Theorem: InnerProductGeometry.inner_eq_neg_mul_norm_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: simp [← cos_angle_mul_norm_mul_norm, h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
h : angle x y = π
⊢ inner x y = -(‖x‖ * ‖y‖)
Theorem: ContinuousLinearMap.fderivWithin
File: Mathlib/Analysis/Calculus/FDeriv/Linear.lean

tactic: rw [DifferentiableAt.fderivWithin e.differentiableAt hxs]
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.38206
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.38301
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
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderivWithin 𝕜 (↑e) s x = e

tactic: exact e.fderiv
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.38206
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.38301
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
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderiv 𝕜 (↑e) x = e
Theorem: WType.cardinal_mk_eq_sum
File: Mathlib/Data/W/Cardinal.lean

tactic: simp only [Cardinal.power_def, ← Cardinal.mk_sigma]
state_before: α : Type u
β : α → Type u
⊢ (#WType β) = sum fun a => (#WType β) ^ (#β a)

tactic: exact mk_congr (equivSigma β)
state_before: α : Type u
β : α → Type u
⊢ (#WType β) = (#(i : α) × (β i → WType β))
Theorem: bit0_mul
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: dsimp [bit0]
state_before: α : Type ?u.268299
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : NonUnitalNonAssocRing R
n r : R
⊢ bit0 n * r = 2 • (n * r)

tactic: rw [add_mul, ← one_add_one_eq_two, add_zsmul, one_zsmul]
state_before: α : Type ?u.268299
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : NonUnitalNonAssocRing R
n r : R
⊢ (n + n) * r = 2 • (n * r)
Theorem: Nat.binomial_eq
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: simp [multinomial, Finset.sum_pair h, Finset.prod_pair h]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
h : a ≠ b
⊢ multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!)