tasksource/leandojo huggingface dataset:
Theorem: EReal.neg_mul
File: Mathlib/Data/Real/EReal.lean

tactic: induction x, y using induction₂_neg_left with
| top_zero | zero_top | zero_bot => simp only [zero_mul, mul_zero, neg_zero]
| top_top | top_bot => rfl
| neg_left h => rw [h, neg_neg, neg_neg]
| coe_coe => norm_cast; exact neg_mul _ _
| top_pos _ h => rw [top_mul_coe_of_pos h, neg_top, bot_mul_coe_of_pos h]
| pos_top _ h => rw [coe_mul_top_of_pos h, neg_top, ← coe_neg,
  coe_mul_top_of_neg (neg_neg_of_pos h)]
| top_neg _ h => rw [top_mul_coe_of_neg h, neg_top, bot_mul_coe_of_neg h, neg_bot]
| pos_bot _ h => rw [coe_mul_bot_of_pos h, neg_bot, ← coe_neg,
  coe_mul_bot_of_neg (neg_neg_of_pos h)]
state_before: x y : EReal
⊢ -x * y = -(x * y)

tactic: simp only [zero_mul, mul_zero, neg_zero]
state_before: case zero_bot

⊢ -0 * ⊥ = -(0 * ⊥)

tactic: rfl
state_before: case top_bot

⊢ -⊤ * ⊥ = -(⊤ * ⊥)

tactic: rw [h, neg_neg, neg_neg]
state_before: case neg_left
x✝ y✝ : EReal
h : -x✝ * y✝ = -(x✝ * y✝)
⊢ - -x✝ * y✝ = -(-x✝ * y✝)

tactic: norm_cast
state_before: case coe_coe
x✝ y✝ : ℝ
⊢ -↑x✝ * ↑y✝ = -(↑x✝ * ↑y✝)

tactic: exact neg_mul _ _
state_before: case coe_coe
x✝ y✝ : ℝ
⊢ -x✝ * y✝ = -(x✝ * y✝)

tactic: rw [top_mul_coe_of_pos h, neg_top, bot_mul_coe_of_pos h]
state_before: case top_pos
x✝ : ℝ
h : 0 < x✝
⊢ -⊤ * ↑x✝ = -(⊤ * ↑x✝)

tactic: rw [coe_mul_top_of_pos h, neg_top, ← coe_neg,
coe_mul_top_of_neg (neg_neg_of_pos h)]
state_before: case pos_top
x✝ : ℝ
h : 0 < x✝
⊢ -↑x✝ * ⊤ = -(↑x✝ * ⊤)

tactic: rw [top_mul_coe_of_neg h, neg_top, bot_mul_coe_of_neg h, neg_bot]
state_before: case top_neg
x✝ : ℝ
h : x✝ < 0
⊢ -⊤ * ↑x✝ = -(⊤ * ↑x✝)

tactic: rw [coe_mul_bot_of_pos h, neg_bot, ← coe_neg,
coe_mul_bot_of_neg (neg_neg_of_pos h)]
state_before: case pos_bot
x✝ : ℝ
h : 0 < x✝
⊢ -↑x✝ * ⊥ = -(↑x✝ * ⊥)
Theorem: MeasureTheory.measure_diff'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [add_comm, measure_add_diff hm, union_comm]
state_before: α : Type u_1
β : Type ?u.21889
γ : Type ?u.21892
δ : Type ?u.21895
ι : Type ?u.21898
R : Type ?u.21901
R' : Type ?u.21904
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
hm : MeasurableSet t
h_fin : ↑↑μ t ≠ ⊤
⊢ ↑↑μ (s \ t) + ↑↑μ t = ↑↑μ (s ∪ t)
Theorem: Multiset.Rel.add
File: Mathlib/Data/Multiset/Basic.lean

tactic: induction hst
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.439795
δ : Type ?u.439798
r : α → β → Prop
p : γ → δ → Prop
s : Multiset α
t : Multiset β
u : Multiset α
v : Multiset β
hst : Rel r s t
huv : Rel r u v
⊢ Rel r (s + u) (t + v)

tactic: case zero => simpa using huv
state_before: case zero
α : Type u_1
β : Type u_2
γ : Type ?u.439795
δ : Type ?u.439798
r : α → β → Prop
p : γ → δ → Prop
s : Multiset α
t : Multiset β
u : Multiset α
v : Multiset β
huv : Rel r u v
⊢ Rel r (0 + u) (0 + v)

case cons
α : Type u_1
β : Type u_2
γ : Type ?u.439795
δ : Type ?u.439798
r : α → β → Prop
p : γ → δ → Prop
s : Multiset α
t : Multiset β
u : Multiset α
v : Multiset β
huv : Rel r u v
a✝² : α
b✝ : β
as✝ : Multiset α
bs✝ : Multiset β
a✝¹ : r a✝² b✝
a✝ : Rel r as✝ bs✝
a_ih✝ : Rel r (as✝ + u) (bs✝ + v)
⊢ Rel r (a✝² ::ₘ as✝ + u) (b✝ ::ₘ bs✝ + v)

tactic: case cons a b s t hab hst ih => simpa using ih.cons hab
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type ?u.439795
δ : Type ?u.439798
r : α → β → Prop
p : γ → δ → Prop
s : Multiset α
t : Multiset β
u : Multiset α
v : Multiset β
huv : Rel r u v
a✝² : α
b✝ : β
as✝ : Multiset α
bs✝ : Multiset β
a✝¹ : r a✝² b✝
a✝ : Rel r as✝ bs✝
a_ih✝ : Rel r (as✝ + u) (bs✝ + v)
⊢ Rel r (a✝² ::ₘ as✝ + u) (b✝ ::ₘ bs✝ + v)

tactic: simpa using huv
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.439795
δ : Type ?u.439798
r : α → β → Prop
p : γ → δ → Prop
s : Multiset α
t : Multiset β
u : Multiset α
v : Multiset β
huv : Rel r u v
⊢ Rel r (0 + u) (0 + v)

tactic: simpa using ih.cons hab
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.439795
δ : Type ?u.439798
r : α → β → Prop
p : γ → δ → Prop
s✝ : Multiset α
t✝ : Multiset β
u : Multiset α
v : Multiset β
huv : Rel r u v
a : α
b : β
s : Multiset α
t : Multiset β
hab : r a b
hst : Rel r s t
ih : Rel r (s + u) (t + v)
⊢ Rel r (a ::ₘ s + u) (b ::ₘ t + v)
Theorem: Cardinal.bsup_lt_ord_lift_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [hc.cof_eq]
state_before: α : Type ?u.159715
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
c : Cardinal
hc : IsRegular c
hι : lift (card o) < c
⊢ lift (card o) < Ordinal.cof (ord c)
Theorem: Multiset.dedup_cons
File: Mathlib/Data/Multiset/FinsetOps.lean

tactic: by_cases h : a ∈ s <;> simp [h]
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
⊢ dedup (a ::ₘ s) = ndinsert a (dedup s)
Theorem: Units.inv_mul_of_eq
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← h, u.inv_mul]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
h : ↑u = a
⊢ ↑u⁻¹ * a = 1
Theorem: Finset.le_sum_card
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: simp_rw [univ_inter]
state_before: ι : Type ?u.109273
α : Type u_1
β : Type ?u.109279
M : Type ?u.109282
N : Type ?u.109285
G : Type ?u.109288
k : Type ?u.109291
R : Type ?u.109294
inst✝¹ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
inst✝ : Fintype α
h : ∀ (a : α), n ≤ card (filter ((fun x x_1 => x ∈ x_1) a) B)
⊢ ∑ s in B, card (univ ∩ s) = ∑ s in B, card s
Theorem: List.length_tails
File: Mathlib/Data/List/Infix.lean

tactic: induction' l with x l IH
state_before: α : Type u_1
β : Type ?u.48588
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ length (tails l) = length l + 1

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.48588
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ length (tails []) = length [] + 1

tactic: simpa using IH
state_before: case cons
α : Type u_1
β : Type ?u.48588
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x : α
l : List α
IH : length (tails l) = length l + 1
⊢ length (tails (x :: l)) = length (x :: l) + 1
Theorem: Submodule.isClosed_orthogonal
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: rw [orthogonal_eq_inter K]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.53341
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ IsClosed ↑Kᗮ

tactic: have := fun v : K => ContinuousLinearMap.isClosed_ker (innerSL 𝕜 (v : E))
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.53341
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ IsClosed ↑(⨅ (v : { x // x ∈ K }), LinearMap.ker (↑(innerSL 𝕜) ↑v))

tactic: convert isClosed_iInter this
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.53341
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
this : ∀ (v : { x // x ∈ K }), IsClosed ↑(LinearMap.ker (↑(innerSL 𝕜) ↑v))
⊢ IsClosed ↑(⨅ (v : { x // x ∈ K }), LinearMap.ker (↑(innerSL 𝕜) ↑v))

tactic: simp only [iInf_coe]
state_before: case h.e'_3
𝕜 : Type u_2
E : Type u_1
F : Type ?u.53341
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
this : ∀ (v : { x // x ∈ K }), IsClosed ↑(LinearMap.ker (↑(innerSL 𝕜) ↑v))
⊢ ↑(⨅ (v : { x // x ∈ K }), LinearMap.ker (↑(innerSL 𝕜) ↑v)) =
    ⋂ (i : { x // x ∈ K }), ↑(LinearMap.ker (↑(innerSL 𝕜) ↑i))
Theorem: Nat.NormDigits.digits_succ
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases h with ⟨h, b2, m0⟩
state_before: n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : digits b m = l ∧ 1 < b ∧ 0 < m
⊢ digits b n = r :: l ∧ 1 < b ∧ 0 < n

tactic: have b0 : 0 < b := by linarith
state_before: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : digits b m = l
b2 : 1 < b
m0 : 0 < m
⊢ digits b n = r :: l ∧ 1 < b ∧ 0 < n

tactic: have n0 : 0 < n := by linarith [mul_pos b0 m0]
state_before: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : digits b m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
⊢ digits b n = r :: l ∧ 1 < b ∧ 0 < n

tactic: refine' ⟨_, b2, n0⟩
state_before: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : digits b m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
n0 : 0 < n
⊢ digits b n = r :: l ∧ 1 < b ∧ 0 < n

tactic: obtain ⟨rfl, rfl⟩ := (Nat.div_mod_unique b0).2 ⟨e, hr⟩
state_before: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : digits b m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
n0 : 0 < n
⊢ digits b n = r :: l

tactic: subst h
state_before: case intro.intro.intro
n✝ b n : ℕ
l : List ℕ
b2 : 1 < b
b0 : 0 < b
n0 : 0 < n
h : digits b (n / b) = l
m0 : 0 < n / b
hr : n % b < b
e : n % b + b * (n / b) = n
⊢ digits b n = n % b :: l

tactic: exact Nat.digits_def' b2 n0
state_before: case intro.intro.intro
n✝ b n : ℕ
b2 : 1 < b
b0 : 0 < b
n0 : 0 < n
m0 : 0 < n / b
hr : n % b < b
e : n % b + b * (n / b) = n
⊢ digits b n = n % b :: digits b (n / b)

tactic: linarith
state_before: n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : digits b m = l
b2 : 1 < b
m0 : 0 < m
⊢ 0 < b

tactic: linarith [mul_pos b0 m0]
state_before: n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : digits b m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
⊢ 0 < n
Theorem: CategoryTheory.FreeBicategory.normalizeAux_nil_comp
File: Mathlib/CategoryTheory/Bicategory/Coherence.lean

tactic: induction g generalizing a with
| id => rfl
| of => rfl
| comp g _ ihf ihg => erw [ihg (f.comp g), ihf f, ihg g, comp_assoc]
state_before: B : Type u
inst✝ : Quiver B
a b c : B
f : Hom a b
g : Hom b c
⊢ normalizeAux nil (Hom.comp f g) = comp (normalizeAux nil f) (normalizeAux nil g)

tactic: rfl
state_before: case id
B : Type u
inst✝ : Quiver B
b c a✝ a : B
f : Hom a a✝
⊢ normalizeAux nil (Hom.comp f (Hom.id a✝)) = comp (normalizeAux nil f) (normalizeAux nil (Hom.id a✝))

tactic: rfl
state_before: case of
B : Type u
inst✝ : Quiver B
b c a✝ b✝ : B
f✝ : a✝ ⟶ b✝
a : B
f : Hom a a✝
⊢ normalizeAux nil (Hom.comp f (Hom.of f✝)) = comp (normalizeAux nil f) (normalizeAux nil (Hom.of f✝))

tactic: erw [ihg (f.comp g), ihf f, ihg g, comp_assoc]
state_before: case comp
B : Type u
inst✝ : Quiver B
b c a✝ b✝ c✝ : B
g : Hom a✝ b✝
g✝ : Hom b✝ c✝
ihf : ∀ {a : B} (f : Hom a a✝), normalizeAux nil (Hom.comp f g) = comp (normalizeAux nil f) (normalizeAux nil g)
ihg : ∀ {a : B} (f : Hom a b✝), normalizeAux nil (Hom.comp f g✝) = comp (normalizeAux nil f) (normalizeAux nil g✝)
a : B
f : Hom a a✝
⊢ normalizeAux nil (Hom.comp f (Hom.comp g g✝)) = comp (normalizeAux nil f) (normalizeAux nil (Hom.comp g g✝))
Theorem: Tropical.add_pow
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: cases' le_total x y with h h
state_before: R : Type u
inst✝³ : LinearOrder R
inst✝² : AddMonoid R
inst✝¹ : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass R R (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
x y : Tropical R
n : ℕ
⊢ (x + y) ^ n = x ^ n + y ^ n

tactic: rw [add_eq_left h, add_eq_left (pow_le_pow_of_le_left' h _)]
state_before: case inl
R : Type u
inst✝³ : LinearOrder R
inst✝² : AddMonoid R
inst✝¹ : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass R R (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
x y : Tropical R
n : ℕ
h : x ≤ y
⊢ (x + y) ^ n = x ^ n + y ^ n

tactic: rw [add_eq_right h, add_eq_right (pow_le_pow_of_le_left' h _)]
state_before: case inr
R : Type u
inst✝³ : LinearOrder R
inst✝² : AddMonoid R
inst✝¹ : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass R R (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
x y : Tropical R
n : ℕ
h : y ≤ x
⊢ (x + y) ^ n = x ^ n + y ^ n
Theorem: Finset.Ioc_subset_Iic_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simpa [← coe_subset] using Set.Ioc_subset_Iic_self
state_before: ι : Type ?u.54007
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderBot α
⊢ Ioc a b ⊆ Iic b
Theorem: MvPowerSeries.coeff_monomial_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: have :
  ∀ p ∈ antidiagonal m,
    coeff R (p : (σ →₀ ℕ) × (σ →₀ ℕ)).1 (monomial R n a) * coeff R p.2 φ ≠ 0 → p.1 = n :=
  fun p _ hp => eq_of_coeff_monomial_ne_zero (left_ne_zero_of_mul hp)
state_before: σ : Type u_2
R : Type u_1
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
⊢ ↑(coeff R m) (↑(monomial R n) a * φ) = if n ≤ m then a * ↑(coeff R (m - n)) φ else 0

tactic: rw [coeff_mul, ← Finset.sum_filter_of_ne this, antidiagonal_filter_fst_eq, Finset.sum_ite_index]
state_before: σ : Type u_2
R : Type u_1
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
this :
  ∀ (p : (σ →₀ ℕ) × (σ →₀ ℕ)),
    p ∈ antidiagonal m → ↑(coeff R p.fst) (↑(monomial R n) a) * ↑(coeff R p.snd) φ ≠ 0 → p.fst = n
⊢ ↑(coeff R m) (↑(monomial R n) a * φ) = if n ≤ m then a * ↑(coeff R (m - n)) φ else 0

tactic: simp only [Finset.sum_singleton, coeff_monomial_same, Finset.sum_empty]
state_before: σ : Type u_2
R : Type u_1
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
this :
  ∀ (p : (σ →₀ ℕ) × (σ →₀ ℕ)),
    p ∈ antidiagonal m → ↑(coeff R p.fst) (↑(monomial R n) a) * ↑(coeff R p.snd) φ ≠ 0 → p.fst = n
⊢ (if n ≤ m then ∑ x in {(n, m - n)}, ↑(coeff R x.fst) (↑(monomial R n) a) * ↑(coeff R x.snd) φ
    else ∑ x in ∅, ↑(coeff R x.fst) (↑(monomial R n) a) * ↑(coeff R x.snd) φ) =
    if n ≤ m then a * ↑(coeff R (m - n)) φ else 0
Theorem: Nat.bodd_mul
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: induction' n with n IH
state_before: m n : ℕ
⊢ bodd (m * n) = (bodd m && bodd n)

tactic: simp
state_before: case zero
m : ℕ
⊢ bodd (m * zero) = (bodd m && bodd zero)

tactic: simp [mul_succ, IH]
state_before: case succ
m n : ℕ
IH : bodd (m * n) = (bodd m && bodd n)
⊢ bodd (m * succ n) = (bodd m && bodd (succ n))

tactic: cases bodd m <;> cases bodd n <;> rfl
state_before: case succ
m n : ℕ
IH : bodd (m * n) = (bodd m && bodd n)
⊢ bxor (bodd m && bodd n) (bodd m) = (bodd m && !bodd n)
Theorem: Complex.ofReal_exp_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← exp_conj, conj_ofReal]
state_before: x✝ y : ℂ
x : ℝ
⊢ ↑(starRingEnd ℂ) (exp ↑x) = exp ↑x
Theorem: mul_div_mul_comm
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.47654
G : Type ?u.47657
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a * b / (c * d) = a / c * (b / d)
Theorem: Finsupp.single_finset_sum
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: trans
state_before: α : Type u_3
ι : Type u_2
γ : Type ?u.271042
A : Type ?u.271045
B : Type ?u.271048
C : Type ?u.271051
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.274181
M : Type u_1
M' : Type ?u.274187
N : Type ?u.274190
P : Type ?u.274193
G : Type ?u.274196
H : Type ?u.274199
R : Type ?u.274202
S : Type ?u.274205
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → M
a : α
⊢ single a (∑ b in s, f b) = ∑ b in s, single a (f b)

tactic: apply single_multiset_sum
state_before: α : Type u_3
ι : Type u_2
γ : Type ?u.271042
A : Type ?u.271045
B : Type ?u.271048
C : Type ?u.271051
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.274181
M : Type u_1
M' : Type ?u.274187
N : Type ?u.274190
P : Type ?u.274193
G : Type ?u.274196
H : Type ?u.274199
R : Type ?u.274202
S : Type ?u.274205
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → M
a : α
⊢ single a (∑ b in s, f b) = ?m.274947

tactic: rw [Multiset.map_map]
state_before: α : Type u_3
ι : Type u_2
γ : Type ?u.271042
A : Type ?u.271045
B : Type ?u.271048
C : Type ?u.271051
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.274181
M : Type u_1
M' : Type ?u.274187
N : Type ?u.274190
P : Type ?u.274193
G : Type ?u.274196
H : Type ?u.274199
R : Type ?u.274202
S : Type ?u.274205
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → M
a : α
⊢ Multiset.sum (Multiset.map (single a) (Multiset.map (fun b => f b) s.val)) = ∑ b in s, single a (f b)

tactic: rfl
state_before: α : Type u_3
ι : Type u_2
γ : Type ?u.271042
A : Type ?u.271045
B : Type ?u.271048
C : Type ?u.271051
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.274181
M : Type u_1
M' : Type ?u.274187
N : Type ?u.274190
P : Type ?u.274193
G : Type ?u.274196
H : Type ?u.274199
R : Type ?u.274202
S : Type ?u.274205
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → M
a : α
⊢ Multiset.sum (Multiset.map (single a ∘ fun b => f b) s.val) = ∑ b in s, single a (f b)
Theorem: Nat.ModEq.dvd_iff
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp only [← modEq_zero_iff_dvd]
state_before: m n a b c d : ℕ
h : a ≡ b [MOD m]
hdm : d ∣ m
⊢ d ∣ a ↔ d ∣ b

tactic: replace h := h.of_dvd hdm
state_before: m n a b c d : ℕ
h : a ≡ b [MOD m]
hdm : d ∣ m
⊢ a ≡ 0 [MOD d] ↔ b ≡ 0 [MOD d]

tactic: exact ⟨h.symm.trans, h.trans⟩
state_before: m n a b c d : ℕ
hdm : d ∣ m
h : a ≡ b [MOD d]
⊢ a ≡ 0 [MOD d] ↔ b ≡ 0 [MOD d]
Theorem: Cardinal.aleph_one_le_continuum
File: Mathlib/SetTheory/Cardinal/Continuum.lean

tactic: rw [← succ_aleph0]
state_before: ⊢ aleph 1 ≤ 𝔠

tactic: exact Order.succ_le_of_lt aleph0_lt_continuum
state_before: ⊢ Order.succ ℵ₀ ≤ 𝔠
Theorem: Part.mem_toOption
File: Mathlib/Data/Part.lean

tactic: unfold toOption
state_before: α : Type u_1
β : Type ?u.7431
γ : Type ?u.7434
o : Part α
inst✝ : Decidable o.Dom
a : α
⊢ a ∈ toOption o ↔ a ∈ o

tactic: by_cases h : o.Dom <;> simp [h]
state_before: α : Type u_1
β : Type ?u.7431
γ : Type ?u.7434
o : Part α
inst✝ : Decidable o.Dom
a : α
⊢ (a ∈ if h : o.Dom then Option.some (get o h) else Option.none) ↔ a ∈ o

tactic: exact ⟨fun h => ⟨_, h⟩, fun ⟨_, h⟩ => h⟩
state_before: case pos
α : Type u_1
β : Type ?u.7431
γ : Type ?u.7434
o : Part α
inst✝ : Decidable o.Dom
a : α
h : o.Dom
⊢ get o (_ : o.Dom) = a ↔ a ∈ o

tactic: exact mt Exists.fst h
state_before: case neg
α : Type u_1
β : Type ?u.7431
γ : Type ?u.7434
o : Part α
inst✝ : Decidable o.Dom
a : α
h : ¬o.Dom
⊢ ¬a ∈ o
Theorem: add_halves'
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: rw [← add_div, half_add_self]
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
a : R
⊢ a / 2 + a / 2 = a
Theorem: le_of_forall_sub_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: contrapose! h
state_before: ι : Type ?u.195915
α : Type u_1
β : Type ?u.195921
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h : ∀ (ε : α), ε > 0 → b - ε ≤ a
⊢ b ≤ a

tactic: simpa only [@and_comm ((0 : α) < _), lt_sub_iff_add_lt, gt_iff_lt] using
  exists_add_lt_and_pos_of_lt h
state_before: ι : Type ?u.195915
α : Type u_1
β : Type ?u.195921
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h : a < b
⊢ ∃ ε, ε > 0 ∧ a < b - ε
Theorem: Equiv.Perm.IsCycleOn.zpow_apply_eq_zpow_apply
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [Int.modEq_iff_dvd, ← hf.zpow_apply_eq ha]
state_before: ι : Type ?u.1791500
α : Type u_1
β : Type ?u.1791506
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
m n : ℤ
⊢ ↑(f ^ m) a = ↑(f ^ n) a ↔ m ≡ n [ZMOD ↑(card s)]

tactic: simp [sub_eq_neg_add, zpow_add, eq_inv_iff_eq, eq_comm]
state_before: ι : Type ?u.1791500
α : Type u_1
β : Type ?u.1791506
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
m n : ℤ
⊢ ↑(f ^ m) a = ↑(f ^ n) a ↔ ↑(f ^ (n - m)) a = a
Theorem: IsNoetherian.iff_rank_lt_aleph0
File: Mathlib/FieldTheory/Finiteness.lean

tactic: let b := Basis.ofVectorSpace K V
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ IsNoetherian K V ↔ Module.rank K V < ℵ₀

tactic: rw [← b.mk_eq_rank'', lt_aleph0_iff_set_finite]
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
b : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
⊢ IsNoetherian K V ↔ Module.rank K V < ℵ₀

tactic: constructor
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
b : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
⊢ IsNoetherian K V ↔ Set.Finite (Basis.ofVectorSpaceIndex K V)

tactic: intro
state_before: case mp
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
b : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
⊢ IsNoetherian K V → Set.Finite (Basis.ofVectorSpaceIndex K V)

tactic: exact finite_of_linearIndependent (Basis.ofVectorSpaceIndex.linearIndependent K V)
state_before: case mp
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
b : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
a✝ : IsNoetherian K V
⊢ Set.Finite (Basis.ofVectorSpaceIndex K V)

tactic: intro hbfinite
state_before: case mpr
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
b : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
⊢ Set.Finite (Basis.ofVectorSpaceIndex K V) → IsNoetherian K V

tactic: refine'
  @isNoetherian_of_linearEquiv K (⊤ : Submodule K V) V _ _ _ _ _ (LinearEquiv.ofTop _ rfl)
    (id _)
state_before: case mpr
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
b : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
hbfinite : Set.Finite (Basis.ofVectorSpaceIndex K V)
⊢ IsNoetherian K V

tactic: refine' isNoetherian_of_fg_of_noetherian _ ⟨Set.Finite.toFinset hbfinite, _⟩
state_before: case mpr
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
b : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
hbfinite : Set.Finite (Basis.ofVectorSpaceIndex K V)
⊢ IsNoetherian K { x // x ∈ ⊤ }

tactic: rw [Set.Finite.coe_toFinset, ← b.span_eq, Basis.coe_ofVectorSpace, Subtype.range_coe]
state_before: case mpr
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
b : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
hbfinite : Set.Finite (Basis.ofVectorSpaceIndex K V)
⊢ span K ↑(Set.Finite.toFinset hbfinite) = ⊤
Theorem: Nat.coprime_mul_left_add_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [coprime, coprime, gcd_mul_left_add_right]
state_before: m n k : ℕ
⊢ coprime m (m * k + n) ↔ coprime m n
Theorem: isConformalMap_id
File: Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean

tactic: simp
state_before: R : Type u_1
M : Type u_2
N : Type ?u.8223
G : Type ?u.8226
M' : Type ?u.8229
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
⊢ ContinuousLinearMap.id R M = 1 • toContinuousLinearMap LinearIsometry.id
Theorem: MvPolynomial.comap_rename
File: Mathlib/Data/MvPolynomial/Comap.lean

tactic: funext
state_before: σ : Type u_1
τ : Type u_3
υ : Type ?u.158664
R : Type u_2
inst✝ : CommSemiring R
f : σ → τ
x : τ → R
⊢ comap (rename f) x = x ∘ f

tactic: simp [rename_X, comap_apply, aeval_X]
state_before: case h
σ : Type u_1
τ : Type u_3
υ : Type ?u.158664
R : Type u_2
inst✝ : CommSemiring R
f : σ → τ
x : τ → R
x✝ : σ
⊢ comap (rename f) x x✝ = (x ∘ f) x✝