tasksource/leandojo huggingface dataset:
Theorem: FreeAbelianGroup.support_nsmul
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: apply support_zsmul k _ a
state_before: X : Type u_1
k : ℕ
h : k ≠ 0
a : FreeAbelianGroup X
⊢ support (k • a) = support a

tactic: exact_mod_cast h
state_before: X : Type u_1
k : ℕ
h : k ≠ 0
a : FreeAbelianGroup X
⊢ ↑k ≠ 0
Theorem: MvPolynomial.derivation_C_mul
File: Mathlib/Data/MvPolynomial/Derivation.lean

tactic: rw [C_mul', D.map_smul]
state_before: σ : Type u_2
R : Type u_1
A : Type u_3
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid A
inst✝¹ : Module R A
inst✝ : Module (MvPolynomial σ R) A
D : Derivation R (MvPolynomial σ R) A
a : R
f : MvPolynomial σ R
⊢ ↑D (↑C a * f) = a • ↑D f
Theorem: mul_lt_of_one_lt_right
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [mul_one] using mul_lt_mul_of_neg_left h ha
state_before: α : Type u
β : Type ?u.89024
inst✝ : StrictOrderedRing α
a b c : α
ha : a < 0
h : 1 < b
⊢ a * b < a
Theorem: Nat.Partrec.Code.encode_lt_prec
File: Mathlib/Computability/PartrecCode.lean

tactic: suffices
state_before: cf cg : Code
⊢ encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg)

tactic: exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this
state_before: cf cg : Code
this : ?m.360436
⊢ encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg)

case this
cf cg : Code
⊢ ?m.360436

tactic: change _
state_before: case this
cf cg : Code
⊢ encode (pair cf cg) < encode (prec cf cg)

tactic: simp [encodeCode_eq, encodeCode]
state_before: case this
cf cg : Code
⊢ encode (pair cf cg) < encode (prec cf cg)
Theorem: Nat.coprime.gcd_mul_left_cancel_right
File: Std/Data/Nat/Gcd.lean

tactic: rw [gcd_comm m n, gcd_comm m (k * n), H.gcd_mul_left_cancel n]
state_before: k m n : Nat
H : coprime k m
⊢ gcd m (k * n) = gcd m n
Theorem: Int.ceil_add_ceil_le
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← le_sub_iff_add_le, ceil_le, Int.cast_sub, Int.cast_add, Int.cast_one, le_sub_comm]
state_before: F : Type ?u.218257
α : Type u_1
β : Type ?u.218263
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ⌈a⌉ + ⌈b⌉ ≤ ⌈a + b⌉ + 1

tactic: refine' (ceil_lt_add_one _).le.trans _
state_before: F : Type ?u.218257
α : Type u_1
β : Type ?u.218263
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌈b⌉ ≤ ↑⌈a + b⌉ + 1 - a

tactic: rw [le_sub_iff_add_le', ← add_assoc, add_le_add_iff_right]
state_before: F : Type ?u.218257
α : Type u_1
β : Type ?u.218263
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ b + 1 ≤ ↑⌈a + b⌉ + 1 - a

tactic: exact le_ceil _
state_before: F : Type ?u.218257
α : Type u_1
β : Type ?u.218263
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ a + b ≤ ↑⌈a + b⌉
Theorem: Orientation.measure_eq_volume
File: Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean

tactic: have A : o.volumeForm.measure (stdOrthonormalBasis ℝ F).toBasis.parallelepiped = 1 :=
  Orientation.measure_orthonormalBasis o (stdOrthonormalBasis ℝ F)
state_before: ι : Type ?u.6740
F : Type u_1
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
m n : ℕ
_i : Fact (finrank ℝ F = n)
o : Orientation ℝ F (Fin n)
⊢ AlternatingMap.measure (volumeForm o) = volume

tactic: rw [addHaarMeasure_unique o.volumeForm.measure
  (stdOrthonormalBasis ℝ F).toBasis.parallelepiped, A, one_smul]
state_before: ι : Type ?u.6740
F : Type u_1
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
m n : ℕ
_i : Fact (finrank ℝ F = n)
o : Orientation ℝ F (Fin n)
A :
  ↑↑(AlternatingMap.measure (volumeForm o))
      ↑(Basis.parallelepiped (OrthonormalBasis.toBasis (stdOrthonormalBasis ℝ F))) =
    1
⊢ AlternatingMap.measure (volumeForm o) = volume

tactic: simp only [volume, Basis.addHaar]
state_before: ι : Type ?u.6740
F : Type u_1
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
m n : ℕ
_i : Fact (finrank ℝ F = n)
o : Orientation ℝ F (Fin n)
A :
  ↑↑(AlternatingMap.measure (volumeForm o))
      ↑(Basis.parallelepiped (OrthonormalBasis.toBasis (stdOrthonormalBasis ℝ F))) =
    1
⊢ addHaarMeasure (Basis.parallelepiped (OrthonormalBasis.toBasis (stdOrthonormalBasis ℝ F))) = volume
Theorem: MonoidHom.mker_prod_map
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: rw [← comap_bot', ← comap_bot', ← comap_bot', ← prod_map_comap_prod', bot_prod_bot]
state_before: M : Type u_3
N : Type u_4
P : Type ?u.142244
inst✝⁵ : MulOneClass M
inst✝⁴ : MulOneClass N
inst✝³ : MulOneClass P
S : Submonoid M
A : Type ?u.142265
inst✝² : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.142289
mc : MonoidHomClass F M N
M' : Type u_1
N' : Type u_2
inst✝¹ : MulOneClass M'
inst✝ : MulOneClass N'
f : M →* N
g : M' →* N'
⊢ mker (prodMap f g) = prod (mker f) (mker g)
Theorem: Multiset.mem_inter
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← cons_erase h₁, cons_inter_of_pos _ h₂]
state_before: α : Type u_1
β : Type ?u.176256
γ : Type ?u.176259
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
x✝ : a ∈ s ∧ a ∈ t
h₁ : a ∈ s
h₂ : a ∈ t
⊢ a ∈ s ∩ t

tactic: apply mem_cons_self
state_before: α : Type u_1
β : Type ?u.176256
γ : Type ?u.176259
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
x✝ : a ∈ s ∧ a ∈ t
h₁ : a ∈ s
h₂ : a ∈ t
⊢ a ∈ a ::ₘ erase s a ∩ erase t a
Theorem: inv_mul_lt_of_lt_mul₀
File: Mathlib/Algebra/Order/WithZero.lean

tactic: rw [mul_comm] at *
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : x < y * z
⊢ y⁻¹ * x < z

tactic: exact mul_inv_lt_of_lt_mul₀ h
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : x < z * y
⊢ x * y⁻¹ < z
Theorem: BoundedContinuousFunction.lipschitz_comp
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: gcongr
state_before: F : Type ?u.376927
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f✝ g✝ : α →ᵇ β
x✝ : α
C✝ : ℝ
G : β → γ
C : ℝ≥0
H : LipschitzWith C G
f g : α →ᵇ β
x : α
⊢ ↑C * dist (↑f x) (↑g x) ≤ ↑C * dist f g

tactic: apply dist_coe_le_dist
state_before: case h
F : Type ?u.376927
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f✝ g✝ : α →ᵇ β
x✝ : α
C✝ : ℝ
G : β → γ
C : ℝ≥0
H : LipschitzWith C G
f g : α →ᵇ β
x : α
⊢ dist (↑f x) (↑g x) ≤ dist f g
Theorem: CategoryTheory.Equalizer.Sieve.w
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: apply limit.hom_ext
state_before: C : Type u₁
inst✝ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
⊢ forkMap P S.arrows ≫ firstMap P S = forkMap P S.arrows ≫ secondMap P S

tactic: rintro ⟨Y, Z, g, f, hf⟩
state_before: case w
C : Type u₁
inst✝ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
⊢ ∀ (j : Discrete ((Y : C) × (Z : C) × (_ : Z ⟶ Y) × { f' // S.arrows f' })),
    (forkMap P S.arrows ≫ firstMap P S) ≫ limit.π (Discrete.functor fun f => P.obj f.snd.fst.op) j =
      (forkMap P S.arrows ≫ secondMap P S) ≫ limit.π (Discrete.functor fun f => P.obj f.snd.fst.op) j

tactic: simp [firstMap, secondMap, forkMap]
state_before: case w.mk.mk.mk.mk.mk
C : Type u₁
inst✝ : Category C
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
X : C
R : Presieve X
S : Sieve X
Y Z : C
g : Z ⟶ Y
f : Y ⟶ X
hf : S.arrows f
⊢ (forkMap P S.arrows ≫ firstMap P S) ≫
      limit.π (Discrete.functor fun f => P.obj f.snd.fst.op)
        { as := { fst := Y, snd := { fst := Z, snd := { fst := g, snd := { val := f, property := hf } } } } } =
    (forkMap P S.arrows ≫ secondMap P S) ≫
      limit.π (Discrete.functor fun f => P.obj f.snd.fst.op)
        { as := { fst := Y, snd := { fst := Z, snd := { fst := g, snd := { val := f, property := hf } } } } }
Theorem: Polynomial.erase_zero
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ (erase n 0).toFinsupp = 0.toFinsupp

tactic: exact Finsupp.erase_zero n
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ Finsupp.erase n 0 = 0
Theorem: Set.Finite.exists_finset_coe
File: Mathlib/Data/Set/Finite.lean

tactic: cases h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
h : Set.Finite s
⊢ ∃ s', ↑s' = s

tactic: exact ⟨s.toFinset, s.coe_toFinset⟩
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
a✝ : Fintype ↑s
⊢ ∃ s', ↑s' = s
Theorem: Nat.ArithmeticFunction.isMultiplicative_zeta
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp
state_before: R : Type ?u.536824
⊢ ↑ζ 1 = 1

tactic: simp (config := { contextual := true })
state_before: R : Type ?u.536824
⊢ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → coprime m n → ↑ζ (m * n) = ↑ζ m * ↑ζ n
Theorem: MeasureTheory.lintegral_finset
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [lintegral_countable _ s.countable_toSet, ← Finset.tsum_subtype']
state_before: α : Type u_1
β : Type ?u.1733020
γ : Type ?u.1733023
δ : Type ?u.1733026
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSingletonClass α
s : Finset α
f : α → ℝ≥0∞
⊢ (∫⁻ (x : α) in ↑s, f x ∂μ) = ∑ x in s, f x * ↑↑μ {x}
Theorem: Std.RBNode.modify_eq_alter
File: Std/Data/RBMap/Alter.lean

tactic: simp [modify, alter]
state_before: α : Type u_1
cut : α → Ordering
f : α → α
t : RBNode α
⊢ modify cut f t = alter cut (Option.map f) t

tactic: split <;> simp [Option.map]
state_before: α : Type u_1
cut : α → Ordering
f : α → α
t : RBNode α
⊢ (match zoom cut t Path.root with
    | (nil, snd) => t
    | (node c a x b, path) => Path.fill path (node c a (f x) b)) =
    match zoom cut t Path.root with
    | (nil, path) =>
      match Option.map f none with
      | none => t
      | some y => Path.insertNew path y
    | (node c a x b, path) =>
      match Option.map f (some x) with
      | none => Path.del path (append a b) c
      | some y => Path.fill path (node c a y b)
Theorem: essSup_smul_measure
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: simp_rw [essSup]
state_before: α : Type u_2
β : Type u_1
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
c : ℝ≥0∞
hc : c ≠ 0
⊢ essSup f (c • μ) = essSup f μ

tactic: suffices h_smul : (c • μ).ae = μ.ae
state_before: α : Type u_2
β : Type u_1
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
c : ℝ≥0∞
hc : c ≠ 0
⊢ limsup f (Measure.ae (c • μ)) = limsup f (Measure.ae μ)

tactic: ext1
state_before: case h_smul
α : Type u_2
β : Type u_1
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
c : ℝ≥0∞
hc : c ≠ 0
⊢ Measure.ae (c • μ) = Measure.ae μ

tactic: simp_rw [mem_ae_iff]
state_before: case h_smul.a
α : Type u_2
β : Type u_1
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
c : ℝ≥0∞
hc : c ≠ 0
s✝ : Set α
⊢ s✝ ∈ Measure.ae (c • μ) ↔ s✝ ∈ Measure.ae μ

tactic: simp [hc]
state_before: case h_smul.a
α : Type u_2
β : Type u_1
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
c : ℝ≥0∞
hc : c ≠ 0
s✝ : Set α
⊢ ↑↑(c • μ) (s✝ᶜ) = 0 ↔ ↑↑μ (s✝ᶜ) = 0

tactic: rw [h_smul]
state_before: α : Type u_2
β : Type u_1
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
c : ℝ≥0∞
hc : c ≠ 0
h_smul : Measure.ae (c • μ) = Measure.ae μ
⊢ limsup f (Measure.ae (c • μ)) = limsup f (Measure.ae μ)
Theorem: List.get?_zero
File: Std/Data/List/Lemmas.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
l : List α
⊢ get? l 0 = head? l
Theorem: ZNum.zneg_succ
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> try { rfl }
state_before: α : Type ?u.658662
n : ZNum
⊢ -succ n = pred (-n)

tactic: rw [succ, Num.zneg_toZNumNeg]
state_before: case neg
α : Type ?u.658662
a✝ : PosNum
⊢ -succ (neg a✝) = pred (-neg a✝)

tactic: rfl
state_before: case neg
α : Type ?u.658662
a✝ : PosNum
⊢ Num.toZNum (pred' a✝) = pred (-neg a✝)
Theorem: Ordinal.log_opow_mul_add
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: have hne' := (opow_mul_add_pos (zero_lt_one.trans hb).ne' u hv w).ne'
state_before: b u v w : Ordinal
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
⊢ log b (b ^ u * v + w) = u

tactic: by_contra' hne
state_before: b u v w : Ordinal
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
⊢ log b (b ^ u * v + w) = u

tactic: cases' lt_or_gt_of_ne hne with h h
state_before: b u v w : Ordinal
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : ¬log b (b ^ u * v + w) = u
⊢ False

tactic: rw [← lt_opow_iff_log_lt hb hne'] at h
state_before: case inl
b u v w : Ordinal
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : ¬log b (b ^ u * v + w) = u
h : log b (b ^ u * v + w) < u
⊢ False

tactic: exact h.not_le ((le_mul_left _ (Ordinal.pos_iff_ne_zero.2 hv)).trans (le_add_right _ _))
state_before: case inl
b u v w : Ordinal
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : ¬log b (b ^ u * v + w) = u
h : b ^ u * v + w < b ^ u
⊢ False

tactic: conv at h => change u < log b (b ^ u * v + w)
state_before: case inr
b u v w : Ordinal
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : ¬log b (b ^ u * v + w) = u
h : log b (b ^ u * v + w) > u
⊢ False

tactic: rw [← succ_le_iff, ← opow_le_iff_le_log hb hne'] at h
state_before: case inr
b u v w : Ordinal
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : ¬log b (b ^ u * v + w) = u
h : u < log b (b ^ u * v + w)
⊢ False

tactic: exact (not_lt_of_le h) (opow_mul_add_lt_opow_succ hvb hw)
state_before: case inr
b u v w : Ordinal
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : ¬log b (b ^ u * v + w) = u
h✝ : u < log b (b ^ u * v + w)
h : b ^ succ u ≤ b ^ u * v + w
⊢ False
Theorem: Ordinal.limitRecOn_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [limitRecOn, lt_wf.fix_eq, dif_neg h.1, dif_neg (not_succ_of_isLimit h)]
state_before: α : Type ?u.97233
β : Type ?u.97236
γ : Type ?u.97239
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
C : Ordinal → Sort u_2
o : Ordinal
H₁ : C 0
H₂ : (o : Ordinal) → C o → C (succ o)
H₃ : (o : Ordinal) → IsLimit o → ((o' : Ordinal) → o' < o → C o') → C o
h : IsLimit o
⊢ limitRecOn o H₁ H₂ H₃ = H₃ o h fun x _h => limitRecOn x H₁ H₂ H₃

tactic: rfl
state_before: α : Type ?u.97233
β : Type ?u.97236
γ : Type ?u.97239
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
C : Ordinal → Sort u_2
o : Ordinal
H₁ : C 0
H₂ : (o : Ordinal) → C o → C (succ o)
H₃ : (o : Ordinal) → IsLimit o → ((o' : Ordinal) → o' < o → C o') → C o
h : IsLimit o
⊢ (H₃ o (_ : o ≠ 0 ∧ ∀ (a : Ordinal), a < o → succ a < o) fun y x =>
      WellFounded.fix lt_wf
        (fun o IH =>
          if o0 : o = 0 then Eq.mpr (_ : C o = C 0) H₁
          else
            if h : ∃ a, o = succ a then
              Eq.mpr (_ : C o = C (succ (pred o))) (H₂ (pred o) (IH (pred o) (_ : pred o < o)))
            else H₃ o (_ : o ≠ 0 ∧ ∀ (a : Ordinal), a < o → succ a < o) IH)
        y) =
    H₃ o h fun x _h => limitRecOn x H₁ H₂ H₃
Theorem: Subgroup.mem_map
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: erw [mem_image_iff_bex]
state_before: G : Type u_1
G' : Type ?u.242723
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.242732
inst✝² : AddGroup A
H K✝ : Subgroup G
k : Set G
N : Type u_2
inst✝¹ : Group N
P : Type ?u.242759
inst✝ : Group P
f : G →* N
K : Subgroup G
y : N
⊢ y ∈ map f K ↔ ∃ x, x ∈ K ∧ ↑f x = y

tactic: simp
state_before: G : Type u_1
G' : Type ?u.242723
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.242732
inst✝² : AddGroup A
H K✝ : Subgroup G
k : Set G
N : Type u_2
inst✝¹ : Group N
P : Type ?u.242759
inst✝ : Group P
f : G →* N
K : Subgroup G
y : N
⊢ (∃ x x_1, ↑f x = y) ↔ ∃ x, x ∈ K ∧ ↑f x = y
Theorem: Polynomial.EisensteinCriterionAux.isUnit_of_natDegree_eq_zero_of_isPrimitive
File: Mathlib/RingTheory/EisensteinCriterion.lean

tactic: rw [eq_C_of_degree_le_zero (natDegree_eq_zero_iff_degree_le_zero.1 hpm), isUnit_C]
state_before: R : Type u_1
inst✝ : CommRing R
p q : R[X]
hu : IsPrimitive (p * q)
hpm : natDegree p = 0
⊢ IsUnit p

tactic: refine' hu _ _
state_before: R : Type u_1
inst✝ : CommRing R
p q : R[X]
hu : IsPrimitive (p * q)
hpm : natDegree p = 0
⊢ IsUnit (coeff p 0)

tactic: rw [← eq_C_of_degree_le_zero (natDegree_eq_zero_iff_degree_le_zero.1 hpm)]
state_before: R : Type u_1
inst✝ : CommRing R
p q : R[X]
hu : IsPrimitive (p * q)
hpm : natDegree p = 0
⊢ ↑C (coeff p 0) ∣ p * q

tactic: exact dvd_mul_right _ _
state_before: R : Type u_1
inst✝ : CommRing R
p q : R[X]
hu : IsPrimitive (p * q)
hpm : natDegree p = 0
⊢ p ∣ p * q
Theorem: pow_boole
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: simp
state_before: α : Type ?u.22144
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝² : Monoid M
inst✝¹ : AddMonoid A
P : Prop
inst✝ : Decidable P
a : M
⊢ (a ^ if P then 1 else 0) = if P then a else 1
Theorem: MeasureTheory.ae_le_of_ae_lt
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [Filter.EventuallyLE, ae_iff]
state_before: α : Type u_1
β : Type ?u.100460
γ : Type ?u.100463
δ : Type ?u.100466
ι : Type ?u.100469
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
f g : α → ℝ≥0∞
h : ∀ᵐ (x : α) ∂μ, f x < g x
⊢ f ≤ᵐ[μ] g

tactic: rw [ae_iff] at h
state_before: α : Type u_1
β : Type ?u.100460
γ : Type ?u.100463
δ : Type ?u.100466
ι : Type ?u.100469
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
f g : α → ℝ≥0∞
h : ∀ᵐ (x : α) ∂μ, f x < g x
⊢ ↑↑μ {a | ¬f a ≤ g a} = 0

tactic: refine' measure_mono_null (fun x hx => _) h
state_before: α : Type u_1
β : Type ?u.100460
γ : Type ?u.100463
δ : Type ?u.100466
ι : Type ?u.100469
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
f g : α → ℝ≥0∞
h : ↑↑μ {a | ¬f a < g a} = 0
⊢ ↑↑μ {a | ¬f a ≤ g a} = 0

tactic: exact not_lt.2 (le_of_lt (not_le.1 hx))
state_before: α : Type u_1
β : Type ?u.100460
γ : Type ?u.100463
δ : Type ?u.100466
ι : Type ?u.100469
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
f g : α → ℝ≥0∞
h : ↑↑μ {a | ¬f a < g a} = 0
x : α
hx : x ∈ {a | ¬f a ≤ g a}
⊢ x ∈ {a | ¬f a < g a}
Theorem: vadd_vsub_assoc
File: Mathlib/Algebra/AddTorsor.lean

tactic: apply vadd_right_cancel p2
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p1 p2 : P
⊢ g +ᵥ p1 -ᵥ p2 = g + (p1 -ᵥ p2)

tactic: rw [vsub_vadd, add_vadd, vsub_vadd]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p1 p2 : P
⊢ g +ᵥ p1 -ᵥ p2 +ᵥ p2 = g + (p1 -ᵥ p2) +ᵥ p2
Theorem: CategoryTheory.lift_comp_preservesLimitsIso_hom
File: Mathlib/CategoryTheory/Limits/Preserves/Limits.lean

tactic: ext
state_before: C : Type u₁
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
G : C ⥤ D
J : Type w
inst✝³ : Category J
F : J ⥤ C
inst✝² : PreservesLimit F G
inst✝¹ : HasLimit F
inst✝ : HasLimit (F ⋙ G)
t : Cone F
⊢ G.map (limit.lift F t) ≫ (preservesLimitIso G F).hom = limit.lift (F ⋙ G) (G.mapCone t)

tactic: simp [← G.map_comp]
state_before: case w
C : Type u₁
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
G : C ⥤ D
J : Type w
inst✝³ : Category J
F : J ⥤ C
inst✝² : PreservesLimit F G
inst✝¹ : HasLimit F
inst✝ : HasLimit (F ⋙ G)
t : Cone F
j✝ : J
⊢ (G.map (limit.lift F t) ≫ (preservesLimitIso G F).hom) ≫ limit.π (F ⋙ G) j✝ =
    limit.lift (F ⋙ G) (G.mapCone t) ≫ limit.π (F ⋙ G) j✝
Theorem: Sum.LiftRel.swap
File: Mathlib/Data/Sum/Basic.lean

tactic: cases h
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r r₁ r₂ : α → γ → Prop
s s₁ s₂ : β → δ → Prop
a : α
b : β
c : γ
d : δ
x : α ⊕ β
y : γ ⊕ δ
h : LiftRel r s x y
⊢ LiftRel s r (swap x) (swap y)

tactic: exact LiftRel.inr ‹_›
state_before: case inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r r₁ r₂ : α → γ → Prop
s s₁ s₂ : β → δ → Prop
a : α
b : β
c : γ
d : δ
a✝¹ : α
c✝ : γ
a✝ : r a✝¹ c✝
⊢ LiftRel s r (swap (inl a✝¹)) (swap (inl c✝))

tactic: exact LiftRel.inl ‹_›
state_before: case inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r r₁ r₂ : α → γ → Prop
s s₁ s₂ : β → δ → Prop
a : α
b : β
c : γ
d : δ
b✝ : β
d✝ : δ
a✝ : s b✝ d✝
⊢ LiftRel s r (swap (inr b✝)) (swap (inr d✝))
Theorem: List.drop_sizeOf_le
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with _ _ lih <;> intro n
state_before: ι : Type ?u.208871
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
l : List α
⊢ ∀ (n : ℕ), sizeOf (drop n l) ≤ sizeOf l

tactic: rw [drop_nil]
state_before: case nil
ι : Type ?u.208871
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
n : ℕ
⊢ sizeOf (drop n []) ≤ sizeOf []

tactic: induction' n with n
state_before: case cons
ι : Type ?u.208871
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
head✝ : α
tail✝ : List α
lih : ∀ (n : ℕ), sizeOf (drop n tail✝) ≤ sizeOf tail✝
n : ℕ
⊢ sizeOf (drop n (head✝ :: tail✝)) ≤ sizeOf (head✝ :: tail✝)

tactic: rfl
state_before: case cons.zero
ι : Type ?u.208871
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
head✝ : α
tail✝ : List α
lih : ∀ (n : ℕ), sizeOf (drop n tail✝) ≤ sizeOf tail✝
⊢ sizeOf (drop zero (head✝ :: tail✝)) ≤ sizeOf (head✝ :: tail✝)

tactic: exact Trans.trans (lih _) le_add_self
state_before: case cons.succ
ι : Type ?u.208871
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
head✝ : α
tail✝ : List α
lih : ∀ (n : ℕ), sizeOf (drop n tail✝) ≤ sizeOf tail✝
n : ℕ
n_ih✝ : sizeOf (drop n (head✝ :: tail✝)) ≤ sizeOf (head✝ :: tail✝)
⊢ sizeOf (drop (succ n) (head✝ :: tail✝)) ≤ sizeOf (head✝ :: tail✝)
Theorem: Multiset.filter_eq'
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [quot_mk_to_coe, coe_filter, mem_coe, coe_count]
state_before: α : Type u_1
β : Type ?u.420411
γ : Type ?u.420414
inst✝ : DecidableEq α
s : Multiset α
b : α
l : List α
⊢ filter (fun x => x = b) (Quotient.mk (isSetoid α) l) = replicate (count b (Quotient.mk (isSetoid α) l)) b

tactic: rw [List.filter_eq' l b, coe_replicate]
state_before: α : Type u_1
β : Type ?u.420411
γ : Type ?u.420414
inst✝ : DecidableEq α
s : Multiset α
b : α
l : List α
⊢ ↑(List.filter (fun b_1 => decide (b_1 = b)) l) = replicate (List.count b l) b
Theorem: isAlgebraic_algebraMap
File: Mathlib/RingTheory/Algebraic.lean

tactic: rw [_root_.map_sub, aeval_X, aeval_C, sub_self]
state_before: R : Type u
S : Type ?u.65885
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
x : R
⊢ ↑(aeval (↑(algebraMap R A) x)) (X - ↑C x) = 0
Theorem: mul_self_zpow
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: conv_lhs =>
  congr
  rw [← zpow_one b]
state_before: α : Type ?u.125817
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
b : G
m : ℤ
⊢ b * b ^ m = b ^ (m + 1)

tactic: rw [← zpow_add, add_comm]
state_before: α : Type ?u.125817
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
b : G
m : ℤ
⊢ b ^ 1 * b ^ m = b ^ (m + 1)
Theorem: bihimp_right_comm
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [bihimp_assoc, bihimp_comm]
state_before: ι : Type ?u.81353
α : Type u_1
β : Type ?u.81359
π : ι → Type ?u.81364
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⇔ b ⇔ c = a ⇔ c ⇔ b