tasksource/leandojo huggingface dataset:
Theorem: Polynomial.count_map_roots
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [le_rootMultiplicity_iff hmap, ← Multiset.prod_replicate, ←
  Multiset.map_replicate fun a => X - C a]
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hmap : map f p ≠ 0
b : B
⊢ Multiset.count b (Multiset.map (↑f) (roots p)) ≤ rootMultiplicity b (map f p)

tactic: rw [← Multiset.filter_eq]
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hmap : map f p ≠ 0
b : B
⊢ Multiset.prod
      (Multiset.map (fun a => X - ↑C a) (Multiset.replicate (Multiset.count b (Multiset.map (↑f) (roots p))) b)) ∣
    map f p

tactic: refine
  (Multiset.prod_dvd_prod_of_le <| Multiset.map_le_map <| Multiset.filter_le (Eq b) _).trans ?_
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hmap : map f p ≠ 0
b : B
⊢ Multiset.prod (Multiset.map (fun a => X - ↑C a) (Multiset.filter (Eq b) (Multiset.map (↑f) (roots p)))) ∣ map f p

tactic: convert Polynomial.map_dvd f p.prod_multiset_X_sub_C_dvd
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hmap : map f p ≠ 0
b : B
⊢ Multiset.prod (Multiset.map (fun a => X - ↑C a) (Multiset.map (↑f) (roots p))) ∣ map f p

tactic: simp only [Polynomial.map_multiset_prod, Multiset.map_map]
state_before: case h.e'_3
R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hmap : map f p ≠ 0
b : B
⊢ Multiset.prod (Multiset.map (fun a => X - ↑C a) (Multiset.map (↑f) (roots p))) =
    map f (Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p)))

tactic: congr
state_before: case h.e'_3
R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hmap : map f p ≠ 0
b : B
⊢ Multiset.prod (Multiset.map ((fun x => X - ↑C x) ∘ fun x => ↑f x) (roots p)) =
    Multiset.prod (Multiset.map (map f ∘ fun x => X - ↑C x) (roots p))

tactic: ext1
state_before: case h.e'_3.e_a.e_f
R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hmap : map f p ≠ 0
b : B
⊢ ((fun x => X - ↑C x) ∘ fun x => ↑f x) = map f ∘ fun x => X - ↑C x

tactic: simp only [Function.comp_apply, Polynomial.map_sub, map_X, map_C]
state_before: case h.e'_3.e_a.e_f.h
R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hmap : map f p ≠ 0
b : B
x✝ : A
⊢ ((fun x => X - ↑C x) ∘ fun x => ↑f x) x✝ = (map f ∘ fun x => X - ↑C x) x✝
Theorem: ContinuousLinearMap.compContinuousMultilinearMap_coe
File: Mathlib/Topology/Algebra/Module/Multilinear.lean

tactic: ext m
state_before: R : Type u
ι : Type v
n : ℕ
M : Fin (Nat.succ n) → Type w
M₁ : ι → Type w₁
M₁' : ι → Type w₁'
M₂ : Type w₂
M₃ : Type w₃
M₄ : Type w₄
inst✝¹⁸ : Semiring R
inst✝¹⁷ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝¹⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝¹⁵ : (i : ι) → AddCommMonoid (M₁' i)
inst✝¹⁴ : AddCommMonoid M₂
inst✝¹³ : AddCommMonoid M₃
inst✝¹² : AddCommMonoid M₄
inst✝¹¹ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹⁰ : (i : ι) → Module R (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁' i)
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M₃
inst✝⁶ : Module R M₄
inst✝⁵ : (i : Fin (Nat.succ n)) → TopologicalSpace (M i)
inst✝⁴ : (i : ι) → TopologicalSpace (M₁ i)
inst✝³ : (i : ι) → TopologicalSpace (M₁' i)
inst✝² : TopologicalSpace M₂
inst✝¹ : TopologicalSpace M₃
inst✝ : TopologicalSpace M₄
f✝ f' : ContinuousMultilinearMap R M₁ M₂
g : M₂ →L[R] M₃
f : ContinuousMultilinearMap R M₁ M₂
⊢ ↑(ContinuousLinearMap.compContinuousMultilinearMap g f) = ↑g ∘ ↑f

tactic: rfl
state_before: case h
R : Type u
ι : Type v
n : ℕ
M : Fin (Nat.succ n) → Type w
M₁ : ι → Type w₁
M₁' : ι → Type w₁'
M₂ : Type w₂
M₃ : Type w₃
M₄ : Type w₄
inst✝¹⁸ : Semiring R
inst✝¹⁷ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝¹⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝¹⁵ : (i : ι) → AddCommMonoid (M₁' i)
inst✝¹⁴ : AddCommMonoid M₂
inst✝¹³ : AddCommMonoid M₃
inst✝¹² : AddCommMonoid M₄
inst✝¹¹ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹⁰ : (i : ι) → Module R (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁' i)
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M₃
inst✝⁶ : Module R M₄
inst✝⁵ : (i : Fin (Nat.succ n)) → TopologicalSpace (M i)
inst✝⁴ : (i : ι) → TopologicalSpace (M₁ i)
inst✝³ : (i : ι) → TopologicalSpace (M₁' i)
inst✝² : TopologicalSpace M₂
inst✝¹ : TopologicalSpace M₃
inst✝ : TopologicalSpace M₄
f✝ f' : ContinuousMultilinearMap R M₁ M₂
g : M₂ →L[R] M₃
f : ContinuousMultilinearMap R M₁ M₂
m : (i : ι) → M₁ i
⊢ ↑(ContinuousLinearMap.compContinuousMultilinearMap g f) m = (↑g ∘ ↑f) m
Theorem: Finset.filter_lt_lt_eq_Ioo
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.35376
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a < j ∧ j < b
⊢ filter (fun j => a < j ∧ j < b) univ = Ioo a b

tactic: simp
state_before: case a
ι : Type ?u.35376
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a < j ∧ j < b
a✝ : α
⊢ a✝ ∈ filter (fun j => a < j ∧ j < b) univ ↔ a✝ ∈ Ioo a b
Theorem: ENNReal.pow_strictMono
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [pow_one] using strictMono_id
state_before: α : Type ?u.155987
β : Type ?u.155990
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ : 1 ≠ 0
⊢ StrictMono fun x => x ^ 1
Theorem: Nat.Linear.Expr.eq_of_toNormPoly_eq
File: src/lean/Init/Data/Nat/Linear.lean

tactic: have h := congrArg (Poly.denote ctx) (eq_of_beq h)
state_before: ctx : Context
e e' : Expr
h : (toNormPoly e == toPoly e') = true
⊢ denote ctx e = denote ctx e'

tactic: simp [Expr.toNormPoly, Poly.norm] at h
state_before: ctx : Context
e e' : Expr
h✝ : (toNormPoly e == toPoly e') = true
h : Poly.denote ctx (toNormPoly e) = Poly.denote ctx (toPoly e')
⊢ denote ctx e = denote ctx e'

tactic: assumption
state_before: ctx : Context
e e' : Expr
h✝ : (toNormPoly e == toPoly e') = true
h : denote ctx e = denote ctx e'
⊢ denote ctx e = denote ctx e'
Theorem: inner_re_zero_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [inner_zero_right, AddMonoidHom.map_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1554514
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ↑re (inner x 0) = 0
Theorem: RatFunc.ofFractionRing_add
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp only [HAdd.hAdd, Add.add, RatFunc.add]
state_before: K : Type u
inst✝ : CommRing K
p q : FractionRing K[X]
⊢ { toFractionRing := p + q } = { toFractionRing := p } + { toFractionRing := q }
Theorem: UniformCauchySeqOn.mul
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: simpa using (uniformContinuous_mul.comp_uniformCauchySeqOn (hf.prod' hf')) u hu
state_before: α : Type u_2
β : Type u_1
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Type u_3
l : Filter ι
l' : Filter β
f f' : ι → β → α
g g' : β → α
s : Set β
hf : UniformCauchySeqOn f l s
hf' : UniformCauchySeqOn f' l s
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (m : ι × ι) in l ×ˢ l, ∀ (x : β), x ∈ s → ((f * f') m.fst x, (f * f') m.snd x) ∈ u
Theorem: List.mem_permutations_of_perm_lemma
File: Mathlib/Data/List/Perm.lean

tactic: simpa [permutations, perm_nil] using H
state_before: α : Type uu
β : Type vv
l₁ l₂ is l : List α
H : l ~ [] ++ is → (∃ ts' x, l = ts' ++ is) ∨ l ∈ permutationsAux is []
⊢ l ~ is → l ∈ permutations is
Theorem: IsOpen.isGδ
File: Mathlib/Topology/GDelta.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type ?u.165
γ : Type ?u.168
ι : Type ?u.171
inst✝ : TopologicalSpace α
s : Set α
h : IsOpen s
⊢ ∀ (t : Set α), t ∈ {s} → IsOpen t
Theorem: Subgroup.mem_normalizer_fintype
File: Mathlib/GroupTheory/Subgroup/Finite.lean

tactic: haveI := Classical.propDecidable
state_before: G : Type u_1
inst✝² : Group G
A : Type ?u.42200
inst✝¹ : AddGroup A
S : Set G
inst✝ : Finite ↑S
x : G
h : ∀ (n : G), n ∈ S → x * n * x⁻¹ ∈ S
⊢ x ∈ setNormalizer S

tactic: cases nonempty_fintype S
state_before: G : Type u_1
inst✝² : Group G
A : Type ?u.42200
inst✝¹ : AddGroup A
S : Set G
inst✝ : Finite ↑S
x : G
h : ∀ (n : G), n ∈ S → x * n * x⁻¹ ∈ S
this : (a : Prop) → Decidable a
⊢ x ∈ setNormalizer S

tactic: haveI := Set.fintypeImage S fun n => x * n * x⁻¹
state_before: case intro
G : Type u_1
inst✝² : Group G
A : Type ?u.42200
inst✝¹ : AddGroup A
S : Set G
inst✝ : Finite ↑S
x : G
h : ∀ (n : G), n ∈ S → x * n * x⁻¹ ∈ S
this : (a : Prop) → Decidable a
val✝ : Fintype ↑S
⊢ x ∈ setNormalizer S

tactic: exact fun n =>
  ⟨h n, fun h₁ =>
    have heq : (fun n => x * n * x⁻¹) '' S = S :=
      Set.eq_of_subset_of_card_le (fun n ⟨y, hy⟩ => hy.2 ▸ h y hy.1)
        (by rw [Set.card_image_of_injective S conj_injective])
    have : x * n * x⁻¹ ∈ (fun n => x * n * x⁻¹) '' S := heq.symm ▸ h₁
    let ⟨y, hy⟩ := this
    conj_injective hy.2 ▸ hy.1⟩
state_before: case intro
G : Type u_1
inst✝² : Group G
A : Type ?u.42200
inst✝¹ : AddGroup A
S : Set G
inst✝ : Finite ↑S
x : G
h : ∀ (n : G), n ∈ S → x * n * x⁻¹ ∈ S
this✝ : (a : Prop) → Decidable a
val✝ : Fintype ↑S
this : Fintype ↑((fun n => x * n * x⁻¹) '' S)
⊢ x ∈ setNormalizer S

tactic: rw [Set.card_image_of_injective S conj_injective]
state_before: G : Type u_1
inst✝² : Group G
A : Type ?u.42200
inst✝¹ : AddGroup A
S : Set G
inst✝ : Finite ↑S
x : G
h : ∀ (n : G), n ∈ S → x * n * x⁻¹ ∈ S
this✝ : (a : Prop) → Decidable a
val✝ : Fintype ↑S
this : Fintype ↑((fun n => x * n * x⁻¹) '' S)
n : G
h₁ : x * n * x⁻¹ ∈ S
⊢ Fintype.card ↑S ≤ Fintype.card ↑((fun n => x * n * x⁻¹) '' S)
Theorem: Multiset.lcm_eq_zero_iff
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: induction' s using Multiset.induction_on with a s ihs
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
s : Multiset α
⊢ lcm s = 0 ↔ 0 ∈ s

tactic: simp only [lcm_zero, one_ne_zero, not_mem_zero]
state_before: case empty
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
⊢ lcm 0 = 0 ↔ 0 ∈ 0

tactic: simp only [mem_cons, lcm_cons, lcm_eq_zero_iff, ihs, @eq_comm _ a]
state_before: case cons
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
a : α
s : Multiset α
ihs : lcm s = 0 ↔ 0 ∈ s
⊢ lcm (a ::ₘ s) = 0 ↔ 0 ∈ a ::ₘ s
Theorem: MvPolynomial.IsHomogeneous.coeff_eq_zero
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: have aux := mt (@hφ d) hd
state_before: σ : Type u_1
τ : Type ?u.155224
R : Type u_2
S : Type ?u.155230
inst✝ : CommSemiring R
φ ψ : MvPolynomial σ R
m n : ℕ
hφ : IsHomogeneous φ n
d : σ →₀ ℕ
hd : ∑ i in d.support, ↑d i ≠ n
⊢ coeff d φ = 0

tactic: classical
rwa [Classical.not_not] at aux
state_before: σ : Type u_1
τ : Type ?u.155224
R : Type u_2
S : Type ?u.155230
inst✝ : CommSemiring R
φ ψ : MvPolynomial σ R
m n : ℕ
hφ : IsHomogeneous φ n
d : σ →₀ ℕ
hd : ∑ i in d.support, ↑d i ≠ n
aux : ¬coeff d φ ≠ 0
⊢ coeff d φ = 0

tactic: rwa [Classical.not_not] at aux
state_before: σ : Type u_1
τ : Type ?u.155224
R : Type u_2
S : Type ?u.155230
inst✝ : CommSemiring R
φ ψ : MvPolynomial σ R
m n : ℕ
hφ : IsHomogeneous φ n
d : σ →₀ ℕ
hd : ∑ i in d.support, ↑d i ≠ n
aux : ¬coeff d φ ≠ 0
⊢ coeff d φ = 0
Theorem: IsUnifLocDoublingMeasure.ae_tendsto_average_norm_sub
File: Mathlib/MeasureTheory/Covering/DensityTheorem.lean

tactic: filter_upwards [(vitaliFamily μ K).ae_tendsto_average_norm_sub hf] with x hx ι l w δ δlim
  xmem using hx.comp (tendsto_closedBall_filterAt μ _ _ δlim xmem)
state_before: α : Type u_2
inst✝⁶ : MetricSpace α
inst✝⁵ : MeasurableSpace α
μ : MeasureTheory.Measure α
inst✝⁴ : IsUnifLocDoublingMeasure μ
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
E : Type u_1
inst✝ : NormedAddCommGroup E
f : α → E
hf : Integrable f
K : ℝ
⊢ ∀ᵐ (x : α) ∂μ,
    ∀ {ι : Type u_3} {l : Filter ι} (w : ι → α) (δ : ι → ℝ),
      Tendsto δ l (𝓝[Ioi 0] 0) →
        (∀ᶠ (j : ι) in l, x ∈ closedBall (w j) (K * δ j)) →
          Tendsto (fun j => ⨍ (y : α) in closedBall (w j) (δ j), ‖f y - f x‖ ∂μ) l (𝓝 0)
Theorem: RingHom.map_matrix_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [Matrix.mul_apply, map_sum]
state_before: l : Type ?u.1247421
m : Type u_1
n : Type u_2
o : Type u_3
m' : o → Type ?u.1247435
n' : o → Type ?u.1247440
R : Type ?u.1247443
S : Type ?u.1247446
α : Type v
β : Type w
γ : Type ?u.1247453
inst✝² : Fintype n
inst✝¹ : NonAssocSemiring α
inst✝ : NonAssocSemiring β
M : Matrix m n α
N : Matrix n o α
i : m
j : o
f : α →+* β
⊢ ↑f ((M ⬝ N) i j) = (map M ↑f ⬝ map N ↑f) i j
Theorem: Equiv.Perm.SameCycle.of_zpow
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [zpow_mul, h]
state_before: ι : Type ?u.205527
α : Type u_1
β : Type ?u.205533
f g : Perm α
p : α → Prop
x y z : α
n : ℤ
x✝ : SameCycle (f ^ n) x y
m : ℤ
h : ↑((f ^ n) ^ m) x = y
⊢ ↑(f ^ (n * m)) x = y
Theorem: Set.Finite.isCompact_biUnion
File: Mathlib/Topology/SubsetProperties.lean

tactic: rw [le_principal_iff, Ultrafilter.mem_coe, Ultrafilter.finite_biUnion_mem_iff hs] at hl
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type ?u.31333
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t : Set α
s : Set ι
f : ι → Set α
hs : Set.Finite s
hf : ∀ (i : ι), i ∈ s → IsCompact (f i)
l : Ultrafilter α
hl : ↑l ≤ 𝓟 (⋃ (i : ι) (_ : i ∈ s), f i)
⊢ ∃ a, (a ∈ ⋃ (i : ι) (_ : i ∈ s), f i) ∧ ↑l ≤ 𝓝 a

tactic: rcases hl with ⟨i, his, hi⟩
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type ?u.31333
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t : Set α
s : Set ι
f : ι → Set α
hs : Set.Finite s
hf : ∀ (i : ι), i ∈ s → IsCompact (f i)
l : Ultrafilter α
hl : ∃ i, i ∈ s ∧ f i ∈ l
⊢ ∃ a, (a ∈ ⋃ (i : ι) (_ : i ∈ s), f i) ∧ ↑l ≤ 𝓝 a

tactic: rcases (hf i his).ultrafilter_le_nhds _ (le_principal_iff.2 hi) with ⟨x, hxi, hlx⟩
state_before: case intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type ?u.31333
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t : Set α
s : Set ι
f : ι → Set α
hs : Set.Finite s
hf : ∀ (i : ι), i ∈ s → IsCompact (f i)
l : Ultrafilter α
i : ι
his : i ∈ s
hi : f i ∈ l
⊢ ∃ a, (a ∈ ⋃ (i : ι) (_ : i ∈ s), f i) ∧ ↑l ≤ 𝓝 a

tactic: exact ⟨x, mem_iUnion₂.2 ⟨i, his, hxi⟩, hlx⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type ?u.31333
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t : Set α
s : Set ι
f : ι → Set α
hs : Set.Finite s
hf : ∀ (i : ι), i ∈ s → IsCompact (f i)
l : Ultrafilter α
i : ι
his : i ∈ s
hi : f i ∈ l
x : α
hxi : x ∈ f i
hlx : ↑l ≤ 𝓝 x
⊢ ∃ a, (a ∈ ⋃ (i : ι) (_ : i ∈ s), f i) ∧ ↑l ≤ 𝓝 a
Theorem: LinearMap.finrank_range_of_inj
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: rw [(LinearEquiv.ofInjective f hf).finrank_eq]
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
hf : Injective ↑f
⊢ finrank K { x // x ∈ range f } = finrank K V
Theorem: MvPolynomial.degrees_sub
File: Mathlib/Data/MvPolynomial/CommRing.lean

tactic: simpa only [sub_eq_add_neg] using le_trans (degrees_add p (-q)) (by rw [degrees_neg])
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ degrees (p - q) ≤ degrees p ⊔ degrees q

tactic: rw [degrees_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ degrees p ⊔ degrees (-q) ≤ degrees p ⊔ degrees q
Theorem: TypeVec.dropFun_prod
File: Mathlib/Data/TypeVec.lean

tactic: ext i : 2
state_before: n : ℕ
α α' β β' : TypeVec (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
⊢ dropFun (f ⊗' f') = (dropFun f ⊗' dropFun f')

tactic: induction i <;> simp [dropFun, *] <;> rfl
state_before: case a.h
n : ℕ
α α' β β' : TypeVec (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
i : Fin2 n
x✝ : drop (α ⊗ α') i
⊢ dropFun (f ⊗' f') i x✝ = (dropFun f ⊗' dropFun f') i x✝
Theorem: Set.image_add_const_Iio
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x + a) '' Iio b = Iio (b + a)
Theorem: Polynomial.rootSet_X_pow
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [← one_mul (X ^ n : R[X]), ← C_1, rootSet_C_mul_X_pow hn]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
n : ℕ
hn : n ≠ 0
⊢ rootSet (X ^ n) S = {0}

tactic: exact one_ne_zero
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
n : ℕ
hn : n ≠ 0
⊢ 1 ≠ 0
Theorem: Covby.Iio_eq
File: Mathlib/Order/Cover.lean

tactic: rw [← Iic_union_Ioo_eq_Iio h.lt, h.Ioo_eq, union_empty]
state_before: α : Type u_1
β : Type ?u.38227
inst✝ : LinearOrder α
a b c : α
h : a ⋖ b
⊢ Iio b = Iic a
Theorem: LieSubmodule.nontrivial_iff_ne_bot
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: constructor <;> contrapose!
state_before: R : Type u
L : Type v
M : Type w
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
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
N : LieSubmodule R L M
⊢ Nontrivial { x // x ∈ ↑N } ↔ N ≠ ⊥

tactic: rintro rfl
  ⟨⟨m₁, h₁ : m₁ ∈ (⊥ : LieSubmodule R L M)⟩, ⟨m₂, h₂ : m₂ ∈ (⊥ : LieSubmodule R L M)⟩, h₁₂⟩
state_before: case mp
R : Type u
L : Type v
M : Type w
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
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
N : LieSubmodule R L M
⊢ N = ⊥ → ¬Nontrivial { x // x ∈ ↑N }

tactic: simp [(LieSubmodule.mem_bot _).mp h₁, (LieSubmodule.mem_bot _).mp h₂] at h₁₂
state_before: case mp.mk.intro.mk.intro.mk
R : Type u
L : Type v
M : Type w
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
N N' : LieSubmodule R L M
I J : LieIdeal R L
m₁ : M
h₁ : m₁ ∈ ⊥
m₂ : M
h₂ : m₂ ∈ ⊥
h₁₂ : { val := m₁, property := h₁ } ≠ { val := m₂, property := h₂ }
⊢ False

tactic: rw [not_nontrivial_iff_subsingleton, LieSubmodule.eq_bot_iff]
state_before: case mpr
R : Type u
L : Type v
M : Type w
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
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
N : LieSubmodule R L M
⊢ ¬Nontrivial { x // x ∈ ↑N } → N = ⊥

tactic: rintro ⟨h⟩ m hm
state_before: case mpr
R : Type u
L : Type v
M : Type w
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
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
N : LieSubmodule R L M
⊢ Subsingleton { x // x ∈ ↑N } → ∀ (m : M), m ∈ N → m = 0

tactic: simpa using h ⟨m, hm⟩ ⟨_, N.zero_mem⟩
state_before: case mpr.intro
R : Type u
L : Type v
M : Type w
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
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
N : LieSubmodule R L M
h : ∀ (a b : { x // x ∈ ↑N }), a = b
m : M
hm : m ∈ N
⊢ m = 0
Theorem: StructureGroupoid.LocalInvariantProp.liftPropWithinAt_of_liftPropAt
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: rw [← liftPropWithinAt_univ] at h
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.50373
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
mono : ∀ ⦃s : Set H⦄ ⦃x : H⦄ ⦃t : Set H⦄ ⦃f : H → H'⦄, t ⊆ s → P f s x → P f t x
h : LiftPropAt P g x
⊢ LiftPropWithinAt P g s x

tactic: exact liftPropWithinAt_mono mono h (subset_univ _)
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.50373
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
mono : ∀ ⦃s : Set H⦄ ⦃x : H⦄ ⦃t : Set H⦄ ⦃f : H → H'⦄, t ⊆ s → P f s x → P f t x
h : LiftPropWithinAt P g univ x
⊢ LiftPropWithinAt P g s x
Theorem: LinearMap.lsum_single
File: Mathlib/LinearAlgebra/Pi.lean

tactic: simp [Finset.univ_sum_single]
state_before: R✝ : Type u
K : Type u'
M✝ : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι✝ : Type x
ι' : Type x'
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R✝ M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : Module R✝ M₃
φ : ι✝ → Type i
inst✝⁶ : (i : ι✝) → AddCommMonoid (φ i)
inst✝⁵ : (i : ι✝) → Module R✝ (φ i)
ι : Type u_1
R : Type u_2
inst✝⁴ : Fintype ι
inst✝³ : DecidableEq ι
inst✝² : CommRing R
M : ι → Type u_3
inst✝¹ : (i : ι) → AddCommGroup (M i)
inst✝ : (i : ι) → Module R (M i)
x : (i : ι) → M i
⊢ ↑(↑(lsum R M R) single) x = ↑id x
Theorem: Nat.add_eq_two_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: cases n <;>
simp [(succ_ne_zero 1).symm, (show 2 = Nat.succ 1 from rfl),
  succ_eq_add_one, ← add_assoc, succ_inj', add_eq_one_iff]
state_before: m n k l : ℕ
⊢ m + n = 2 ↔ m = 0 ∧ n = 2 ∨ m = 1 ∧ n = 1 ∨ m = 2 ∧ n = 0