tasksource/leandojo huggingface dataset:
Theorem: Multiset.prod_map_one
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [map_const', prod_replicate, one_pow]
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.57133
γ : Type ?u.57136
inst✝ : CommMonoid α
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
⊢ prod (map (fun x => 1) m) = 1
Theorem: IsSubgroup.mul_mem_cancel_right
File: Mathlib/Deprecated/Subgroup.lean

tactic: simpa using hs.mul_mem hba (hs.inv_mem h)
state_before: G : Type u_1
H : Type ?u.13003
A : Type ?u.13006
a a₁ a₂ b c : G
inst✝ : Group G
s : Set G
hs : IsSubgroup s
h : a ∈ s
hba : b * a ∈ s
⊢ b ∈ s
Theorem: le_inv_mul_iff_le
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_left b, mul_one, mul_inv_cancel_left]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ 1 ≤ b⁻¹ * a ↔ b ≤ a
Theorem: Metric.cthickening_cthickening_subset
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: intro x
state_before: ι : Sort ?u.158407
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x : α
hε : 0 ≤ ε
hδ : 0 ≤ δ
s : Set α
⊢ cthickening ε (cthickening δ s) ⊆ cthickening (ε + δ) s

tactic: simp_rw [mem_cthickening_iff, ENNReal.ofReal_add hε hδ]
state_before: ι : Sort ?u.158407
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x✝ : α
hε : 0 ≤ ε
hδ : 0 ≤ δ
s : Set α
x : α
⊢ x ∈ cthickening ε (cthickening δ s) → x ∈ cthickening (ε + δ) s

tactic: exact fun hx => infEdist_le_infEdist_cthickening_add.trans (add_le_add_right hx _)
state_before: ι : Sort ?u.158407
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x✝ : α
hε : 0 ≤ ε
hδ : 0 ≤ δ
s : Set α
x : α
⊢ infEdist x (cthickening δ s) ≤ ENNReal.ofReal ε → infEdist x s ≤ ENNReal.ofReal ε + ENNReal.ofReal δ
Theorem: SimpleGraph.dart_edge_eq_mk'_iff'
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rintro ⟨⟨a, b⟩, h⟩ u v
state_before: ι : Sort ?u.98622
𝕜 : Type ?u.98625
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
⊢ ∀ {d : Dart G} {u v : V},
    Dart.edge d = Quotient.mk (Sym2.Rel.setoid V) (u, v) ↔ d.fst = u ∧ d.snd = v ∨ d.fst = v ∧ d.snd = u

tactic: rw [dart_edge_eq_mk'_iff]
state_before: case mk.mk
ι : Sort ?u.98622
𝕜 : Type ?u.98625
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a✝ b✝ c u✝ v✝ w : V
e : Sym2 V
a b : V
h : Adj G (a, b).fst (a, b).snd
u v : V
⊢ Dart.edge { toProd := (a, b), is_adj := h } = Quotient.mk (Sym2.Rel.setoid V) (u, v) ↔
    { toProd := (a, b), is_adj := h }.toProd.fst = u ∧ { toProd := (a, b), is_adj := h }.toProd.snd = v ∨
      { toProd := (a, b), is_adj := h }.toProd.fst = v ∧ { toProd := (a, b), is_adj := h }.toProd.snd = u

tactic: simp
state_before: case mk.mk
ι : Sort ?u.98622
𝕜 : Type ?u.98625
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a✝ b✝ c u✝ v✝ w : V
e : Sym2 V
a b : V
h : Adj G (a, b).fst (a, b).snd
u v : V
⊢ { toProd := (a, b), is_adj := h }.toProd = (u, v) ∨ { toProd := (a, b), is_adj := h }.toProd = Prod.swap (u, v) ↔
    { toProd := (a, b), is_adj := h }.toProd.fst = u ∧ { toProd := (a, b), is_adj := h }.toProd.snd = v ∨
      { toProd := (a, b), is_adj := h }.toProd.fst = v ∧ { toProd := (a, b), is_adj := h }.toProd.snd = u
Theorem: Set.infinite_of_forall_exists_gt
File: Mathlib/Data/Set/Finite.lean

tactic: inhabit α
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Preorder α
inst✝ : Nonempty α
s : Set α
h : ∀ (a : α), ∃ b, b ∈ s ∧ a < b
⊢ Set.Infinite s

tactic: set f : ℕ → α := fun n => Nat.recOn n (h default).choose fun n a => (h a).choose
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Preorder α
inst✝ : Nonempty α
s : Set α
h : ∀ (a : α), ∃ b, b ∈ s ∧ a < b
inhabited_h : Inhabited α
⊢ Set.Infinite s

tactic: have hf : ∀ n, f n ∈ s := by rintro (_ | _) <;> exact (h _).choose_spec.1
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Preorder α
inst✝ : Nonempty α
s : Set α
h : ∀ (a : α), ∃ b, b ∈ s ∧ a < b
inhabited_h : Inhabited α
f : ℕ → α :=
  fun n => Nat.recOn n (Exists.choose (_ : ∃ b, b ∈ s ∧ default < b)) fun n a => Exists.choose (_ : ∃ b, b ∈ s ∧ a < b)
⊢ Set.Infinite s

tactic: exact infinite_of_injective_forall_mem
  (strictMono_nat_of_lt_succ fun n => (h _).choose_spec.2).injective hf
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Preorder α
inst✝ : Nonempty α
s : Set α
h : ∀ (a : α), ∃ b, b ∈ s ∧ a < b
inhabited_h : Inhabited α
f : ℕ → α :=
  fun n => Nat.recOn n (Exists.choose (_ : ∃ b, b ∈ s ∧ default < b)) fun n a => Exists.choose (_ : ∃ b, b ∈ s ∧ a < b)
hf : ∀ (n : ℕ), f n ∈ s
⊢ Set.Infinite s

tactic: rintro (_ | _) <;> exact (h _).choose_spec.1
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Preorder α
inst✝ : Nonempty α
s : Set α
h : ∀ (a : α), ∃ b, b ∈ s ∧ a < b
inhabited_h : Inhabited α
f : ℕ → α :=
  fun n => Nat.recOn n (Exists.choose (_ : ∃ b, b ∈ s ∧ default < b)) fun n a => Exists.choose (_ : ∃ b, b ∈ s ∧ a < b)
⊢ ∀ (n : ℕ), f n ∈ s
Theorem: compl_eq_iff_isCompl
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← h]
state_before: α : Type u
β : Type ?u.54113
w x y z : α
inst✝ : BooleanAlgebra α
h : xᶜ = y
⊢ IsCompl x y

tactic: exact isCompl_compl
state_before: α : Type u
β : Type ?u.54113
w x y z : α
inst✝ : BooleanAlgebra α
h : xᶜ = y
⊢ IsCompl x (xᶜ)
Theorem: Polynomial.eraseLead_coeff_of_ne
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: simp [eraseLead_coeff, hi]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
i : ℕ
hi : i ≠ natDegree f
⊢ coeff (eraseLead f) i = coeff f i
Theorem: Nat.Ico_pred_singleton
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [← Icc_pred_right _ h, Icc_self]
state_before: a✝ b c a : ℕ
h : 0 < a
⊢ Ico (a - 1) a = {a - 1}
Theorem: Multiset.toEnumFinset_subset_iff
File: Mathlib/Data/Multiset/Fintype.lean

tactic: refine' ⟨fun h ↦ _, Multiset.toEnumFinset_mono⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
⊢ toEnumFinset m₁ ⊆ toEnumFinset m₂ ↔ m₁ ≤ m₂

tactic: rw [Multiset.le_iff_count]
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
⊢ m₁ ≤ m₂

tactic: intro x
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
⊢ ∀ (a : α), count a m₁ ≤ count a m₂

tactic: by_cases hx : x ∈ m₁
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
x : α
⊢ count x m₁ ≤ count x m₂

tactic: apply Nat.le_of_pred_lt
state_before: case pos
α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
x : α
hx : x ∈ m₁
⊢ count x m₁ ≤ count x m₂

tactic: have : (x, m₁.count x - 1) ∈ m₁.toEnumFinset := by
  rw [Multiset.mem_toEnumFinset]
  exact Nat.pred_lt (ne_of_gt (Multiset.count_pos.mpr hx))
state_before: case pos.a
α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
x : α
hx : x ∈ m₁
⊢ Nat.pred (count x m₁) < count x m₂

tactic: simpa only [Multiset.mem_toEnumFinset] using h this
state_before: case pos.a
α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
x : α
hx : x ∈ m₁
this : (x, count x m₁ - 1) ∈ toEnumFinset m₁
⊢ Nat.pred (count x m₁) < count x m₂

tactic: rw [Multiset.mem_toEnumFinset]
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
x : α
hx : x ∈ m₁
⊢ (x, count x m₁ - 1) ∈ toEnumFinset m₁

tactic: exact Nat.pred_lt (ne_of_gt (Multiset.count_pos.mpr hx))
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
x : α
hx : x ∈ m₁
⊢ (x, count x m₁ - 1).snd < count (x, count x m₁ - 1).fst m₁

tactic: simp [hx]
state_before: case neg
α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : toEnumFinset m₁ ⊆ toEnumFinset m₂
x : α
hx : ¬x ∈ m₁
⊢ count x m₁ ≤ count x m₂
Theorem: Nat.minFac_has_prop
File: Mathlib/Data/Nat/Prime.lean

tactic: by_cases n0 : n = 0
state_before: n : ℕ
n1 : n ≠ 1
⊢ Nat.minFacProp n (minFac n)

tactic: have n2 : 2 ≤ n := by
  revert n0 n1
  rcases n with (_ | _ | _) <;> simp [succ_le_succ]
state_before: case neg
n : ℕ
n1 : n ≠ 1
n0 : ¬n = 0
⊢ Nat.minFacProp n (minFac n)

tactic: simp [minFac_eq]
state_before: case neg
n : ℕ
n1 : n ≠ 1
n0 : ¬n = 0
n2 : 2 ≤ n
⊢ Nat.minFacProp n (minFac n)

tactic: by_cases d2 : 2 ∣ n <;> simp [d2]
state_before: case neg
n : ℕ
n1 : n ≠ 1
n0 : ¬n = 0
n2 : 2 ≤ n
⊢ Nat.minFacProp n (if 2 ∣ n then 2 else minFacAux n 3)

tactic: simp [n0, minFacProp, GE.ge]
state_before: case pos
n : ℕ
n1 : n ≠ 1
n0 : n = 0
⊢ Nat.minFacProp n (minFac n)

tactic: revert n0 n1
state_before: n : ℕ
n1 : n ≠ 1
n0 : ¬n = 0
⊢ 2 ≤ n

tactic: rcases n with (_ | _ | _) <;> simp [succ_le_succ]
state_before: n : ℕ
⊢ n ≠ 1 → ¬n = 0 → 2 ≤ n

tactic: exact ⟨le_rfl, d2, fun k k2 _ => k2⟩
state_before: case pos
n : ℕ
n1 : n ≠ 1
n0 : ¬n = 0
n2 : 2 ≤ n
d2 : 2 ∣ n
⊢ Nat.minFacProp n 2

tactic: refine'
  minFacAux_has_prop n2 3 0 rfl fun m m2 d => (Nat.eq_or_lt_of_le m2).resolve_left (mt _ d2)
state_before: case neg
n : ℕ
n1 : n ≠ 1
n0 : ¬n = 0
n2 : 2 ≤ n
d2 : ¬2 ∣ n
⊢ Nat.minFacProp n (minFacAux n 3)

tactic: exact fun e => e.symm ▸ d
state_before: case neg
n : ℕ
n1 : n ≠ 1
n0 : ¬n = 0
n2 : 2 ≤ n
d2 : ¬2 ∣ n
m : ℕ
m2 : 2 ≤ m
d : m ∣ n
⊢ 2 = m → 2 ∣ n
Theorem: uniqueDiffOn_Ici
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: simp only [interior_Ici, nonempty_Ioi]
state_before: 𝕜 : Type ?u.175688
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.175694
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.175789
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.175879
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a : ℝ
⊢ Set.Nonempty (interior (Ici a))
Theorem: Ideal.pow_le_pow
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: cases' Nat.exists_eq_add_of_le h with k hk
state_before: R : Type u
ι : Type ?u.292952
inst✝ : CommSemiring R
I J K L : Ideal R
m n : ℕ
h : m ≤ n
⊢ I ^ n ≤ I ^ m

tactic: rw [hk, pow_add]
state_before: case intro
R : Type u
ι : Type ?u.292952
inst✝ : CommSemiring R
I J K L : Ideal R
m n : ℕ
h : m ≤ n
k : ℕ
hk : n = m + k
⊢ I ^ n ≤ I ^ m

tactic: exact le_trans mul_le_inf inf_le_left
state_before: case intro
R : Type u
ι : Type ?u.292952
inst✝ : CommSemiring R
I J K L : Ideal R
m n : ℕ
h : m ≤ n
k : ℕ
hk : n = m + k
⊢ I ^ m * I ^ k ≤ I ^ m
Theorem: FiniteDimensional.finrank_pos_iff_exists_ne_zero
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← finrank_eq_rank]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ 0 < finrank K V ↔ 0 < Module.rank K V

tactic: norm_cast
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ 0 < finrank K V ↔ 0 < ↑(finrank K V)
Theorem: Int.clog_of_right_le_zero
File: Mathlib/Data/Int/Log.lean

tactic: rw [clog, if_neg (hr.trans_lt zero_lt_one).not_le, neg_eq_zero, Int.coe_nat_eq_zero,
  Nat.log_eq_zero_iff]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
⊢ clog b r = 0

tactic: cases' le_or_lt b 1 with hb hb
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
⊢ ⌊r⁻¹⌋₊ < b ∨ b ≤ 1

tactic: exact Or.inr hb
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
hb : b ≤ 1
⊢ ⌊r⁻¹⌋₊ < b ∨ b ≤ 1

tactic: refine' Or.inl (lt_of_le_of_lt _ hb)
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
hb : 1 < b
⊢ ⌊r⁻¹⌋₊ < b ∨ b ≤ 1

tactic: exact Nat.floor_le_one_of_le_one ((inv_nonpos.2 hr).trans zero_le_one)
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
hb : 1 < b
⊢ ⌊r⁻¹⌋₊ ≤ 1
Theorem: zpow_sub
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [sub_eq_add_neg, zpow_add, zpow_neg]
state_before: α : Type ?u.132793
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
a : G
m n : ℤ
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹
Theorem: AbstractCompletion.extend_map
File: Mathlib/Topology/UniformSpace/AbstractCompletion.lean

tactic: rw [pkg.extend_coe (hf.comp hg), comp_apply, pkg.map_coe pkg' hg, pkg'.extend_coe hf]
state_before: α : Type u_3
inst✝⁴ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝³ : UniformSpace β
pkg' : AbstractCompletion β
f✝ : α → β
γ : Type u_1
inst✝² : UniformSpace γ
inst✝¹ : CompleteSpace γ
inst✝ : SeparatedSpace γ
f : β → γ
g : α → β
hf : UniformContinuous f
hg : UniformContinuous g
a : α
⊢ (AbstractCompletion.extend pkg' f ∘ AbstractCompletion.map pkg pkg' g) (coe pkg a) =
    AbstractCompletion.extend pkg (f ∘ g) (coe pkg a)

tactic: rfl
state_before: α : Type u_3
inst✝⁴ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝³ : UniformSpace β
pkg' : AbstractCompletion β
f✝ : α → β
γ : Type u_1
inst✝² : UniformSpace γ
inst✝¹ : CompleteSpace γ
inst✝ : SeparatedSpace γ
f : β → γ
g : α → β
hf : UniformContinuous f
hg : UniformContinuous g
a : α
⊢ f (g a) = (f ∘ g) a
Theorem: Int.mul_div_cancel'
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, Int.div_mul_cancel H]
state_before: a b : Int
H : a ∣ b
⊢ a * div b a = b
Theorem: Matrix.StdBasisMatrix.mul_same
File: Mathlib/Data/Matrix/Basis.lean

tactic: ext (a b)
state_before: l : Type ?u.41930
m : Type ?u.41933
n : Type u_1
R : Type ?u.41939
α : Type u_2
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
k : n
d : α
⊢ stdBasisMatrix i j c ⬝ stdBasisMatrix j k d = stdBasisMatrix i k (c * d)

tactic: simp only [mul_apply, stdBasisMatrix, boole_mul]
state_before: case a.h
l : Type ?u.41930
m : Type ?u.41933
n : Type u_1
R : Type ?u.41939
α : Type u_2
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
k : n
d : α
a b : n
⊢ (stdBasisMatrix i j c ⬝ stdBasisMatrix j k d) a b = stdBasisMatrix i k (c * d) a b

tactic: by_cases h₁ : i = a <;> by_cases h₂ : k = b <;> simp [h₁, h₂]
state_before: case a.h
l : Type ?u.41930
m : Type ?u.41933
n : Type u_1
R : Type ?u.41939
α : Type u_2
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
k : n
d : α
a b : n
⊢ (∑ j_1 : n, (if i = a ∧ j = j_1 then c else 0) * if j = j_1 ∧ k = b then d else 0) =
    if i = a ∧ k = b then c * d else 0
Theorem: Function.invFunOn_neg
File: Mathlib/Data/Set/Function.lean

tactic: rw [invFunOn, dif_neg h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.65525
ι : Sort ?u.65528
π : α → Type ?u.65533
inst✝ : Nonempty α
s : Set α
f : α → β
a : α
b : β
h : ¬∃ a, a ∈ s ∧ f a = b
⊢ invFunOn f s b = Classical.choice inst✝
Theorem: hasSum_zero
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simp [HasSum, tendsto_const_nhds]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.14510
δ : Type ?u.14513
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
⊢ HasSum (fun x => 0) 0
Theorem: MeasureTheory.Measure.toSignedMeasure_add
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: ext i
state_before: α : Type u_1
β : Type ?u.137383
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
⊢ toSignedMeasure (μ + ν) = toSignedMeasure μ + toSignedMeasure ν

tactic: intro hi
state_before: case h
α : Type u_1
β : Type ?u.137383
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
i : Set α
⊢ MeasurableSet i → ↑(toSignedMeasure (μ + ν)) i = ↑(toSignedMeasure μ + toSignedMeasure ν) i

tactic: rw [toSignedMeasure_apply_measurable hi, add_apply,
  ENNReal.toReal_add (ne_of_lt (measure_lt_top _ _)) (ne_of_lt (measure_lt_top _ _)),
  VectorMeasure.add_apply, toSignedMeasure_apply_measurable hi,
  toSignedMeasure_apply_measurable hi]
state_before: case h
α : Type u_1
β : Type ?u.137383
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
i : Set α
hi : MeasurableSet i
⊢ ↑(toSignedMeasure (μ + ν)) i = ↑(toSignedMeasure μ + toSignedMeasure ν) i
Theorem: Polynomial.eval₂_nat_cast
File: Mathlib/Data/Polynomial/Eval.lean

tactic: induction' n with n ih
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
x : S
n : ℕ
⊢ eval₂ f x ↑n = ↑n

tactic: simp only [eval₂_zero, Nat.cast_zero, Nat.zero_eq]
state_before: case zero
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
x : S
⊢ eval₂ f x ↑Nat.zero = ↑Nat.zero

tactic: rw [n.cast_succ, eval₂_add, ih, eval₂_one, n.cast_succ]
state_before: case succ
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
x : S
n : ℕ
ih : eval₂ f x ↑n = ↑n
⊢ eval₂ f x ↑(Nat.succ n) = ↑(Nat.succ n)
Theorem: Polynomial.nat_cast_coeff_zero
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: induction' n with n ih
state_before: R✝ : Type u
S : Type v
a b : R✝
n✝ m : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
n : ℕ
R : Type u_1
inst✝ : Semiring R
⊢ coeff (↑n) 0 = ↑n

tactic: simp
state_before: case zero
R✝ : Type u
S : Type v
a b : R✝
n m : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
R : Type u_1
inst✝ : Semiring R
⊢ coeff (↑Nat.zero) 0 = ↑Nat.zero

tactic: simp [ih]
state_before: case succ
R✝ : Type u
S : Type v
a b : R✝
n✝ m : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
R : Type u_1
inst✝ : Semiring R
n : ℕ
ih : coeff (↑n) 0 = ↑n
⊢ coeff (↑(Nat.succ n)) 0 = ↑(Nat.succ n)
Theorem: skewAdjoint.mem_iff
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: rw [← AddSubgroup.mem_carrier]
state_before: R : Type u_1
A : Type ?u.105083
inst✝¹ : AddCommGroup R
inst✝ : StarAddMonoid R
x : R
⊢ x ∈ skewAdjoint R ↔ star x = -x

tactic: exact Iff.rfl
state_before: R : Type u_1
A : Type ?u.105083
inst✝¹ : AddCommGroup R
inst✝ : StarAddMonoid R
x : R
⊢ x ∈ (skewAdjoint R).toAddSubmonoid.toAddSubsemigroup.carrier ↔ star x = -x
Theorem: Order.Ioc_succ_right
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [← Ioi_inter_Iic, Iic_succ, inter_insert_of_mem (mem_Ioi.2 h)]
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
h : a < succ b
⊢ Ioc a (succ b) = insert (succ b) (Ioc a b)
Theorem: MeasureTheory.SimpleFunc.integral_eq_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [MeasureTheory.integral_eq f hfi, ← L1.SimpleFunc.toLp_one_eq_toL1,
  L1.SimpleFunc.integral_L1_eq_integral, L1.SimpleFunc.integral_eq_integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.1246877
𝕜 : Type ?u.1246880
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1249571
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α →ₛ E
hfi : Integrable ↑f
⊢ integral μ f = ∫ (x : α), ↑f x ∂μ

tactic: exact SimpleFunc.integral_congr hfi (Lp.simpleFunc.toSimpleFunc_toLp _ _).symm
state_before: α : Type u_1
E : Type u_2
F : Type ?u.1246877
𝕜 : Type ?u.1246880
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1249571
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α →ₛ E
hfi : Integrable ↑f
⊢ integral μ f = integral μ (Lp.simpleFunc.toSimpleFunc (Lp.simpleFunc.toLp f (_ : Memℒp (↑f) 1)))
Theorem: Vector.insertNth_comm
File: Mathlib/Data/Vector/Basic.lean

tactic: refine' Subtype.eq _
state_before: n : ℕ
α : Type u_1
β : Type ?u.56356
γ : Type ?u.56359
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : List.length l = n
⊢ insertNth b (Fin.succ j) (insertNth a i { val := l, property := hl }) =
    insertNth a (↑Fin.castSucc i) (insertNth b j { val := l, property := hl })

tactic: simp only [insertNth_val, Fin.val_succ, Fin.castSucc, Fin.coe_castAdd]
state_before: n : ℕ
α : Type u_1
β : Type ?u.56356
γ : Type ?u.56359
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : List.length l = n
⊢ ↑(insertNth b (Fin.succ j) (insertNth a i { val := l, property := hl })) =
    ↑(insertNth a (↑Fin.castSucc i) (insertNth b j { val := l, property := hl }))

tactic: apply List.insertNth_comm
state_before: n : ℕ
α : Type u_1
β : Type ?u.56356
γ : Type ?u.56359
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : List.length l = n
⊢ List.insertNth (↑j + 1) b (List.insertNth (↑i) a l) = List.insertNth (↑i) a (List.insertNth (↑j) b l)

tactic: assumption
state_before: case x
n : ℕ
α : Type u_1
β : Type ?u.56356
γ : Type ?u.56359
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : List.length l = n
⊢ ↑i ≤ ↑j

tactic: rw [hl]
state_before: case x
n : ℕ
α : Type u_1
β : Type ?u.56356
γ : Type ?u.56359
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : List.length l = n
⊢ ↑j ≤ List.length l

tactic: exact Nat.le_of_succ_le_succ j.2
state_before: case x
n : ℕ
α : Type u_1
β : Type ?u.56356
γ : Type ?u.56359
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : List.length l = n
⊢ ↑j ≤ n
Theorem: Finset.Ico_filter_lt_of_le_right
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext x
state_before: ι : Type ?u.30542
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : DecidablePred fun x => x < c
hcb : c ≤ b
⊢ filter (fun x => x < c) (Ico a b) = Ico a c

tactic: rw [mem_filter, mem_Ico, mem_Ico, and_right_comm]
state_before: case a
ι : Type ?u.30542
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x✝ : α
inst✝ : DecidablePred fun x => x < c
hcb : c ≤ b
x : α
⊢ x ∈ filter (fun x => x < c) (Ico a b) ↔ x ∈ Ico a c

tactic: exact and_iff_left_of_imp fun h => h.2.trans_le hcb
state_before: case a
ι : Type ?u.30542
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x✝ : α
inst✝ : DecidablePred fun x => x < c
hcb : c ≤ b
x : α
⊢ (a ≤ x ∧ x < c) ∧ x < b ↔ a ≤ x ∧ x < c
Theorem: RingEquiv.noZeroDivisors
File: Mathlib/Algebra/Ring/Equiv.lean

tactic: have : e x * e y = 0 := by rw [← e.map_mul, hxy, e.map_zero]
state_before: F : Type ?u.112165
α : Type ?u.112168
β : Type ?u.112171
R : Type ?u.112174
S : Type ?u.112177
S' : Type ?u.112180
inst✝⁶ : Add R
inst✝⁵ : Add S
inst✝⁴ : Mul R
inst✝³ : Mul S
A : Type u_1
B : Type u_2
inst✝² : Ring A
inst✝¹ : Ring B
inst✝ : NoZeroDivisors B
e : A ≃+* B
x y : A
hxy : x * y = 0
⊢ x = 0 ∨ y = 0

tactic: simpa using eq_zero_or_eq_zero_of_mul_eq_zero this
state_before: F : Type ?u.112165
α : Type ?u.112168
β : Type ?u.112171
R : Type ?u.112174
S : Type ?u.112177
S' : Type ?u.112180
inst✝⁶ : Add R
inst✝⁵ : Add S
inst✝⁴ : Mul R
inst✝³ : Mul S
A : Type u_1
B : Type u_2
inst✝² : Ring A
inst✝¹ : Ring B
inst✝ : NoZeroDivisors B
e : A ≃+* B
x y : A
hxy : x * y = 0
this : ↑e x * ↑e y = 0
⊢ x = 0 ∨ y = 0

tactic: rw [← e.map_mul, hxy, e.map_zero]
state_before: F : Type ?u.112165
α : Type ?u.112168
β : Type ?u.112171
R : Type ?u.112174
S : Type ?u.112177
S' : Type ?u.112180
inst✝⁶ : Add R
inst✝⁵ : Add S
inst✝⁴ : Mul R
inst✝³ : Mul S
A : Type u_1
B : Type u_2
inst✝² : Ring A
inst✝¹ : Ring B
inst✝ : NoZeroDivisors B
e : A ≃+* B
x y : A
hxy : x * y = 0
⊢ ↑e x * ↑e y = 0
Theorem: Int.emod_one
File: Std/Data/Int/DivMod.lean

tactic: simp [emod_def, Int.one_mul, Int.sub_self]
state_before: a : Int
⊢ a % 1 = 0