tasksource/leandojo huggingface dataset:
Theorem: List.count_erase_self
File: Mathlib/Data/List/Count.lean

tactic: rw [count_erase, if_pos rfl]
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a : α
l : List α
⊢ count a (List.erase l a) = count a l - 1
Theorem: Matrix.tail_cons
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext
state_before: α : Type u
m n o : ℕ
m' : Type ?u.14819
n' : Type ?u.14822
o' : Type ?u.14825
x : α
u : Fin m → α
⊢ vecTail (vecCons x u) = u

tactic: simp [vecTail]
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.14819
n' : Type ?u.14822
o' : Type ?u.14825
x : α
u : Fin m → α
x✝ : Fin m
⊢ vecTail (vecCons x u) x✝ = u x✝
Theorem: Ordinal.nadd_le_nadd_left
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rcases lt_or_eq_of_le h with (h | rfl)
state_before: a✝ b c : Ordinal
h : b ≤ c
a : Ordinal
⊢ a ♯ b ≤ a ♯ c

tactic: exact (nadd_lt_nadd_left h a).le
state_before: case inl
a✝ b c : Ordinal
h✝ : b ≤ c
a : Ordinal
h : b < c
⊢ a ♯ b ≤ a ♯ c

tactic: exact le_rfl
state_before: case inr
a✝ b a : Ordinal
h : b ≤ b
⊢ a ♯ b ≤ a ♯ b
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
⊢ neLocus (f + g) f = support g
Theorem: Ordinal.type_def
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rfl
state_before: α : Type u_1
β : Type ?u.23200
γ : Type ?u.23203
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
wo : IsWellOrder α r
⊢ Quotient.mk isEquivalent { α := α, r := r, wo := wo } = type r
Theorem: UniformContinuous.pow_const
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: simp_rw [pow_zero]
state_before: α : Type u_2
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
⊢ UniformContinuous fun x => f x ^ 0

tactic: exact uniformContinuous_const
state_before: α : Type u_2
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
⊢ UniformContinuous fun x => 1

tactic: simp_rw [pow_succ]
state_before: α : Type u_2
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ (n + 1)

tactic: exact hf.mul (hf.pow_const n)
state_before: α : Type u_2
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x * f x ^ n
Theorem: Set.image_const_add_Icc
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: simp only [add_comm a, image_add_const_Icc]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Icc b c = Icc (a + b) (a + c)
Theorem: Stream'.cycle_eq
File: Mathlib/Data/Stream/Init.lean

tactic: intro l'
state_before: α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
⊢ ∀ (l' : List α) (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l', a, l) = a' :: l' ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)

tactic: induction' l' with a₁ l₁ ih
state_before: α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
l' : List α
⊢ ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l', a, l) = a' :: l' ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)

tactic: intros
state_before: case nil
α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
⊢ ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', [], a, l) = [a'] ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)

tactic: rw [corec_eq]
state_before: case nil
α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
a'✝ : α
⊢ corec Stream'.cycleF Stream'.cycleG (a'✝, [], a, l) = [a'✝] ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)

tactic: rfl
state_before: case nil
α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
a'✝ : α
⊢ Stream'.cycleF (a'✝, [], a, l) :: corec Stream'.cycleF Stream'.cycleG (Stream'.cycleG (a'✝, [], a, l)) =
    [a'✝] ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)

tactic: intros
state_before: case cons
α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
a₁ : α
l₁ : List α
ih :
  ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l₁, a, l) = a' :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
⊢ ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', a₁ :: l₁, a, l) =
      a' :: a₁ :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)

tactic: rw [corec_eq, Stream'.cycle_g_cons, ih a₁]
state_before: case cons
α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
a₁ : α
l₁ : List α
ih :
  ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l₁, a, l) = a' :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
a'✝ : α
⊢ corec Stream'.cycleF Stream'.cycleG (a'✝, a₁ :: l₁, a, l) =
    a'✝ :: a₁ :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)

tactic: rfl
state_before: case cons
α : Type u
β : Type v
δ : Type w
a : α
l : List α
x✝ : a :: l ≠ []
a₁ : α
l₁ : List α
ih :
  ∀ (a' : α),
    corec Stream'.cycleF Stream'.cycleG (a', l₁, a, l) = a' :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
a'✝ : α
⊢ Stream'.cycleF (a'✝, a₁ :: l₁, a, l) :: (a₁ :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)) =
    a'✝ :: a₁ :: l₁ ++ₛ corec Stream'.cycleF Stream'.cycleG (a, l, a, l)
Theorem: CategoryTheory.obj_ε_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: refine' Eq.trans _ (Category.id_comp _)
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) = (F.map (λ_ n).inv).app X ≫ (MonoidalFunctor.μIso F (𝟙_ M) n).inv.app X

tactic: rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) ≫ (F.map (λ_ n).inv).app X ≫ (MonoidalFunctor.μIso F (𝟙_ M) n).inv.app X

tactic: convert left_unitality_app F n X
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) ≫ inv ((MonoidalFunctor.μIso F (𝟙_ M) n).inv.app X) ≫ inv ((F.map (λ_ n).inv).app X) =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))

tactic: simp
state_before: case h.e'_2.h.h.e'_7.h.h.e'_6
C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
e_1✝ :
  ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) =
    ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj X)
e_5✝ : (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) = (F.obj n).obj X
⊢ inv ((MonoidalFunctor.μIso F (𝟙_ M) n).inv.app X) = (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X

tactic: simp
state_before: case h.e'_2.h.h.e'_7.h.h.e'_7.h
C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
e_1✝ :
  ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) =
    ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj X)
e_5✝¹ e_5✝ : (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) = (F.obj n).obj X
⊢ inv ((F.map (λ_ n).inv).app X) = (F.map (λ_ n).hom).app X
Theorem: uniqueDiffWithinAt_of_mem_nhds
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: simpa only [univ_inter] using uniqueDiffWithinAt_univ.inter h
state_before: 𝕜 : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.123068
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.123158
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
h : s ∈ 𝓝 x
⊢ UniqueDiffWithinAt 𝕜 s x
Theorem: Cardinal.mk_compl_eq_mk_compl_finite
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [← lift_inj.{u, max u v}]
state_before: α β : Type u
inst✝ : Finite α
s : Set α
t : Set β
h1 : (#α) = (#β)
h : (#↑s) = (#↑t)
⊢ (#↑(sᶜ)) = (#↑(tᶜ))

tactic: apply mk_compl_eq_mk_compl_finite_lift.{u, u, max u v}
<;> rwa [lift_inj]
state_before: α β : Type u
inst✝ : Finite α
s : Set α
t : Set β
h1 : (#α) = (#β)
h : (#↑s) = (#↑t)
⊢ lift (#↑(sᶜ)) = lift (#↑(tᶜ))
Theorem: List.pairwise_bind
File: Mathlib/Data/List/Pairwise.lean

tactic: simp [List.bind, List.pairwise_join, List.mem_map, List.pairwise_map]
state_before: α : Type u_1
β : Type u_2
R✝ S T : α → α → Prop
a : α
l✝ : List α
R : β → β → Prop
l : List α
f : α → List β
⊢ Pairwise R (List.bind l f) ↔
    (∀ (a : α), a ∈ l → Pairwise R (f a)) ∧ Pairwise (fun a₁ a₂ => ∀ (x : β), x ∈ f a₁ → ∀ (y : β), y ∈ f a₂ → R x y) l
Theorem: Set.star_mul
File: Mathlib/Algebra/Star/Pointwise.lean

tactic: simp_rw [← image_star, ← image2_mul, image_image2, image2_image_left, image2_image_right,
  star_mul, image2_swap _ s t]
state_before: α : Type u_1
s✝ t✝ : Set α
a : α
inst✝¹ : Monoid α
inst✝ : StarSemigroup α
s t : Set α
⊢ (s * t)⋆ = t⋆ * s⋆
Theorem: Set.preimage_eq_iff_eq_image
File: Mathlib/Data/Set/Image.lean

tactic: rw [← image_eq_image hf.1, hf.2.image_preimage]
state_before: α : Type u
β : Type v
f✝ f : α → β
hf : Bijective f
s : Set β
t : Set α
⊢ f ⁻¹' s = t ↔ s = f '' t
Theorem: Fin.prod_Ioi_succ
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [Ioi_succ, Finset.prod_map, RelEmbedding.coe_toEmbedding, val_succEmbedding]
state_before: α : Type ?u.64433
β : Type ?u.64436
M : Type u_1
inst✝ : CommMonoid M
n : ℕ
i : Fin n
v : Fin (Nat.succ n) → M
⊢ ∏ j in Ioi (succ i), v j = ∏ j in Ioi i, v (succ j)
Theorem: abs_norm_sub_norm_le'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa [dist_eq_norm_div] using abs_dist_sub_le a b 1
state_before: 𝓕 : Type ?u.82498
𝕜 : Type ?u.82501
α : Type ?u.82504
ι : Type ?u.82507
κ : Type ?u.82510
E : Type u_1
F : Type ?u.82516
G : Type ?u.82519
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ abs (‖a‖ - ‖b‖) ≤ ‖a / b‖
Theorem: Polynomial.degree_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [degree, ← monomial_zero_left, support_monomial 0 ha, max_eq_sup_coe, sup_singleton,
  WithBot.coe_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a ≠ 0
⊢ degree (↑C a) = 0
Theorem: Ordinal.le_enum_succ
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [type_lt]
state_before: α : Type ?u.196040
β : Type ?u.196043
γ : Type ?u.196046
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
a : (Quotient.out (succ o)).α
⊢ o < type fun x x_1 => x < x_1

tactic: exact lt_succ o
state_before: α : Type ?u.196040
β : Type ?u.196043
γ : Type ?u.196046
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
a : (Quotient.out (succ o)).α
⊢ o < succ o

tactic: apply typein_lt_self
state_before: α : Type ?u.196040
β : Type ?u.196043
γ : Type ?u.196046
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
a : (Quotient.out (succ o)).α
⊢ typein (fun x x_1 => x < x_1) a < succ o
Theorem: Int.natAbs_lt_iff_sq_lt
File: Mathlib/Data/Int/Lemmas.lean

tactic: rw [sq, sq]
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ natAbs a < natAbs b ↔ a ^ 2 < b ^ 2

tactic: exact natAbs_lt_iff_mul_self_lt
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ natAbs a < natAbs b ↔ a * a < b * b
Theorem: OneOneReducible.trans
File: Mathlib/Computability/Reduce.lean

tactic: erw [← h₂, ← h₁]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable γ
p : α → Prop
q : β → Prop
r : γ → Prop
f : α → β
c₁ : Computable f
i₁ : Injective f
h₁ : ∀ (a : α), p a ↔ q (f a)
g : β → γ
c₂ : Computable g
i₂ : Injective g
h₂ : ∀ (a : β), q a ↔ r (g a)
a : α
h : p a
⊢ r ((g ∘ f) a)

tactic: assumption
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable γ
p : α → Prop
q : β → Prop
r : γ → Prop
f : α → β
c₁ : Computable f
i₁ : Injective f
h₁ : ∀ (a : α), p a ↔ q (f a)
g : β → γ
c₂ : Computable g
i₂ : Injective g
h₂ : ∀ (a : β), q a ↔ r (g a)
a : α
h : p a
⊢ p a

tactic: rwa [h₁, h₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable γ
p : α → Prop
q : β → Prop
r : γ → Prop
f : α → β
c₁ : Computable f
i₁ : Injective f
h₁ : ∀ (a : α), p a ↔ q (f a)
g : β → γ
c₂ : Computable g
i₂ : Injective g
h₂ : ∀ (a : β), q a ↔ r (g a)
a : α
h : r ((g ∘ f) a)
⊢ p a
Theorem: Finset.inter_singleton_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [inter_comm, singleton_inter_of_not_mem h]
state_before: α : Type u_1
β : Type ?u.188434
γ : Type ?u.188437
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a✝ b a : α
s : Finset α
h : ¬a ∈ s
⊢ s ∩ {a} = ∅
Theorem: SubMulAction.neg_mem_iff
File: Mathlib/GroupTheory/GroupAction/SubMulAction.lean

tactic: rw [← neg_neg x]
state_before: S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : SubMulAction R M
r : R
x y : M
h : -x ∈ p
⊢ x ∈ p

tactic: exact neg_mem _ h
state_before: S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : SubMulAction R M
r : R
x y : M
h : -x ∈ p
⊢ - -x ∈ p
Theorem: Basis.repr_range
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rw [LinearEquiv.range, Finsupp.supported_univ]
state_before: ι : Type u_1
ι' : Type ?u.55731
R : Type u_2
R₂ : Type ?u.55737
K : Type ?u.55740
M : Type u_3
M' : Type ?u.55746
M'' : Type ?u.55749
V : Type u
V' : Type ?u.55754
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
⊢ LinearMap.range ↑b.repr = Finsupp.supported R R univ
Theorem: Polynomial.natTrailingDegree_le_natTrailingDegree
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hq : q ≠ 0
hpq : trailingDegree p ≤ trailingDegree q
⊢ natTrailingDegree p ≤ natTrailingDegree q

tactic: rw [trailingDegree_eq_natTrailingDegree hp, trailingDegree_eq_natTrailingDegree hq] at hpq
state_before: case neg
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hq : q ≠ 0
hpq : trailingDegree p ≤ trailingDegree q
hp : ¬p = 0
⊢ natTrailingDegree p ≤ natTrailingDegree q

tactic: exact WithTop.coe_le_coe.1 hpq
state_before: case neg
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hq : q ≠ 0
hpq : ↑(natTrailingDegree p) ≤ ↑(natTrailingDegree q)
hp : ¬p = 0
⊢ natTrailingDegree p ≤ natTrailingDegree q

tactic: rw [hp, natTrailingDegree_zero]
state_before: case pos
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hq : q ≠ 0
hpq : trailingDegree p ≤ trailingDegree q
hp : p = 0
⊢ natTrailingDegree p ≤ natTrailingDegree q

tactic: exact zero_le _
state_before: case pos
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hq : q ≠ 0
hpq : trailingDegree p ≤ trailingDegree q
hp : p = 0
⊢ 0 ≤ natTrailingDegree q
Theorem: IsCoprime.of_isCoprime_of_dvd_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: obtain ⟨d, rfl⟩ := hdvd
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime y z
hdvd : x ∣ y
⊢ IsCoprime x z

tactic: exact IsCoprime.of_mul_left_left h
state_before: case intro
R : Type u
inst✝ : CommSemiring R
x z d : R
h : IsCoprime (x * d) z
⊢ IsCoprime x z
Theorem: Qpf.Fix.ind_aux
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: have : Fix.mk (abs ⟨a, fun x => ⟦f x⟧⟩) = ⟦Wrepr ⟨a, f⟩⟧ := by
  apply Quot.sound; apply Wequiv.abs'
  rw [PFunctor.W.dest_mk, abs_map, abs_repr, ← abs_map, PFunctor.map_eq]
  conv =>
    rhs
    simp only [Wrepr, recF_eq, PFunctor.W.dest_mk, abs_repr, Function.comp]
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
⊢ mk (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) }) = Quotient.mk Wsetoid (WType.mk a f)

tactic: rw [this]
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
this : mk (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) }) = Quotient.mk Wsetoid (Wrepr (WType.mk a f))
⊢ mk (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) }) = Quotient.mk Wsetoid (WType.mk a f)

tactic: apply Quot.sound
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
this : mk (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) }) = Quotient.mk Wsetoid (Wrepr (WType.mk a f))
⊢ Quotient.mk Wsetoid (Wrepr (WType.mk a f)) = Quotient.mk Wsetoid (WType.mk a f)

tactic: apply Wrepr_equiv
state_before: case a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
this : mk (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) }) = Quotient.mk Wsetoid (Wrepr (WType.mk a f))
⊢ Setoid.r (Wrepr (WType.mk a f)) (WType.mk a f)

tactic: apply Quot.sound
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
⊢ mk (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) }) = Quotient.mk Wsetoid (Wrepr (WType.mk a f))

tactic: apply Wequiv.abs'
state_before: case a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
⊢ Setoid.r (PFunctor.W.mk (fixToW <$> repr (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) })))
    (Wrepr (WType.mk a f))

tactic: rw [PFunctor.W.dest_mk, abs_map, abs_repr, ← abs_map, PFunctor.map_eq]
state_before: case a.h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
⊢ abs
      (PFunctor.W.dest
        (PFunctor.W.mk (fixToW <$> repr (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) })))) =
    abs (PFunctor.W.dest (Wrepr (WType.mk a f)))

tactic: conv =>
  rhs
  simp only [Wrepr, recF_eq, PFunctor.W.dest_mk, abs_repr, Function.comp]
state_before: case a.h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
⊢ abs { fst := a, snd := fixToW ∘ fun x => Quotient.mk Wsetoid (f x) } = abs (PFunctor.W.dest (Wrepr (WType.mk a f)))
Theorem: MeasureTheory.VectorMeasure.restrict_apply
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [restrict, dif_pos hi]
state_before: α : Type u_1
β : Type ?u.472690
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
⊢ ↑(restrict v i) j = ↑v (j ∩ i)

tactic: exact if_pos hj
state_before: α : Type u_1
β : Type ?u.472690
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
⊢ ↑{ measureOf' := fun s => if MeasurableSet s then ↑v (s ∩ i) else 0,
          empty' := (_ : (if MeasurableSet ∅ then ↑v (∅ ∩ i) else 0) = 0),
          not_measurable' :=
            (_ : ∀ (i_1 : Set α), ¬MeasurableSet i_1 → (if MeasurableSet i_1 then ↑v (i_1 ∩ i) else 0) = 0),
          m_iUnion' :=
            (_ :
              ∀ ⦃f : ℕ → Set α⦄,
                (∀ (i : ℕ), MeasurableSet (f i)) →
                  Pairwise (Disjoint on f) →
                    HasSum (fun i_1 => (fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) (f i_1))
                      ((fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) (⋃ (i : ℕ), f i))) }
      j =
    ↑v (j ∩ i)
Theorem: Real.sin_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [two_mul, sin_add]
state_before: ⊢ sin (2 * π) = 0
Theorem: Algebra.FinitePresentation.trans
File: Mathlib/RingTheory/FinitePresentation.lean

tactic: obtain ⟨n, I, e, hfg⟩ := iff.1 hfpB
state_before: R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Algebra R A
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
hfpA : FinitePresentation R A
hfpB : FinitePresentation A B
⊢ FinitePresentation R B

tactic: exact equiv ((mvPolynomial_of_finitePresentation hfpA _).quotient hfg) (e.restrictScalars R)
state_before: case intro.intro.intro
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Algebra R A
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
hfpA : FinitePresentation R A
hfpB : FinitePresentation A B
n : ℕ
I : Ideal (MvPolynomial (Fin n) A)
e : (MvPolynomial (Fin n) A ⧸ I) ≃ₐ[A] B
hfg : Ideal.FG I
⊢ FinitePresentation R B
Theorem: LieSubmodule.top_lie_le_iff_le_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: rw [lie_le_iff]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type ?u.23856
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ N' : LieSubmodule R L M
⊢ ⁅⊤, N⁆ ≤ N' ↔ N ≤ normalizer N'

tactic: tauto
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type ?u.23856
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ N' : LieSubmodule R L M
⊢ (∀ (x : L), x ∈ ⊤ → ∀ (m : M), m ∈ N → ⁅x, m⁆ ∈ N') ↔ N ≤ normalizer N'
Theorem: Matrix.cramer_is_linear
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: constructor <;> intros <;> ext i
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
⊢ IsLinearMap α (cramerMap A)

tactic: apply (cramerMap_is_linear A i).1
state_before: case map_add.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b x✝ y✝ : n → α
i : n
⊢ cramerMap A (x✝ + y✝) i = (cramerMap A x✝ + cramerMap A y✝) i

tactic: apply (cramerMap_is_linear A i).2
state_before: case map_smul.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
c✝ : α
x✝ : n → α
i : n
⊢ cramerMap A (c✝ • x✝) i = (c✝ • cramerMap A x✝) i
Theorem: Complex.IsExpCmpFilter.isLittleO_exp_cpow
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: simpa using hl.isLittleO_cpow_mul_exp hb 0 a
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : b < 0
⊢ (fun z => exp (↑b * z)) =o[l] fun z => z ^ a
Theorem: MulChar.ext_iff
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: rintro rfl a
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ χ' : MulChar R R'
⊢ χ = χ' → ∀ (a : Rˣ), ↑χ ↑a = ↑χ' ↑a

tactic: rfl
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
a : Rˣ
⊢ ↑χ ↑a = ↑χ ↑a
Theorem: Nat.minFac_lemma
File: Mathlib/Data/Nat/Prime.lean

tactic: decide
state_before: n k : ℕ
h : ¬n < k * k
⊢ 0 < 2