tasksource/leandojo huggingface dataset:
Theorem: Polynomial.degree_divByMonic_le
File: Mathlib/Data/Polynomial/Div.lean

tactic: simp only [hp0, zero_divByMonic, le_refl]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hp0 : p = 0
⊢ degree (p /ₘ q) ≤ degree p

tactic: haveI := Nontrivial.of_polynomial_ne hp0
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hp0 : ¬p = 0
hq : Monic q
h : degree q ≤ degree p
⊢ degree (p /ₘ q) ≤ degree p

tactic: rw [← degree_add_divByMonic hq h, degree_eq_natDegree hq.ne_zero,
  degree_eq_natDegree (mt (divByMonic_eq_zero_iff hq).1 (not_lt.2 h))]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hp0 : ¬p = 0
hq : Monic q
h : degree q ≤ degree p
this : Nontrivial R
⊢ degree (p /ₘ q) ≤ degree p

tactic: exact WithBot.coe_le_coe.2 (Nat.le_add_left _ _)
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hp0 : ¬p = 0
hq : Monic q
h : degree q ≤ degree p
this : Nontrivial R
⊢ ↑(natDegree (p /ₘ q)) ≤ ↑(natDegree q) + ↑(natDegree (p /ₘ q))

tactic: unfold divByMonic divModByMonicAux
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hp0 : ¬p = 0
hq : Monic q
h : ¬degree q ≤ degree p
⊢ degree (p /ₘ q) ≤ degree p

tactic: simp [dif_pos hq, h, false_and_iff, if_false, degree_zero, bot_le]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hp0 : ¬p = 0
hq : Monic q
h : ¬degree q ≤ degree p
⊢ degree
      (if h : Monic q then
        (if h_1 : degree q ≤ degree p ∧ p ≠ 0 then
            let z := ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q);
            let_fun _wf := (_ : degree (p - ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q) * q) < degree p);
            let dm := divModByMonicAux (p - z * q) (_ : Monic q);
            (z + dm.fst, dm.snd)
          else (0, p)).fst
      else 0) ≤
    degree p
Theorem: Matrix.zpow_add_one
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: simp only [← Nat.cast_succ, pow_succ', zpow_ofNat]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
n : ℕ
⊢ A ^ (↑n + 1) = A ^ ↑n * A

tactic: rw [neg_add, neg_add_cancel_right, zpow_neg h, zpow_ofNat]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
n : ℕ
⊢ A ^ (-(↑n + 1) + 1) = (A ^ n)⁻¹

tactic: rw [mul_inv_rev, Matrix.mul_assoc, nonsing_inv_mul _ h, Matrix.mul_one]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
n : ℕ
⊢ (A ^ n)⁻¹ = (A ⬝ A ^ n)⁻¹ ⬝ A

tactic: rw [zpow_neg h, ← Int.ofNat_succ, zpow_ofNat, pow_succ, mul_eq_mul, mul_eq_mul]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
n : ℕ
⊢ (A ⬝ A ^ n)⁻¹ ⬝ A = A ^ (-(↑n + 1)) * A
Theorem: Filter.exists_seq_tendsto
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: obtain ⟨B, h⟩ := f.exists_antitone_basis
state_before: ι : Type ?u.364441
ι' : Type ?u.364444
α : Type u_1
β : Type ?u.364450
γ : Type ?u.364453
f : Filter α
inst✝¹ : IsCountablyGenerated f
inst✝ : NeBot f
⊢ ∃ x, Tendsto x atTop f

tactic: choose x hx using fun n => Filter.nonempty_of_mem (h.mem n)
state_before: case intro
ι : Type ?u.364441
ι' : Type ?u.364444
α : Type u_1
β : Type ?u.364450
γ : Type ?u.364453
f : Filter α
inst✝¹ : IsCountablyGenerated f
inst✝ : NeBot f
B : ℕ → Set α
h : HasAntitoneBasis f B
⊢ ∃ x, Tendsto x atTop f

tactic: exact ⟨x, h.tendsto hx⟩
state_before: case intro
ι : Type ?u.364441
ι' : Type ?u.364444
α : Type u_1
β : Type ?u.364450
γ : Type ?u.364453
f : Filter α
inst✝¹ : IsCountablyGenerated f
inst✝ : NeBot f
B : ℕ → Set α
h : HasAntitoneBasis f B
x : ℕ → α
hx : ∀ (n : ℕ), x n ∈ B n
⊢ ∃ x, Tendsto x atTop f
Theorem: Polynomial.leadingCoeff_pow_X_add_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: nontriviality
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
r : R
i : ℕ
⊢ leadingCoeff ((X + ↑C r) ^ i) = 1

tactic: rw [leadingCoeff_pow'] <;> simp
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
r : R
i : ℕ
✝ : Nontrivial R
⊢ leadingCoeff ((X + ↑C r) ^ i) = 1
Theorem: Nat.div_lt_div_of_lt_of_dvd
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: rw [Nat.lt_div_iff_mul_lt hdb]
state_before: a✝ b✝ m n k a b d : ℕ
hdb : d ∣ b
h : a < b
⊢ a / d < b / d

tactic: exact lt_of_le_of_lt (mul_div_le a d) h
state_before: a✝ b✝ m n k a b d : ℕ
hdb : d ∣ b
h : a < b
⊢ d * (a / d) < b
Theorem: Infinite.of_injective_to_set
File: Mathlib/Data/Fintype/Card.lean

tactic: skip
state_before: α : Type u_1
β : Type ?u.65760
γ : Type ?u.65763
s : Set α
hs : s ≠ Set.univ
f : α → ↑s
hf : Injective f
h : Fintype α
⊢ False

tactic: classical
  refine' lt_irrefl (Fintype.card α) _
  calc
    Fintype.card α ≤ Fintype.card s := Fintype.card_le_of_injective f hf
    _ = s.toFinset.card := s.toFinset_card.symm
    _ < Fintype.card α :=
      Finset.card_lt_card <| by rwa [Set.toFinset_ssubset_univ, Set.ssubset_univ_iff]
state_before: α : Type u_1
β : Type ?u.65760
γ : Type ?u.65763
s : Set α
hs : s ≠ Set.univ
f : α → ↑s
hf : Injective f
h : Fintype α
⊢ False

tactic: refine' lt_irrefl (Fintype.card α) _
state_before: α : Type u_1
β : Type ?u.65760
γ : Type ?u.65763
s : Set α
hs : s ≠ Set.univ
f : α → ↑s
hf : Injective f
h : Fintype α
⊢ False

tactic: calc
  Fintype.card α ≤ Fintype.card s := Fintype.card_le_of_injective f hf
  _ = s.toFinset.card := s.toFinset_card.symm
  _ < Fintype.card α :=
    Finset.card_lt_card <| by rwa [Set.toFinset_ssubset_univ, Set.ssubset_univ_iff]
state_before: α : Type u_1
β : Type ?u.65760
γ : Type ?u.65763
s : Set α
hs : s ≠ Set.univ
f : α → ↑s
hf : Injective f
h : Fintype α
⊢ Fintype.card α < Fintype.card α

tactic: rwa [Set.toFinset_ssubset_univ, Set.ssubset_univ_iff]
state_before: α : Type u_1
β : Type ?u.65760
γ : Type ?u.65763
s : Set α
hs : s ≠ Set.univ
f : α → ↑s
hf : Injective f
h : Fintype α
⊢ Set.toFinset s ⊂ univ
Theorem: Part.elim_toOption
File: Mathlib/Data/Part.lean

tactic: split_ifs with h
state_before: α✝ : Type ?u.8538
β✝ : Type ?u.8541
γ : Type ?u.8544
α : Type u_1
β : Type u_2
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
⊢ Option.elim (toOption a) b f = if h : a.Dom then f (get a h) else b

tactic: rw [h.toOption]
state_before: case inl
α✝ : Type ?u.8538
β✝ : Type ?u.8541
γ : Type ?u.8544
α : Type u_1
β : Type u_2
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : a.Dom
⊢ Option.elim (toOption a) b f = f (get a h)

tactic: rfl
state_before: case inl
α✝ : Type ?u.8538
β✝ : Type ?u.8541
γ : Type ?u.8544
α : Type u_1
β : Type u_2
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : a.Dom
⊢ Option.elim (Option.some (get a h)) b f = f (get a h)

tactic: rw [Part.toOption_eq_none_iff.2 h]
state_before: case inr
α✝ : Type ?u.8538
β✝ : Type ?u.8541
γ : Type ?u.8544
α : Type u_1
β : Type u_2
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : ¬a.Dom
⊢ Option.elim (toOption a) b f = b

tactic: rfl
state_before: case inr
α✝ : Type ?u.8538
β✝ : Type ?u.8541
γ : Type ?u.8544
α : Type u_1
β : Type u_2
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : ¬a.Dom
⊢ Option.elim Option.none b f = b
Theorem: Set.le_ncard_diff
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [add_comm]
state_before: α : Type u_1
β : Type ?u.126847
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard t ≤ ncard s + ncard (t \ s)

tactic: apply ncard_le_ncard_diff_add_ncard _ _ hs
state_before: α : Type u_1
β : Type ?u.126847
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard t ≤ ncard (t \ s) + ncard s
Theorem: AlgebraicTopology.DoldKan.hσ'_eq_zero
File: Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean

tactic: simp only [hσ', hσ]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n m : ℕ
hnq : n < q
hnm : ComplexShape.Rel c m n
⊢ hσ' q n m hnm = 0

tactic: split_ifs
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n m : ℕ
hnq : n < q
hnm : ComplexShape.Rel c m n
⊢ (if n < q then 0 else (-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
      eqToHom (_ : X.obj [n + 1].op = X.obj [m].op) =
    0

tactic: exact zero_comp
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n m : ℕ
hnq : n < q
hnm : ComplexShape.Rel c m n
⊢ 0 ≫ eqToHom (_ : X.obj [n + 1].op = X.obj [m].op) = 0
Theorem: MeasureTheory.Measure.lintegral_rnDeriv_lt_top
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: rw [← set_lintegral_univ]
state_before: α : Type u_1
β : Type ?u.38581
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : IsFiniteMeasure μ
⊢ (∫⁻ (x : α), rnDeriv μ ν x ∂ν) < ⊤

tactic: exact lintegral_rnDeriv_lt_top_of_measure_ne_top _ (measure_lt_top _ _).ne
state_before: α : Type u_1
β : Type ?u.38581
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : IsFiniteMeasure μ
⊢ (∫⁻ (x : α) in univ, rnDeriv μ ν x ∂ν) < ⊤
Theorem: Rat.add_def'
File: Std/Data/Rat/Lemmas.lean

tactic: rw [add_def, normalize_eq_mkRat]
state_before: a b : Rat
⊢ a + b = mkRat (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den)
Theorem: Algebra.left_comm
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: rw [← mul_assoc, ← commutes, mul_assoc]
state_before: R : Type u
S : Type v
A : Type w
B : Type ?u.275396
inst✝⁵ : CommSemiring R
inst✝⁴ : CommSemiring S
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
x : A
r : R
y : A
⊢ x * (↑(algebraMap R A) r * y) = ↑(algebraMap R A) r * (x * y)
Theorem: Rat.cast_mk
File: Mathlib/Data/Rat/Cast.lean

tactic: simp only [divInt_eq_div, cast_div, cast_coe_int]
state_before: F : Type ?u.53063
ι : Type ?u.53066
α : Type u_1
β : Type ?u.53072
inst✝¹ : DivisionRing α
inst✝ : CharZero α
a b : ℤ
⊢ ↑(a /. b) = ↑a / ↑b
Theorem: CategoryTheory.Iso.trans_refl
File: Mathlib/CategoryTheory/Iso.lean

tactic: ext
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
⊢ α ≪≫ refl Y = α

tactic: apply Category.comp_id
state_before: case w
C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
⊢ (α ≪≫ refl Y).hom = α.hom
Theorem: Equiv.Perm.sign_of_cycleType'
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: induction σ using cycle_induction_on with
| base_one => simp
| base_cycles σ hσ => simp [hσ.cycleType, hσ.sign]
| induction_disjoint σ τ hd _ hσ hτ => simp [hσ, hτ, hd.cycleType]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
⊢ ↑sign σ = prod (map (fun n => -(-1) ^ n) (cycleType σ))

tactic: simp
state_before: case base_one
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
⊢ ↑sign 1 = prod (map (fun n => -(-1) ^ n) (cycleType 1))

tactic: simp [hσ.cycleType, hσ.sign]
state_before: case base_cycles
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
hσ : IsCycle σ
⊢ ↑sign σ = prod (map (fun n => -(-1) ^ n) (cycleType σ))

tactic: simp [hσ, hτ, hd.cycleType]
state_before: case induction_disjoint
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
hd : Disjoint σ τ
a✝ : IsCycle σ
hσ : ↑sign σ = prod (map (fun n => -(-1) ^ n) (cycleType σ))
hτ : ↑sign τ = prod (map (fun n => -(-1) ^ n) (cycleType τ))
⊢ ↑sign (σ * τ) = prod (map (fun n => -(-1) ^ n) (cycleType (σ * τ)))
Theorem: Real.tan_lt_tan_of_nonneg_of_lt_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [tan_eq_sin_div_cos, tan_eq_sin_div_cos]
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y < π / 2
hxy : x < y
⊢ tan x < tan y

tactic: exact
  div_lt_div (sin_lt_sin_of_lt_of_le_pi_div_two (by linarith) (le_of_lt hy₂) hxy)
    (cos_le_cos_of_nonneg_of_le_pi hx₁ (by linarith) (le_of_lt hxy))
    (sin_nonneg_of_nonneg_of_le_pi (by linarith) (by linarith))
    (cos_pos_of_mem_Ioo ⟨by linarith, hy₂⟩)
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y < π / 2
hxy : x < y
⊢ sin x / cos x < sin y / cos y

tactic: linarith
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y < π / 2
hxy : x < y
⊢ -(π / 2) ≤ x

tactic: linarith
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y < π / 2
hxy : x < y
⊢ y ≤ π

tactic: linarith
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y < π / 2
hxy : x < y
⊢ 0 ≤ y

tactic: linarith
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y < π / 2
hxy : x < y
⊢ y ≤ π

tactic: linarith
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y < π / 2
hxy : x < y
⊢ -(π / 2) < y
Theorem: GroupCat.SurjectiveOfEpiAuxs.τ_symm_apply_infinity
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: rw [tau, Equiv.symm_swap, Equiv.swap_apply_right]
state_before: A B : GroupCat
f : A ⟶ B
⊢ ↑τ.symm ∞ =
    fromCoset
      { val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
        property :=
          (_ :
            ∃ y,
              Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) }
Theorem: Valued.loc_const
File: Mathlib/Topology/Algebra/Valuation.lean

tactic: rw [mem_nhds]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : ↑v x ≠ 0
⊢ {y | ↑v y = ↑v x} ∈ 𝓝 x

tactic: rcases Units.exists_iff_ne_zero.mpr h with ⟨γ, hx⟩
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : ↑v x ≠ 0
⊢ ∃ γ, {y | ↑v (y - x) < ↑γ} ⊆ {y | ↑v y = ↑v x}

tactic: use γ
state_before: case intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : ↑v x ≠ 0
γ : ((fun x => Γ₀) x)ˣ
hx : ↑γ = ↑v x
⊢ ∃ γ, {y | ↑v (y - x) < ↑γ} ⊆ {y | ↑v y = ↑v x}

tactic: rw [hx]
state_before: case intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : ↑v x ≠ 0
γ : ((fun x => Γ₀) x)ˣ
hx : ↑γ = ↑v x
⊢ {y | ↑v (y - x) < ↑γ} ⊆ {y | ↑v y = ↑v x}

tactic: intro y y_in
state_before: case intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : ↑v x ≠ 0
γ : ((fun x => Γ₀) x)ˣ
hx : ↑γ = ↑v x
⊢ {y | ↑v (y - x) < ↑v x} ⊆ {y | ↑v y = ↑v x}

tactic: exact Valuation.map_eq_of_sub_lt _ y_in
state_before: case intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : ↑v x ≠ 0
γ : ((fun x => Γ₀) x)ˣ
hx : ↑γ = ↑v x
y : R
y_in : y ∈ {y | ↑v (y - x) < ↑v x}
⊢ y ∈ {y | ↑v y = ↑v x}
Theorem: Polynomial.leadingCoeff_of_injective
File: Mathlib/Data/Polynomial/Monic.lean

tactic: delta leadingCoeff
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ↑f
p : R[X]
⊢ leadingCoeff (map f p) = ↑f (leadingCoeff p)

tactic: rw [coeff_map f, natDegree_map_eq_of_injective hf p]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ↑f
p : R[X]
⊢ coeff (map f p) (natDegree (map f p)) = ↑f (coeff p (natDegree p))
Theorem: List.append_cancel_left
File: src/lean/Init/Data/List/BasicAux.lean

tactic: induction as with
| nil => assumption
| cons a as ih =>
  injection h with _ h
  exact ih h
state_before: α : Type u_1
as bs cs : List α
h : as ++ bs = as ++ cs
⊢ bs = cs

tactic: assumption
state_before: case nil
α : Type u_1
bs cs : List α
h : [] ++ bs = [] ++ cs
⊢ bs = cs

tactic: injection h with _ h
state_before: case cons
α : Type u_1
bs cs : List α
a : α
as : List α
ih : as ++ bs = as ++ cs → bs = cs
h : a :: as ++ bs = a :: as ++ cs
⊢ bs = cs

tactic: exact ih h
state_before: case cons
α : Type u_1
bs cs : List α
a : α
as : List α
ih : as ++ bs = as ++ cs → bs = cs
head_eq✝ : a = a
h : List.append as bs = List.append as cs
⊢ bs = cs
Theorem: Finset.sum_nat_mod
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [Finset.sum, Multiset.map_map]
state_before: ι : Type ?u.876641
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
s : Finset α
n : ℕ
f : α → ℕ
⊢ Multiset.sum (Multiset.map (fun x => x % n) (Multiset.map (fun i => f i) s.val)) % n = (∑ i in s, f i % n) % n

tactic: rfl
state_before: ι : Type ?u.876641
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
s : Finset α
n : ℕ
f : α → ℕ
⊢ Multiset.sum (Multiset.map ((fun x => x % n) ∘ fun i => f i) s.val) % n =
    Multiset.sum (Multiset.map (fun i => f i % n) s.val) % n
Theorem: Set.pairwiseDisjoint_range_singleton
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: rintro _ ⟨a, rfl⟩ _ ⟨b, rfl⟩ h
state_before: α : Type ?u.39435
β : Type ?u.39438
γ : Type ?u.39441
ι : Type u_1
ι' : Type ?u.39447
r p q : α → α → Prop
⊢ PairwiseDisjoint (range singleton) id

tactic: exact disjoint_singleton.2 (ne_of_apply_ne _ h)
state_before: case intro.intro
α : Type ?u.39435
β : Type ?u.39438
γ : Type ?u.39441
ι : Type u_1
ι' : Type ?u.39447
r p q : α → α → Prop
a b : ι
h : {a} ≠ {b}
⊢ (Disjoint on id) {a} {b}
Theorem: StructureGroupoid.id_mem_maximalAtlas
File: Mathlib/Geometry/Manifold/ChartedSpace.lean

tactic: simp
state_before: H : Type u
H' : Type ?u.74250
M : Type ?u.74253
M' : Type ?u.74256
M'' : Type ?u.74259
inst✝² : TopologicalSpace H
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H M
G : StructureGroupoid H
⊢ LocalHomeomorph.refl H ∈ atlas H H
Theorem: Set.ite_inter_self
File: Mathlib/Data/Set/Basic.lean

tactic: rw [Set.ite, union_inter_distrib_right, diff_inter_self, inter_assoc, inter_self, union_empty]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u t s s' : Set α
⊢ Set.ite t s s' ∩ t = s ∩ t
Theorem: left_lt_add_div_two
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp [lt_div_iff, mul_two]
state_before: ι : Type ?u.99336
α : Type u_1
β : Type ?u.99342
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
⊢ a < (a + b) / 2 ↔ a < b
Theorem: Fin.coe_eq_castSucc
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m : ℕ
a : Fin n
⊢ ↑↑a = ↑castSucc a

tactic: exact val_cast_of_lt (Nat.lt.step a.is_lt)
state_before: case h
n m : ℕ
a : Fin n
⊢ ↑↑↑a = ↑(↑castSucc a)
Theorem: MeasureTheory.FinMeasAdditive.map_empty_eq_zero
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: have h_empty : μ ∅ ≠ ∞ := (measure_empty.le.trans_lt ENNReal.coe_lt_top).ne
state_before: α : Type u_2
E : Type ?u.33868
F : Type ?u.33871
F' : Type ?u.33874
G : Type ?u.33877
𝕜 : Type ?u.33880
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β✝ : Type ?u.34180
inst✝¹ : AddCommMonoid β✝
T✝ T' : Set α → β✝
β : Type u_1
inst✝ : AddCancelMonoid β
T : Set α → β
hT : FinMeasAdditive μ T
⊢ T ∅ = 0

tactic: specialize hT ∅ ∅ MeasurableSet.empty MeasurableSet.empty h_empty h_empty (Set.inter_empty ∅)
state_before: α : Type u_2
E : Type ?u.33868
F : Type ?u.33871
F' : Type ?u.33874
G : Type ?u.33877
𝕜 : Type ?u.33880
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β✝ : Type ?u.34180
inst✝¹ : AddCommMonoid β✝
T✝ T' : Set α → β✝
β : Type u_1
inst✝ : AddCancelMonoid β
T : Set α → β
hT : FinMeasAdditive μ T
h_empty : ↑↑μ ∅ ≠ ⊤
⊢ T ∅ = 0

tactic: rw [Set.union_empty] at hT
state_before: α : Type u_2
E : Type ?u.33868
F : Type ?u.33871
F' : Type ?u.33874
G : Type ?u.33877
𝕜 : Type ?u.33880
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β✝ : Type ?u.34180
inst✝¹ : AddCommMonoid β✝
T✝ T' : Set α → β✝
β : Type u_1
inst✝ : AddCancelMonoid β
T : Set α → β
h_empty : ↑↑μ ∅ ≠ ⊤
hT : T (∅ ∪ ∅) = T ∅ + T ∅
⊢ T ∅ = 0

tactic: nth_rw 1 [← add_zero (T ∅)] at hT
state_before: α : Type u_2
E : Type ?u.33868
F : Type ?u.33871
F' : Type ?u.33874
G : Type ?u.33877
𝕜 : Type ?u.33880
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β✝ : Type ?u.34180
inst✝¹ : AddCommMonoid β✝
T✝ T' : Set α → β✝
β : Type u_1
inst✝ : AddCancelMonoid β
T : Set α → β
h_empty : ↑↑μ ∅ ≠ ⊤
hT : T ∅ = T ∅ + T ∅
⊢ T ∅ = 0

tactic: exact (add_left_cancel hT).symm
state_before: α : Type u_2
E : Type ?u.33868
F : Type ?u.33871
F' : Type ?u.33874
G : Type ?u.33877
𝕜 : Type ?u.33880
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β✝ : Type ?u.34180
inst✝¹ : AddCommMonoid β✝
T✝ T' : Set α → β✝
β : Type u_1
inst✝ : AddCancelMonoid β
T : Set α → β
h_empty : ↑↑μ ∅ ≠ ⊤
hT : T ∅ + 0 = T ∅ + T ∅
⊢ T ∅ = 0
Theorem: Filter.tendsto_prod_iff
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [tendsto_def, mem_prod_iff, prod_sub_preimage_iff, exists_prop, iff_self_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.51513
ι : Sort ?u.51516
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : α × β → γ
x : Filter α
y : Filter β
z : Filter γ
⊢ Tendsto f (x ×ˢ y) z ↔
    ∀ (W : Set γ), W ∈ z → ∃ U, U ∈ x ∧ ∃ V, V ∈ y ∧ ∀ (x : α) (y : β), x ∈ U → y ∈ V → f (x, y) ∈ W
Theorem: exists_maximal_of_chains_bounded
File: Mathlib/Order/Zorn.lean

tactic: rw [maxChain_spec.right this (subset_insert _ _)]
state_before: α : Type u_1
β : Type ?u.2285
r : α → α → Prop
c : Set α
h : ∀ (c : Set α), IsChain r c → ∃ ub, ∀ (a : α), a ∈ c → r a ub
trans : ∀ {a b c : α}, r a b → r b c → r a c
this✝ : ∃ ub, ∀ (a : α), a ∈ maxChain r → r a ub
ub : α
hub : ∀ (a : α), a ∈ maxChain r → r a ub
a : α
ha : r ub a
this : IsChain r (insert a (maxChain r))
⊢ a ∈ maxChain r

tactic: exact mem_insert _ _
state_before: α : Type u_1
β : Type ?u.2285
r : α → α → Prop
c : Set α
h : ∀ (c : Set α), IsChain r c → ∃ ub, ∀ (a : α), a ∈ c → r a ub
trans : ∀ {a b c : α}, r a b → r b c → r a c
this✝ : ∃ ub, ∀ (a : α), a ∈ maxChain r → r a ub
ub : α
hub : ∀ (a : α), a ∈ maxChain r → r a ub
a : α
ha : r ub a
this : IsChain r (insert a (maxChain r))
⊢ a ∈ insert a (maxChain r)
Theorem: Set.definable_finset_biInter
File: Mathlib/ModelTheory/Definability.lean

tactic: rw [← Finset.inf_set_eq_iInter]
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.15276
B : Set M
s✝ : Set (α → M)
ι : Type u_1
f : ι → Set (α → M)
hf : ∀ (i : ι), Definable A L (f i)
s : Finset ι
⊢ Definable A L (⋂ (i : ι) (_ : i ∈ s), f i)

tactic: exact definable_finset_inf hf s
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.15276
B : Set M
s✝ : Set (α → M)
ι : Type u_1
f : ι → Set (α → M)
hf : ∀ (i : ι), Definable A L (f i)
s : Finset ι
⊢ Definable A L (Finset.inf s fun i => f i)
Theorem: Dfinsupp.support_tsub
File: Mathlib/Data/Dfinsupp/Order.lean

tactic: simp (config := { contextual := true }) only [subset_iff, tsub_eq_zero_iff_le, mem_support_iff,
  Ne.def, coe_tsub, Pi.sub_apply, not_imp_not, zero_le, imp_true_iff]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : (i : ι) → CanonicallyOrderedAddMonoid (α i)
inst✝³ : (i : ι) → Sub (α i)
inst✝² : ∀ (i : ι), OrderedSub (α i)
f g : Π₀ (i : ι), α i
i : ι
a b : α i
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → (x : α i) → Decidable (x ≠ 0)
⊢ support (f - g) ⊆ support f