tasksource/leandojo huggingface dataset:
Theorem: TensorProduct.tmul_ite
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: split_ifs <;> simp
state_before: R : Type u_3
inst✝¹⁷ : CommSemiring R
R' : Type ?u.449877
inst✝¹⁶ : Monoid R'
R'' : Type ?u.449883
inst✝¹⁵ : Semiring R''
M : Type u_1
N : Type u_2
P✝ : Type ?u.449895
Q : Type ?u.449898
S : Type ?u.449901
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : AddCommMonoid N
inst✝¹² : AddCommMonoid P✝
inst✝¹¹ : AddCommMonoid Q
inst✝¹⁰ : AddCommMonoid S
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module R P✝
inst✝⁶ : Module R Q
inst✝⁵ : Module R S
inst✝⁴ : DistribMulAction R' M
inst✝³ : Module R'' M
inst✝² : SMulCommClass R R' M
inst✝¹ : SMulCommClass R R'' M
x₁ : M
x₂ : N
P : Prop
inst✝ : Decidable P
⊢ (x₁ ⊗ₜ[R] if P then x₂ else 0) = if P then x₁ ⊗ₜ[R] x₂ else 0
Theorem: Int.sub_ediv_of_dvd_sub
File: Std/Data/Int/DivMod.lean

tactic: rw [← Int.add_sub_cancel ((a-b) / c), ← Int.add_ediv_of_dvd_left hcab, Int.sub_add_cancel]
state_before: a b c : Int
hcab : c ∣ a - b
⊢ (a - b) / c = a / c - b / c
Theorem: Ring.two_ne_zero
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rw [Ne.def, (by norm_cast : (2 : R) = (2 : ℕ)), ringChar.spec, Nat.dvd_prime Nat.prime_two]
state_before: R✝ : Type ?u.950230
R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : Nontrivial R
hR : ringChar R ≠ 2
⊢ 2 ≠ 0

tactic: exact mt (or_iff_left hR).mp CharP.ringChar_ne_one
state_before: R✝ : Type ?u.950230
R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : Nontrivial R
hR : ringChar R ≠ 2
⊢ ¬(ringChar R = 1 ∨ ringChar R = 2)

tactic: norm_cast
state_before: R✝ : Type ?u.950230
R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : Nontrivial R
hR : ringChar R ≠ 2
⊢ 2 = ↑2
Theorem: Polynomial.monic_geom_sum_X
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: nontriviality R
state_before: R : Type u
S : Type ?u.60633
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
⊢ Monic (∑ i in range n, X ^ i)

tactic: apply monic_X.geom_sum _ hn
state_before: R : Type u
S : Type ?u.60633
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
✝ : Nontrivial R
⊢ Monic (∑ i in range n, X ^ i)

tactic: simp only [natDegree_X, zero_lt_one]
state_before: R : Type u
S : Type ?u.60633
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
✝ : Nontrivial R
⊢ 0 < natDegree X
Theorem: MeasureTheory.lintegral_const_lt_top
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simpa only [Measure.restrict_univ] using set_lintegral_const_lt_top (univ : Set α) hc
state_before: α : Type u_1
β : Type ?u.76494
γ : Type ?u.76497
δ : Type ?u.76500
m : MeasurableSpace α
μ ν : Measure α
inst✝ : IsFiniteMeasure μ
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ (∫⁻ (x : α), c ∂μ) < ⊤
Theorem: Finsupp.Lex.acc
File: Mathlib/Data/Finsupp/WellFounded.lean

tactic: rw [lex_eq_invImage_dfinsupp_lex]
state_before: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ (a : α), a ∈ x.support → Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ Acc (Finsupp.Lex r s) x

tactic: classical
  refine' InvImage.accessible toDfinsupp (Dfinsupp.Lex.acc (fun _ => hbot) (fun _ => hs) _ _)
  simpa only [toDfinsupp_support] using h
state_before: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ (a : α), a ∈ x.support → Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ Acc (InvImage (Dfinsupp.Lex r fun x => s) toDfinsupp) x

tactic: refine' InvImage.accessible toDfinsupp (Dfinsupp.Lex.acc (fun _ => hbot) (fun _ => hs) _ _)
state_before: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ (a : α), a ∈ x.support → Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ Acc (InvImage (Dfinsupp.Lex r fun x => s) toDfinsupp) x

tactic: simpa only [toDfinsupp_support] using h
state_before: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ (a : α), a ∈ x.support → Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ ∀ (i : α), i ∈ Dfinsupp.support (toDfinsupp x) → Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) i
Theorem: Nat.eq_mul_of_div_eq_right
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [← H2, Nat.mul_div_cancel' H1]
state_before: m n k a b c : ℕ
H1 : b ∣ a
H2 : a / b = c
⊢ a = b * c
Theorem: lt_mul_iff_one_lt_right'
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [mul_one]
state_before: α : Type u_1
β : Type ?u.24947
inst✝³ : MulOneClass α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
⊢ a < a * b ↔ a * 1 < a * b
Theorem: ENNReal.rpow_add
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases' x with x
state_before: x : ℝ≥0∞
y z : ℝ
hx : x ≠ 0
h'x : x ≠ ⊤
⊢ x ^ (y + z) = x ^ y * x ^ z

tactic: have : x ≠ 0 := fun h => by simp [h] at hx
state_before: case some
y z : ℝ
x : ℝ≥0
hx : Option.some x ≠ 0
h'x : Option.some x ≠ ⊤
⊢ Option.some x ^ (y + z) = Option.some x ^ y * Option.some x ^ z

tactic: simp [coe_rpow_of_ne_zero this, NNReal.rpow_add this]
state_before: case some
y z : ℝ
x : ℝ≥0
hx : Option.some x ≠ 0
h'x : Option.some x ≠ ⊤
this : x ≠ 0
⊢ Option.some x ^ (y + z) = Option.some x ^ y * Option.some x ^ z

tactic: exact (h'x rfl).elim
state_before: case none
y z : ℝ
hx : none ≠ 0
h'x : none ≠ ⊤
⊢ none ^ (y + z) = none ^ y * none ^ z

tactic: simp [h] at hx
state_before: y z : ℝ
x : ℝ≥0
hx : Option.some x ≠ 0
h'x : Option.some x ≠ ⊤
h : x = 0
⊢ False
Theorem: SimpleGraph.Walk.IsPath.length_lt
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [Nat.lt_iff_add_one_le, ← length_support]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : Fintype V
u v : V
p : Walk G u v
hp : IsPath p
⊢ length p < Fintype.card V

tactic: exact hp.support_nodup.length_le_card
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : Fintype V
u v : V
p : Walk G u v
hp : IsPath p
⊢ List.length (support p) ≤ Fintype.card V
Theorem: MeasureTheory.Measure.toENNRealVectorMeasure_add
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: refine' MeasureTheory.VectorMeasure.ext fun i hi => _
state_before: α : Type u_1
β : Type ?u.149284
m : MeasurableSpace α
μ ν : Measure α
⊢ toENNRealVectorMeasure (μ + ν) = toENNRealVectorMeasure μ + toENNRealVectorMeasure ν

tactic: rw [toENNRealVectorMeasure_apply_measurable hi, add_apply, VectorMeasure.add_apply,
  toENNRealVectorMeasure_apply_measurable hi, toENNRealVectorMeasure_apply_measurable hi]
state_before: α : Type u_1
β : Type ?u.149284
m : MeasurableSpace α
μ ν : Measure α
i : Set α
hi : MeasurableSet i
⊢ ↑(toENNRealVectorMeasure (μ + ν)) i = ↑(toENNRealVectorMeasure μ + toENNRealVectorMeasure ν) i
Theorem: Polynomial.separable_iff_derivative_ne_zero
File: Mathlib/FieldTheory/Separable.lean

tactic: conv_lhs => rw [hg3, ← hu]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
h : ↑derivative f ≠ 0
g : F[X]
hg1 : g ∈ nonunits F[X]
_hg2 : g ≠ 0
x✝ : g ∣ f
hg4 : g ∣ ↑derivative f
p : F[X]
hg3 : f = g * p
u : F[X]ˣ
hu : ↑u = p
⊢ f ∣ ↑derivative f

tactic: rwa [Units.mul_right_dvd]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
h : ↑derivative f ≠ 0
g : F[X]
hg1 : g ∈ nonunits F[X]
_hg2 : g ≠ 0
x✝ : g ∣ f
hg4 : g ∣ ↑derivative f
p : F[X]
hg3 : f = g * p
u : F[X]ˣ
hu : ↑u = p
⊢ g * ↑u ∣ ↑derivative f
Theorem: LocallyFinite.finite_nonempty_of_compact
File: Mathlib/Topology/SubsetProperties.lean

tactic: simpa only [inter_univ] using hf.finite_nonempty_inter_compact isCompact_univ
state_before: α : Type u
β : Type v
ι✝ : Type ?u.89027
π : ι✝ → Type ?u.89032
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
ι : Type u_1
inst✝ : CompactSpace α
f : ι → Set α
hf : LocallyFinite f
⊢ Set.Finite {i | Set.Nonempty (f i)}
Theorem: ClosedEmbedding.normalSpace
File: Mathlib/Topology/Separation.lean

tactic: have H : SeparatedNhds (f '' s) (f '' t) :=
  NormalSpace.normal (f '' s) (f '' t) (hf.isClosedMap s hs) (hf.isClosedMap t ht)
    (disjoint_image_of_injective hf.inj hst)
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NormalSpace β
f : α → β
hf : ClosedEmbedding f
s t : Set α
hs : IsClosed s
ht : IsClosed t
hst : Disjoint s t
⊢ SeparatedNhds s t

tactic: exact (H.preimage hf.continuous).mono (subset_preimage_image _ _) (subset_preimage_image _ _)
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NormalSpace β
f : α → β
hf : ClosedEmbedding f
s t : Set α
hs : IsClosed s
ht : IsClosed t
hst : Disjoint s t
H : SeparatedNhds (f '' s) (f '' t)
⊢ SeparatedNhds s t
Theorem: Real.le_tan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean

tactic: rcases eq_or_lt_of_le h1 with (rfl | h1')
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x < π / 2
⊢ x ≤ tan x

tactic: rw [tan_zero]
state_before: case inl
h1 : 0 ≤ 0
h2 : 0 < π / 2
⊢ 0 ≤ tan 0

tactic: exact le_of_lt (lt_tan h1' h2)
state_before: case inr
x : ℝ
h1 : 0 ≤ x
h2 : x < π / 2
h1' : 0 < x
⊢ x ≤ tan x
Theorem: Filter.comap_abs_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: refine'
  le_antisymm (((atTop_basis.comap _).le_basis_iff (atBot_basis.sup atTop_basis)).2 _)
    (sup_le tendsto_abs_atBot_atTop.le_comap tendsto_abs_atTop_atTop.le_comap)
state_before: ι : Type ?u.201690
ι' : Type ?u.201693
α : Type u_1
β : Type ?u.201699
γ : Type ?u.201702
inst✝ : LinearOrderedAddCommGroup α
⊢ comap abs atTop = atBot ⊔ atTop

tactic: rintro ⟨a, b⟩ -
state_before: ι : Type ?u.201690
ι' : Type ?u.201693
α : Type u_1
β : Type ?u.201699
γ : Type ?u.201702
inst✝ : LinearOrderedAddCommGroup α
⊢ ∀ (i' : α × α), True ∧ True → ∃ i, True ∧ abs ⁻¹' Ici i ⊆ Iic i'.fst ∪ Ici i'.snd

tactic: refine' ⟨max (-a) b, trivial, fun x hx => _⟩
state_before: case mk
ι : Type ?u.201690
ι' : Type ?u.201693
α : Type u_1
β : Type ?u.201699
γ : Type ?u.201702
inst✝ : LinearOrderedAddCommGroup α
a b : α
⊢ ∃ i, True ∧ abs ⁻¹' Ici i ⊆ Iic (a, b).fst ∪ Ici (a, b).snd

tactic: rw [mem_preimage, mem_Ici, le_abs', max_le_iff, ← min_neg_neg, le_min_iff, neg_neg] at hx
state_before: case mk
ι : Type ?u.201690
ι' : Type ?u.201693
α : Type u_1
β : Type ?u.201699
γ : Type ?u.201702
inst✝ : LinearOrderedAddCommGroup α
a b x : α
hx : x ∈ abs ⁻¹' Ici (max (-a) b)
⊢ x ∈ Iic (a, b).fst ∪ Ici (a, b).snd

tactic: exact hx.imp And.left And.right
state_before: case mk
ι : Type ?u.201690
ι' : Type ?u.201693
α : Type u_1
β : Type ?u.201699
γ : Type ?u.201702
inst✝ : LinearOrderedAddCommGroup α
a b x : α
hx : x ≤ a ∧ x ≤ -b ∨ -a ≤ x ∧ b ≤ x
⊢ x ∈ Iic (a, b).fst ∪ Ici (a, b).snd
Theorem: List.nodup_sublists'
File: Mathlib/Data/List/Sublists.lean

tactic: rw [sublists'_eq_sublists, nodup_map_iff reverse_injective, nodup_sublists, nodup_reverse]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ Nodup (sublists' l) ↔ Nodup l
Theorem: Int.mul_pos_of_neg_of_neg
File: Std/Data/Int/Lemmas.lean

tactic: have : 0 * b < a * b := Int.mul_lt_mul_of_neg_right ha hb
state_before: a b : Int
ha : a < 0
hb : b < 0
⊢ 0 < a * b

tactic: rwa [Int.zero_mul] at this
state_before: a b : Int
ha : a < 0
hb : b < 0
this : 0 * b < a * b
⊢ 0 < a * b
Theorem: measurableSet_of_differentiableWithinAt_Ioi
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: simpa [differentiableWithinAt_Ioi_iff_Ici] using measurableSet_of_differentiableWithinAt_Ici f
state_before: F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
⊢ MeasurableSet {x | DifferentiableWithinAt ℝ f (Ioi x) x}
Theorem: LieSubmodule.lowerCentralSeries_map_eq_lcs
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: rw [lowerCentralSeries_eq_lcs_comap, LieSubmodule.map_comap_incl, inf_eq_right]
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
k : ℕ
N : LieSubmodule R L M
⊢ map (incl N) (lowerCentralSeries R L { x // x ∈ ↑N } k) = lcs k N

tactic: apply lcs_le_self
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
k : ℕ
N : LieSubmodule R L M
⊢ lcs k N ≤ N
Theorem: Std.AssocList.any_eq
File: Std/Data/AssocList.lean

tactic: induction l <;> simp [any, *]
state_before: α : Type u_1
β : Type u_2
p : α → β → Bool
l : AssocList α β
⊢ any p l =
    List.any (toList l) fun x =>
      match x with
      | (a, b) => p a b
Theorem: Substring.ValidFor.contains
File: Std/Data/String/Lemmas.lean

tactic: simp [Substring.contains, h.any, String.contains]
state_before: l m r : List Char
c : Char
x✝ : Substring
h : ValidFor l m r x✝
⊢ Substring.contains x✝ c = true ↔ c ∈ m
Theorem: mem_perms_of_finset_iff
File: Mathlib/Data/Fintype/Perm.lean

tactic: rintro ⟨⟨l⟩, hs⟩ f
state_before: α : Type u_1
β : Type ?u.50561
γ : Type ?u.50564
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∀ {s : Finset α} {f : Equiv.Perm α}, f ∈ permsOfFinset s ↔ ∀ {x : α}, ↑f x ≠ x → x ∈ s

tactic: exact mem_permsOfList_iff
state_before: case mk.mk
α : Type u_1
β : Type ?u.50561
γ : Type ?u.50564
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
val✝ : Multiset α
l : List α
hs : Multiset.Nodup (Quot.mk Setoid.r l)
f : Equiv.Perm α
⊢ f ∈ permsOfFinset { val := Quot.mk Setoid.r l, nodup := hs } ↔
    ∀ {x : α}, ↑f x ≠ x → x ∈ { val := Quot.mk Setoid.r l, nodup := hs }
Theorem: ContinuousLinearEquiv.comp_right_fderiv
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: rw [← fderivWithin_univ, ← fderivWithin_univ, ← iso.comp_right_fderivWithin, preimage_univ]
state_before: 𝕜 : Type u_3
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_2
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.247750
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
iso : E ≃L[𝕜] F
f : F → G
x : E
⊢ fderiv 𝕜 (f ∘ ↑iso) x = comp (fderiv 𝕜 f (↑iso x)) ↑iso

tactic: exact uniqueDiffWithinAt_univ
state_before: 𝕜 : Type u_3
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_2
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.247750
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
iso : E ≃L[𝕜] F
f : F → G
x : E
⊢ UniqueDiffWithinAt 𝕜 (↑iso ⁻¹' univ) x
Theorem: ForInStep.bind_bindList_assoc
File: Std/Control/ForInStep/Lemmas.lean

tactic: cases s <;> simp
state_before: m : Type u_1 → Type u_2
β : Type u_1
α : Type u_3
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : β → m (ForInStep β)
g : α → β → m (ForInStep β)
s : ForInStep β
l : List α
⊢ (do
      let x ← ForInStep.bind s f
      bindList g l x) =
    ForInStep.bind s fun b => do
      let x ← f b
      bindList g l x
Theorem: Set.Ioc_union_Ioc_left
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [Ioc_union_Ioc, max_self] <;> exact (min_le_right _ _).trans (le_max_right _ _)
state_before: α : Type u_1
β : Type ?u.211771
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a c ∪ Ioc b c = Ioc (min a b) c
Theorem: UniqueFactorizationMonoid.exists_prime_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp_rw [← UniqueFactorizationMonoid.irreducible_iff_prime]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a

tactic: apply WfDvdMonoid.exists_factors a
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Irreducible b) ∧ Multiset.prod f ~ᵤ a
Theorem: AlgEquiv.symm_comp
File: Mathlib/Algebra/Algebra/Equiv.lean

tactic: ext
state_before: R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e✝ e : A₁ ≃ₐ[R] A₂
⊢ AlgHom.comp ↑(symm e) ↑e = AlgHom.id R A₁

tactic: simp
state_before: case H
R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e✝ e : A₁ ≃ₐ[R] A₂
x✝ : A₁
⊢ ↑(AlgHom.comp ↑(symm e) ↑e) x✝ = ↑(AlgHom.id R A₁) x✝
Theorem: ProjectiveSpectrum.vanishingIdeal_singleton
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: simp [vanishingIdeal]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : ProjectiveSpectrum 𝒜
⊢ vanishingIdeal {x} = x.asHomogeneousIdeal
Theorem: AlgebraicTopology.DoldKan.compatibility_Γ₂N₁_Γ₂N₂_natTrans
File: Mathlib/AlgebraicTopology/DoldKan/NCompGamma.lean

tactic: rw [Γ₂N₂.natTrans_app_f_app]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ Γ₂N₁.natTrans.app X = (compatibility_Γ₂N₁_Γ₂N₂.app X).inv ≫ Γ₂N₂.natTrans.app ((toKaroubi (SimplicialObject C)).obj X)

tactic: dsimp only [Karoubi.decompId_i_toKaroubi, Karoubi.decompId_p_toKaroubi, Functor.comp_map,
  NatTrans.comp_app]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ Γ₂N₁.natTrans.app X =
    (compatibility_Γ₂N₁_Γ₂N₂.app X).inv ≫
      (N₂ ⋙ Γ₂).map (Karoubi.decompId_i ((toKaroubi (SimplicialObject C)).obj X)) ≫
        (compatibility_Γ₂N₁_Γ₂N₂.hom ≫ Γ₂N₁.natTrans).app ((toKaroubi (SimplicialObject C)).obj X).X ≫
          Karoubi.decompId_p ((toKaroubi (SimplicialObject C)).obj X)

tactic: rw [N₂.map_id, Γ₂.map_id, Iso.app_inv]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ Γ₂N₁.natTrans.app X =
    (compatibility_Γ₂N₁_Γ₂N₂.app X).inv ≫
      Γ₂.map (N₂.map (𝟙 ((toKaroubi (SimplicialObject C)).obj X))) ≫
        (compatibility_Γ₂N₁_Γ₂N₂.hom.app ((toKaroubi (SimplicialObject C)).obj X).X ≫
            Γ₂N₁.natTrans.app ((toKaroubi (SimplicialObject C)).obj X).X) ≫
          𝟙 (Karoubi.mk ((toKaroubi (SimplicialObject C)).obj X).X (𝟙 ((toKaroubi (SimplicialObject C)).obj X).X))

tactic: dsimp only [toKaroubi]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ Γ₂N₁.natTrans.app X =
    compatibility_Γ₂N₁_Γ₂N₂.inv.app X ≫
      𝟙 (Γ₂.obj (N₂.obj ((toKaroubi (SimplicialObject C)).obj X))) ≫
        (compatibility_Γ₂N₁_Γ₂N₂.hom.app ((toKaroubi (SimplicialObject C)).obj X).X ≫
            Γ₂N₁.natTrans.app ((toKaroubi (SimplicialObject C)).obj X).X) ≫
          𝟙 (Karoubi.mk ((toKaroubi (SimplicialObject C)).obj X).X (𝟙 ((toKaroubi (SimplicialObject C)).obj X).X))

tactic: erw [id_comp]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ Γ₂N₁.natTrans.app X =
    compatibility_Γ₂N₁_Γ₂N₂.inv.app X ≫
      𝟙 (Γ₂.obj (N₂.obj (Karoubi.mk X (𝟙 X)))) ≫
        (compatibility_Γ₂N₁_Γ₂N₂.hom.app X ≫ Γ₂N₁.natTrans.app X) ≫ 𝟙 (Karoubi.mk X (𝟙 X))

tactic: rw [comp_id, Iso.inv_hom_id_app_assoc]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ Γ₂N₁.natTrans.app X =
    compatibility_Γ₂N₁_Γ₂N₂.inv.app X ≫
      (compatibility_Γ₂N₁_Γ₂N₂.hom.app X ≫ Γ₂N₁.natTrans.app X) ≫ 𝟙 (Karoubi.mk X (𝟙 X))
Theorem: SimpleGraph.Walk.map_toDeleteEdges_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← transfer_eq_map_of_le, transfer_transfer, transfer_self]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : Walk G v w
hp : ∀ (e : Sym2 V), e ∈ edges p → ¬e ∈ s
⊢ Walk.map (Hom.mapSpanningSubgraphs (_ : deleteEdges G s ≤ G)) (toDeleteEdges s p hp) = p

tactic: intros e
state_before: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : Walk G v w
hp : ∀ (e : Sym2 V), e ∈ edges p → ¬e ∈ s
⊢ ∀ (e : Sym2 V),
    e ∈ edges (Walk.transfer p (deleteEdges G s) (_ : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet (deleteEdges G s))) →
      e ∈ edgeSet G

tactic: rw [edges_transfer]
state_before: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : Walk G v w
hp : ∀ (e : Sym2 V), e ∈ edges p → ¬e ∈ s
e : Sym2 V
⊢ e ∈ edges (Walk.transfer p (deleteEdges G s) (_ : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet (deleteEdges G s))) →
    e ∈ edgeSet G

tactic: apply edges_subset_edgeSet p
state_before: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : Walk G v w
hp : ∀ (e : Sym2 V), e ∈ edges p → ¬e ∈ s
e : Sym2 V
⊢ e ∈ edges p → e ∈ edgeSet G
Theorem: CategoryTheory.tensor_sum
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: rw [← tensor_id_comp_id_tensor]
state_before: C : Type u_3
inst✝³ : Category C
inst✝² : Preadditive C
inst✝¹ : MonoidalCategory C
inst✝ : MonoidalPreadditive C
P Q R S : C
J : Type u_1
s : Finset J
f : P ⟶ Q
g : J → (R ⟶ S)
⊢ f ⊗ ∑ j in s, g j = ∑ j in s, f ⊗ g j

tactic: let tQ := (((tensoringLeft C).obj Q).mapAddHom : (R ⟶ S) →+ _)
state_before: C : Type u_3
inst✝³ : Category C
inst✝² : Preadditive C
inst✝¹ : MonoidalCategory C
inst✝ : MonoidalPreadditive C
P Q R S : C
J : Type u_1
s : Finset J
f : P ⟶ Q
g : J → (R ⟶ S)
⊢ (f ⊗ 𝟙 R) ≫ (𝟙 Q ⊗ ∑ j in s, g j) = ∑ j in s, f ⊗ g j

tactic: change _ ≫ tQ _ = _
state_before: C : Type u_3
inst✝³ : Category C
inst✝² : Preadditive C
inst✝¹ : MonoidalCategory C
inst✝ : MonoidalPreadditive C
P Q R S : C
J : Type u_1
s : Finset J
f : P ⟶ Q
g : J → (R ⟶ S)
tQ : (R ⟶ S) →+ (((tensoringLeft C).obj Q).obj R ⟶ ((tensoringLeft C).obj Q).obj S) :=
  Functor.mapAddHom ((tensoringLeft C).obj Q)
⊢ (f ⊗ 𝟙 R) ≫ (𝟙 Q ⊗ ∑ j in s, g j) = ∑ j in s, f ⊗ g j

tactic: rw [tQ.map_sum, Preadditive.comp_sum]
state_before: C : Type u_3
inst✝³ : Category C
inst✝² : Preadditive C
inst✝¹ : MonoidalCategory C
inst✝ : MonoidalPreadditive C
P Q R S : C
J : Type u_1
s : Finset J
f : P ⟶ Q
g : J → (R ⟶ S)
tQ : (R ⟶ S) →+ (((tensoringLeft C).obj Q).obj R ⟶ ((tensoringLeft C).obj Q).obj S) :=
  Functor.mapAddHom ((tensoringLeft C).obj Q)
⊢ (f ⊗ 𝟙 R) ≫ ↑tQ (∑ j in s, g j) = ∑ j in s, f ⊗ g j

tactic: dsimp [Functor.mapAddHom]
state_before: C : Type u_3
inst✝³ : Category C
inst✝² : Preadditive C
inst✝¹ : MonoidalCategory C
inst✝ : MonoidalPreadditive C
P Q R S : C
J : Type u_1
s : Finset J
f : P ⟶ Q
g : J → (R ⟶ S)
tQ : (R ⟶ S) →+ (((tensoringLeft C).obj Q).obj R ⟶ ((tensoringLeft C).obj Q).obj S) :=
  Functor.mapAddHom ((tensoringLeft C).obj Q)
⊢ ∑ j in s, (f ⊗ 𝟙 R) ≫ ↑tQ (g j) = ∑ j in s, f ⊗ g j

tactic: simp only [tensor_id_comp_id_tensor]
state_before: C : Type u_3
inst✝³ : Category C
inst✝² : Preadditive C
inst✝¹ : MonoidalCategory C
inst✝ : MonoidalPreadditive C
P Q R S : C
J : Type u_1
s : Finset J
f : P ⟶ Q
g : J → (R ⟶ S)
tQ : (R ⟶ S) →+ (((tensoringLeft C).obj Q).obj R ⟶ ((tensoringLeft C).obj Q).obj S) :=
  Functor.mapAddHom ((tensoringLeft C).obj Q)
⊢ ∑ j in s, (f ⊗ 𝟙 R) ≫ (𝟙 Q ⊗ g j) = ∑ j in s, f ⊗ g j