tasksource/leandojo huggingface dataset:
Theorem: RatFunc.numDenom_div
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [numDenom, liftOn'_div, if_neg hq]
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ numDenom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) =
    (↑C (leadingCoeff (q / gcd p q))⁻¹ * (p / gcd p q), ↑C (leadingCoeff (q / gcd p q))⁻¹ * (q / gcd p q))

tactic: intro p
state_before: case f0
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ ∀ (p : K[X]),
    (if 0 = 0 then (0, 1)
      else
        let r := gcd p 0;
        (↑C (leadingCoeff (0 / r))⁻¹ * (p / r), ↑C (leadingCoeff (0 / r))⁻¹ * (0 / r))) =
      if 1 = 0 then (0, 1)
      else
        let r := gcd 0 1;
        (↑C (leadingCoeff (1 / r))⁻¹ * (0 / r), ↑C (leadingCoeff (1 / r))⁻¹ * (1 / r))

tactic: rw [if_pos rfl, if_neg (one_ne_zero' K[X])]
state_before: case f0
K : Type u
inst✝ : Field K
p✝ q : K[X]
hq : q ≠ 0
p : K[X]
⊢ (if 0 = 0 then (0, 1)
    else
      let r := gcd p 0;
      (↑C (leadingCoeff (0 / r))⁻¹ * (p / r), ↑C (leadingCoeff (0 / r))⁻¹ * (0 / r))) =
    if 1 = 0 then (0, 1)
    else
      let r := gcd 0 1;
      (↑C (leadingCoeff (1 / r))⁻¹ * (0 / r), ↑C (leadingCoeff (1 / r))⁻¹ * (1 / r))

tactic: simp
state_before: case f0
K : Type u
inst✝ : Field K
p✝ q : K[X]
hq : q ≠ 0
p : K[X]
⊢ (0, 1) =
    let r := gcd 0 1;
    (↑C (leadingCoeff (1 / r))⁻¹ * (0 / r), ↑C (leadingCoeff (1 / r))⁻¹ * (1 / r))
Theorem: smul_ne_zero_iff
File: Mathlib/Algebra/Module/Basic.lean

tactic: rw [Ne.def, smul_eq_zero, not_or]
state_before: α : Type ?u.267693
R : Type u_2
k : Type ?u.267699
S : Type ?u.267702
M : Type u_1
M₂ : Type ?u.267708
M₃ : Type ?u.267711
ι : Type ?u.267714
inst✝³ : Zero R
inst✝² : Zero M
inst✝¹ : SMulWithZero R M
inst✝ : NoZeroSMulDivisors R M
c : R
x : M
⊢ c • x ≠ 0 ↔ c ≠ 0 ∧ x ≠ 0
Theorem: Ordinal.le_add_right
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa only [add_zero] using add_le_add_left (Ordinal.zero_le b) a
state_before: α : Type ?u.162386
β : Type ?u.162389
γ : Type ?u.162392
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
⊢ a ≤ a + b
Theorem: Polynomial.support_map_of_injective
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp_rw [Finset.ext_iff, mem_support_iff, coeff_map, ← map_zero f, hf.ne_iff,
  forall_const]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
f : R →+* S
hf : Function.Injective ↑f
⊢ support (map f p) = support p
Theorem: MeasureTheory.SignedMeasure.someExistsOneDivLT_spec
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [someExistsOneDivLT, dif_pos hi]
state_before: α : Type u_1
β : Type ?u.5208
inst✝³ : MeasurableSpace α
M : Type ?u.5214
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
⊢ MeasureTheory.SignedMeasure.someExistsOneDivLT s i ⊆ i ∧
    MeasurableSet (MeasureTheory.SignedMeasure.someExistsOneDivLT s i) ∧
      1 / (↑(MeasureTheory.SignedMeasure.findExistsOneDivLT s i) + 1) <
        ↑s (MeasureTheory.SignedMeasure.someExistsOneDivLT s i)

tactic: exact Classical.choose_spec (findExistsOneDivLT_spec hi)
state_before: α : Type u_1
β : Type ?u.5208
inst✝³ : MeasurableSpace α
M : Type ?u.5214
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
⊢ Classical.choose
        (_ : MeasureTheory.SignedMeasure.ExistsOneDivLT s i (MeasureTheory.SignedMeasure.findExistsOneDivLT s i)) ⊆
      i ∧
    MeasurableSet
        (Classical.choose
          (_ : MeasureTheory.SignedMeasure.ExistsOneDivLT s i (MeasureTheory.SignedMeasure.findExistsOneDivLT s i))) ∧
      1 / (↑(MeasureTheory.SignedMeasure.findExistsOneDivLT s i) + 1) <
        ↑s
          (Classical.choose
            (_ : MeasureTheory.SignedMeasure.ExistsOneDivLT s i (MeasureTheory.SignedMeasure.findExistsOneDivLT s i)))
Theorem: Polynomial.eval₂_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp only [eval₂_eq_sum, sum, support_restriction, ← @coeff_restriction _ _ p, RingHom.comp_apply,
  Subring.coeSubtype]
state_before: R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
⊢ eval₂ f x p = eval₂ (RingHom.comp f (Subring.subtype (Subring.closure ↑(frange p)))) x (restriction p)
Theorem: SimpleGraph.Connected.pos_dist_of_ne
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

tactic: intro h
state_before: V : Type u_1
G : SimpleGraph V
u v : V
hconn : Connected G
hne : u ≠ v
⊢ dist G u v ≠ 0

tactic: exact False.elim (hne (hconn.dist_eq_zero_iff.mp h))
state_before: V : Type u_1
G : SimpleGraph V
u v : V
hconn : Connected G
hne : u ≠ v
h : dist G u v = 0
⊢ False
Theorem: OrderMonoidWithZeroHom.toOrderMonoidHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: convert FunLike.ext_iff.1 h using 0
state_before: F : Type ?u.123863
α : Type u_1
β : Type u_2
γ : Type ?u.123872
δ : Type ?u.123875
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulZeroOneClass α
inst✝² : MulZeroOneClass β
inst✝¹ : MulZeroOneClass γ
inst✝ : MulZeroOneClass δ
f✝ g✝ f g : α →*₀o β
h : toOrderMonoidHom f = toOrderMonoidHom g
⊢ ∀ (a : α), ↑f a = ↑g a
Theorem: inf_symmDiff_distrib_left
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_eq_sup_sdiff_inf, inf_sdiff_distrib_left, inf_sup_left, inf_inf_distrib_left,
  symmDiff_eq_sup_sdiff_inf]
state_before: ι : Type ?u.60196
α : Type u_1
β : Type ?u.60202
π : ι → Type ?u.60207
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ⊓ b ∆ c = (a ⊓ b) ∆ (a ⊓ c)
Theorem: Multiset.map_univ_coeEmbedding
File: Mathlib/Data/Multiset/Fintype.lean

tactic: ext ⟨x, i⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Finset.map (coeEmbedding m) Finset.univ = toEnumFinset m

tactic: simp only [Fin.exists_iff, Finset.mem_map, Finset.mem_univ, Multiset.coeEmbedding_apply,
  Prod.mk.inj_iff, exists_true_left, Multiset.exists_coe, Multiset.coe_mk, Fin.val_mk,
  exists_prop, exists_eq_right_right, exists_eq_right, Multiset.mem_toEnumFinset, iff_self_iff,
  true_and_iff]
state_before: case a.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
i : ℕ
⊢ (x, i) ∈ Finset.map (coeEmbedding m) Finset.univ ↔ (x, i) ∈ toEnumFinset m
Theorem: right_mem_openSegment_iff
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rw [openSegment_symm, left_mem_openSegment_iff, eq_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.178821
G : Type ?u.178824
ι : Type ?u.178827
π : ι → Type ?u.178832
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
x y : E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
⊢ y ∈ openSegment 𝕜 x y ↔ x = y
Theorem: padicValRat.multiplicity_sub_multiplicity
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [← finite_iff_dom, finite_nat_iff]
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ (multiplicity p q.den).Dom

tactic: exact ⟨hp, q.pos⟩
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den

tactic: rw [padicValRat, padicValInt.of_ne_one_ne_zero hp, padicValNat, dif_pos]
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ padicValRat p q =
    ↑(Part.get (multiplicity (↑p) q.num) (_ : multiplicity.Finite (↑p) q.num)) -
      ↑(Part.get (multiplicity p q.den) (_ : (multiplicity p q.den).Dom))

tactic: exact ⟨hp, q.pos⟩
state_before: case hc
p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den

tactic: exact Rat.num_ne_zero_of_ne_zero hq
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ q.num ≠ 0
Theorem: CategoryTheory.SimplicialObject.σ_comp_σ
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ σ X j ≫ σ X (↑Fin.castSucc i) = σ X i ≫ σ X (Fin.succ j)

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.σ_comp_σ H]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ X.map (SimplexCategory.σ j).op ≫ X.map (SimplexCategory.σ (↑Fin.castSucc i)).op =
    X.map (SimplexCategory.σ i).op ≫ X.map (SimplexCategory.σ (Fin.succ j)).op
Theorem: Matrix.updateRow_submatrix_equiv
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext (i' j)
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type ?u.1234961
n' : o → Type ?u.1234966
R : Type ?u.1234969
S : Type ?u.1234972
α : Type v
β : Type w
γ : Type ?u.1234979
M : Matrix m n α
i✝ : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq l
inst✝ : DecidableEq m
A : Matrix m n α
i : l
r : o → α
e : l ≃ m
f : o ≃ n
⊢ updateRow (submatrix A ↑e ↑f) i r = submatrix (updateRow A (↑e i) fun j => r (↑f.symm j)) ↑e ↑f

tactic: simp only [submatrix_apply, updateRow_apply, Equiv.apply_eq_iff_eq, Equiv.symm_apply_apply]
state_before: case a.h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type ?u.1234961
n' : o → Type ?u.1234966
R : Type ?u.1234969
S : Type ?u.1234972
α : Type v
β : Type w
γ : Type ?u.1234979
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq l
inst✝ : DecidableEq m
A : Matrix m n α
i : l
r : o → α
e : l ≃ m
f : o ≃ n
i' : l
j : o
⊢ updateRow (submatrix A ↑e ↑f) i r i' j = submatrix (updateRow A (↑e i) fun j => r (↑f.symm j)) (↑e) (↑f) i' j
Theorem: List.length_mem_cyclicPermutations
File: Mathlib/Data/List/Rotate.lean

tactic: obtain ⟨k, hk, rfl⟩ := nthLe_of_mem h
state_before: α : Type u
l✝ l' l : List α
h : l' ∈ cyclicPermutations l
⊢ length l' = length l

tactic: simp
state_before: case intro.intro
α : Type u
l✝ l : List α
k : ℕ
hk : k < length (cyclicPermutations l)
h : nthLe (cyclicPermutations l) k hk ∈ cyclicPermutations l
⊢ length (nthLe (cyclicPermutations l) k hk) = length l
Theorem: PowerSeries.map_invUnitsSub
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: ext
state_before: R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
u : Rˣ
⊢ ↑(map f) (invUnitsSub u) = invUnitsSub (↑(Units.map ↑f) u)

tactic: simp only [← map_pow, coeff_map, coeff_invUnitsSub, one_divp]
state_before: case h
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
u : Rˣ
n✝ : ℕ
⊢ ↑(coeff S n✝) (↑(map f) (invUnitsSub u)) = ↑(coeff S n✝) (invUnitsSub (↑(Units.map ↑f) u))

tactic: rfl
state_before: case h
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
u : Rˣ
n✝ : ℕ
⊢ ↑f ↑(u ^ (n✝ + 1))⁻¹ = ↑(↑(Units.map ↑f) (u ^ (n✝ + 1)))⁻¹
Theorem: Finset.sup_le_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: apply Iff.trans Multiset.sup_le
state_before: F : Type ?u.33148
α : Type u_1
β : Type u_2
γ : Type ?u.33157
ι : Type ?u.33160
κ : Type ?u.33163
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ sup s f ≤ a ↔ ∀ (b : β), b ∈ s → f b ≤ a

tactic: simp only [Multiset.mem_map, and_imp, exists_imp]
state_before: F : Type ?u.33148
α : Type u_1
β : Type u_2
γ : Type ?u.33157
ι : Type ?u.33160
κ : Type ?u.33163
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ (b : α), b ∈ Multiset.map f s.val → b ≤ a) ↔ ∀ (b : β), b ∈ s → f b ≤ a

tactic: exact ⟨fun k b hb => k _ _ hb rfl, fun k a' b hb h => h ▸ k _ hb⟩
state_before: F : Type ?u.33148
α : Type u_1
β : Type u_2
γ : Type ?u.33157
ι : Type ?u.33160
κ : Type ?u.33163
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ (b : α) (x : β), x ∈ s.val → f x = b → b ≤ a) ↔ ∀ (b : β), b ∈ s → f b ≤ a
Theorem: Polynomial.Monic.ne_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rintro rfl
state_before: R✝ : Type u
S : Type v
a b c d : R✝
n m : ℕ
inst✝² : Semiring R✝
p✝ q : R✝[X]
ι : Type ?u.645873
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p : R[X]
hp : Monic p
⊢ p ≠ 0

tactic: simp [Monic] at hp
state_before: R✝ : Type u
S : Type v
a b c d : R✝
n m : ℕ
inst✝² : Semiring R✝
p q : R✝[X]
ι : Type ?u.645873
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
hp : Monic 0
⊢ False
Theorem: Finset.prod_range_sub_prod_range
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [← prod_Ico_eq_div f hnm]
state_before: α✝ : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → β
inst✝¹ : CommMonoid β
α : Type u_1
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ (∏ k in range m, f k) / ∏ k in range n, f k = ∏ k in filter (fun k => n ≤ k) (range m), f k

tactic: congr
state_before: α✝ : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → β
inst✝¹ : CommMonoid β
α : Type u_1
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∏ k in Ico n m, f k = ∏ k in filter (fun k => n ≤ k) (range m), f k

tactic: apply Finset.ext
state_before: case e_s
α✝ : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → β
inst✝¹ : CommMonoid β
α : Type u_1
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ Ico n m = filter (fun k => n ≤ k) (range m)

tactic: simp only [mem_Ico, mem_filter, mem_range, *]
state_before: case e_s.a
α✝ : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → β
inst✝¹ : CommMonoid β
α : Type u_1
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), a ∈ Ico n m ↔ a ∈ filter (fun k => n ≤ k) (range m)

tactic: tauto
state_before: case e_s.a
α✝ : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → β
inst✝¹ : CommMonoid β
α : Type u_1
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), n ≤ a ∧ a < m ↔ a < m ∧ n ≤ a
Theorem: Multiset.le_inter
File: Mathlib/Data/Multiset/Basic.lean

tactic: revert s u
state_before: α : Type u_1
β : Type ?u.175213
γ : Type ?u.175216
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
h₁ : s ≤ t
h₂ : s ≤ u
⊢ s ≤ t ∩ u

tactic: refine @(Multiset.induction_on t ?_ fun a t IH => ?_) <;> intros s u h₁ h₂
state_before: α : Type u_1
β : Type ?u.175213
γ : Type ?u.175216
inst✝ : DecidableEq α
t : Multiset α
a b : α
⊢ ∀ {s u : Multiset α}, s ≤ t → s ≤ u → s ≤ t ∩ u

tactic: by_cases h : a ∈ u
state_before: case refine_2
α : Type u_1
β : Type ?u.175213
γ : Type ?u.175216
inst✝ : DecidableEq α
t✝ : Multiset α
a✝ b a : α
t : Multiset α
IH : ∀ {s u : Multiset α}, s ≤ t → s ≤ u → s ≤ t ∩ u
s u : Multiset α
h₁ : s ≤ a ::ₘ t
h₂ : s ≤ u
⊢ s ≤ (a ::ₘ t) ∩ u

tactic: simpa only [zero_inter, nonpos_iff_eq_zero] using h₁
state_before: case refine_1
α : Type u_1
β : Type ?u.175213
γ : Type ?u.175216
inst✝ : DecidableEq α
t : Multiset α
a b : α
s u : Multiset α
h₁ : s ≤ 0
h₂ : s ≤ u
⊢ s ≤ 0 ∩ u

tactic: rw [cons_inter_of_pos _ h, ← erase_le_iff_le_cons]
state_before: case pos
α : Type u_1
β : Type ?u.175213
γ : Type ?u.175216
inst✝ : DecidableEq α
t✝ : Multiset α
a✝ b a : α
t : Multiset α
IH : ∀ {s u : Multiset α}, s ≤ t → s ≤ u → s ≤ t ∩ u
s u : Multiset α
h₁ : s ≤ a ::ₘ t
h₂ : s ≤ u
h : a ∈ u
⊢ s ≤ (a ::ₘ t) ∩ u

tactic: exact IH (erase_le_iff_le_cons.2 h₁) (erase_le_erase _ h₂)
state_before: case pos
α : Type u_1
β : Type ?u.175213
γ : Type ?u.175216
inst✝ : DecidableEq α
t✝ : Multiset α
a✝ b a : α
t : Multiset α
IH : ∀ {s u : Multiset α}, s ≤ t → s ≤ u → s ≤ t ∩ u
s u : Multiset α
h₁ : s ≤ a ::ₘ t
h₂ : s ≤ u
h : a ∈ u
⊢ erase s a ≤ t ∩ erase u a

tactic: rw [cons_inter_of_neg _ h]
state_before: case neg
α : Type u_1
β : Type ?u.175213
γ : Type ?u.175216
inst✝ : DecidableEq α
t✝ : Multiset α
a✝ b a : α
t : Multiset α
IH : ∀ {s u : Multiset α}, s ≤ t → s ≤ u → s ≤ t ∩ u
s u : Multiset α
h₁ : s ≤ a ::ₘ t
h₂ : s ≤ u
h : ¬a ∈ u
⊢ s ≤ (a ::ₘ t) ∩ u

tactic: exact IH ((le_cons_of_not_mem <| mt (mem_of_le h₂) h).1 h₁) h₂
state_before: case neg
α : Type u_1
β : Type ?u.175213
γ : Type ?u.175216
inst✝ : DecidableEq α
t✝ : Multiset α
a✝ b a : α
t : Multiset α
IH : ∀ {s u : Multiset α}, s ≤ t → s ≤ u → s ≤ t ∩ u
s u : Multiset α
h₁ : s ≤ a ::ₘ t
h₂ : s ≤ u
h : ¬a ∈ u
⊢ s ≤ t ∩ u
Theorem: Multiset.card_product
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [SProd.sprod, product]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.63999
δ : Type ?u.64002
a : α
b : β
s : Multiset α
t : Multiset β
⊢ ↑card (s ×ˢ t) = ↑card s * ↑card t
Theorem: MeasureTheory.lintegral_nnnorm_neg
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [Pi.neg_apply, nnnorm_neg]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.697339
δ : Type ?u.697342
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
⊢ (∫⁻ (a : α), ↑‖(-f) a‖₊ ∂μ) = ∫⁻ (a : α), ↑‖f a‖₊ ∂μ
Theorem: iteratedFDeriv_apply_eq_iteratedDeriv_mul_prod
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: rw [iteratedDeriv_eq_iteratedFDeriv, ← ContinuousMultilinearMap.map_smul_univ]
state_before: 𝕜 : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_1
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.103039
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
m : Fin n → 𝕜
⊢ ↑(iteratedFDeriv 𝕜 n f x) m = (∏ i : Fin n, m i) • iteratedDeriv n f x

tactic: simp
state_before: 𝕜 : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_1
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.103039
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
m : Fin n → 𝕜
⊢ ↑(iteratedFDeriv 𝕜 n f x) m = ↑(iteratedFDeriv 𝕜 n f x) fun i => m i • 1
Theorem: Nat.factorization_le_iff_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: constructor
state_before: d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ factorization d ≤ factorization n ↔ d ∣ n

tactic: intro hdn
state_before: case mp
d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ factorization d ≤ factorization n → d ∣ n

tactic: set K := n.factorization - d.factorization with hK
state_before: case mp
d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
hdn : factorization d ≤ factorization n
⊢ d ∣ n

tactic: rw [← factorization_prod_pow_eq_self hn, ← factorization_prod_pow_eq_self hd,
    ←Finsupp.prod_add_index' pow_zero pow_add, hK, add_tsub_cancel_of_le hdn]
state_before: case mp
d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
hdn : factorization d ≤ factorization n
K : ℕ →₀ ℕ := factorization n - factorization d
hK : K = factorization n - factorization d
⊢ n = d * Finsupp.prod K fun x x_1 => x ^ x_1

tactic: rintro ⟨c, rfl⟩
state_before: case mpr
d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ d ∣ n → factorization d ≤ factorization n

tactic: rw [factorization_mul hd (right_ne_zero_of_mul hn)]
state_before: case mpr.intro
d : ℕ
hd : d ≠ 0
c : ℕ
hn : d * c ≠ 0
⊢ factorization d ≤ factorization (d * c)

tactic: simp
state_before: case mpr.intro
d : ℕ
hd : d ≠ 0
c : ℕ
hn : d * c ≠ 0
⊢ factorization d ≤ factorization d + factorization c
Theorem: String.modify_of_valid
File: Std/Data/String/Lemmas.lean

tactic: rw [modify, set_of_valid, get_of_valid]
state_before: f : Char → Char
cs cs' : List Char
⊢ modify { data := cs ++ cs' } { byteIdx := utf8Len cs } f = { data := cs ++ List.modifyHead f cs' }

tactic: cases cs' <;> rfl
state_before: f : Char → Char
cs cs' : List Char
⊢ { data := cs ++ List.modifyHead (fun x => f (List.headD cs' default)) cs' } = { data := cs ++ List.modifyHead f cs' }
Theorem: CauSeq.smul_equiv_smul
File: Mathlib/Data/Real/CauSeq.lean

tactic: simpa [const_smul, smul_one_mul _ _] using
  mul_equiv_mul (const_equiv.mpr <| Eq.refl <| c • (1 : β)) hf
state_before: α : Type u_3
β : Type u_2
inst✝⁴ : LinearOrderedField α
inst✝³ : Ring β
abv : β → α
inst✝² : IsAbsoluteValue abv
G : Type u_1
inst✝¹ : SMul G β
inst✝ : IsScalarTower G β β
f1 f2 : CauSeq β abv
c : G
hf : f1 ≈ f2
⊢ c • f1 ≈ c • f2
Theorem: Polynomial.isUnit_of_self_mul_dvd_separable
File: Mathlib/FieldTheory/Separable.lean

tactic: obtain ⟨p, rfl⟩ := hq
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hp : Separable p
hq : q * q ∣ p
⊢ IsUnit q

tactic: apply isCoprime_self.mp
state_before: case intro
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
q p : R[X]
hp : Separable (q * q * p)
⊢ IsUnit q

tactic: have : IsCoprime (q * (q * p))
    (q * (derivative q * p + derivative q * p + q * derivative p)) := by
  simp only [← mul_assoc, mul_add]
  dsimp only [Separable] at hp
  convert hp using 1
  rw [derivative_mul, derivative_mul]
  ring
state_before: case intro
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
q p : R[X]
hp : Separable (q * q * p)
⊢ IsCoprime q q

tactic: exact IsCoprime.of_mul_right_left (IsCoprime.of_mul_left_left this)
state_before: case intro
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
q p : R[X]
hp : Separable (q * q * p)
this : IsCoprime (q * (q * p)) (q * (↑derivative q * p + ↑derivative q * p + q * ↑derivative p))
⊢ IsCoprime q q

tactic: simp only [← mul_assoc, mul_add]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
q p : R[X]
hp : Separable (q * q * p)
⊢ IsCoprime (q * (q * p)) (q * (↑derivative q * p + ↑derivative q * p + q * ↑derivative p))

tactic: dsimp only [Separable] at hp
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
q p : R[X]
hp : Separable (q * q * p)
⊢ IsCoprime (q * q * p) (q * ↑derivative q * p + q * ↑derivative q * p + q * q * ↑derivative p)

tactic: convert hp using 1
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
q p : R[X]
hp : IsCoprime (q * q * p) (↑derivative (q * q * p))
⊢ IsCoprime (q * q * p) (q * ↑derivative q * p + q * ↑derivative q * p + q * q * ↑derivative p)

tactic: rw [derivative_mul, derivative_mul]
state_before: case h.e'_4
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
q p : R[X]
hp : IsCoprime (q * q * p) (↑derivative (q * q * p))
⊢ q * ↑derivative q * p + q * ↑derivative q * p + q * q * ↑derivative p = ↑derivative (q * q * p)

tactic: ring
state_before: case h.e'_4
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
q p : R[X]
hp : IsCoprime (q * q * p) (↑derivative (q * q * p))
⊢ q * ↑derivative q * p + q * ↑derivative q * p + q * q * ↑derivative p =
    (↑derivative q * q + q * ↑derivative q) * p + q * q * ↑derivative p
Theorem: Associates.mem_factorSet_some
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: dsimp only [Membership.mem]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
p : Associates α
hp : Irreducible p
l : Multiset { a // Irreducible a }
⊢ p ∈ ↑l ↔ { val := p, property := hp } ∈ l

tactic: dsimp only [FactorSetMem]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
p : Associates α
hp : Irreducible p
l : Multiset { a // Irreducible a }
⊢ FactorSetMem p ↑l ↔ Mem { val := p, property := hp } l

tactic: split_ifs
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
p : Associates α
hp : Irreducible p
l : Multiset { a // Irreducible a }
⊢ (if hp : Irreducible p then BfactorSetMem { val := p, property := hp } ↑l else False) ↔
    Mem { val := p, property := hp } l

tactic: rfl
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
p : Associates α
hp : Irreducible p
l : Multiset { a // Irreducible a }
⊢ BfactorSetMem { val := p, property := hp } ↑l ↔ Mem { val := p, property := hp } l
Theorem: Ideal.quotientMap_comp_mk
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: simp only [Function.comp_apply, RingHom.coe_comp, Ideal.quotientMap_mk]
state_before: R : Type u
S : Type v
F : Type w
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
R₁ : Type ?u.1203035
R₂ : Type ?u.1203038
A : Type ?u.1203041
B : Type ?u.1203044
inst✝⁶ : CommSemiring R₁
inst✝⁵ : CommSemiring R₂
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R₁ A
inst✝¹ : Algebra R₂ A
inst✝ : Algebra R₁ B
J : Ideal R
I : Ideal S
f : R →+* S
H : J ≤ comap f I
x : R
⊢ ↑(RingHom.comp (quotientMap I f H) (Quotient.mk J)) x = ↑(RingHom.comp (Quotient.mk I) f) x