tasksource/leandojo huggingface dataset:
Theorem: List.oldMapIdxCore_eq
File: Mathlib/Data/List/Indexes.lean

tactic: induction' l with hd tl hl generalizing f n
state_before: α : Type u
β : Type v
l : List α
f : ℕ → α → β
n : ℕ
⊢ List.oldMapIdxCore f n l = List.oldMapIdx (fun i a => f (i + n) a) l

tactic: rfl
state_before: case nil
α : Type u
β : Type v
f✝ : ℕ → α → β
n✝ : ℕ
f : ℕ → α → β
n : ℕ
⊢ List.oldMapIdxCore f n [] = List.oldMapIdx (fun i a => f (i + n) a) []

tactic: rw [List.oldMapIdx]
state_before: case cons
α : Type u
β : Type v
f✝ : ℕ → α → β
n✝ : ℕ
hd : α
tl : List α
hl : ∀ (f : ℕ → α → β) (n : ℕ), List.oldMapIdxCore f n tl = List.oldMapIdx (fun i a => f (i + n) a) tl
f : ℕ → α → β
n : ℕ
⊢ List.oldMapIdxCore f n (hd :: tl) = List.oldMapIdx (fun i a => f (i + n) a) (hd :: tl)

tactic: simp only [List.oldMapIdxCore, hl, add_left_comm, add_comm, add_zero, zero_add]
state_before: case cons
α : Type u
β : Type v
f✝ : ℕ → α → β
n✝ : ℕ
hd : α
tl : List α
hl : ∀ (f : ℕ → α → β) (n : ℕ), List.oldMapIdxCore f n tl = List.oldMapIdx (fun i a => f (i + n) a) tl
f : ℕ → α → β
n : ℕ
⊢ List.oldMapIdxCore f n (hd :: tl) = List.oldMapIdxCore (fun i a => f (i + n) a) 0 (hd :: tl)
Theorem: RingHom.ker_equiv
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simpa only [← injective_iff_ker_eq_bot] using EquivLike.injective f
state_before: R : Type u
S : Type v
T : Type w
F : Type ?u.1774019
inst✝² : Ring R
inst✝¹ : Semiring S
rc : RingHomClass F R S
f✝ : F
F' : Type u_1
inst✝ : RingEquivClass F' R S
f : F'
⊢ ker f = ⊥
Theorem: LaurentPolynomial.T_pow
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: rw [T, T, single_pow n, one_pow, nsmul_eq_mul]
state_before: R : Type u_1
inst✝ : Semiring R
m : ℤ
n : ℕ
⊢ T m ^ n = T (↑n * m)
Theorem: LocalHomeomorph.ofSet_univ_eq_refl
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: ext <;> simp
state_before: α : Type u_1
β : Type ?u.64088
γ : Type ?u.64091
δ : Type ?u.64094
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
s : Set α
hs : IsOpen s
⊢ ofSet univ (_ : IsOpen univ) = LocalHomeomorph.refl α
Theorem: GeneralizedContinuedFraction.convergents'Aux_succ_none
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simp [convergents'Aux, h, convergents'Aux.match_1]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
h : Stream'.Seq.head s = none
n : ℕ
⊢ convergents'Aux s (n + 1) = 0
Theorem: Rat.inv_neg
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [← @num_den q]
state_before: q : ℚ
⊢ (-q)⁻¹ = -q⁻¹

tactic: simp only [Rat.neg_def, Rat.inv_def', eq_self_iff_true, Rat.divInt_neg_den]
state_before: q : ℚ
⊢ (-(q.num /. ↑q.den))⁻¹ = -(q.num /. ↑q.den)⁻¹
Theorem: CategoryTheory.Mat_.additiveObjIsoBiproduct_naturality'
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

tactic: rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv, additiveObjIsoBiproduct_naturality]
state_before: C : Type u₁
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
D : Type u₁
inst✝³ : Category D
inst✝² : Preadditive D
inst✝¹ : HasFiniteBiproducts D
F : Mat_ C ⥤ D
inst✝ : Functor.Additive F
M N : Mat_ C
f : M ⟶ N
⊢ (additiveObjIsoBiproduct F M).inv ≫ F.map f =
    (biproduct.matrix fun i j => F.map ((embedding C).map (f i j))) ≫ (additiveObjIsoBiproduct F N).inv
Theorem: tsub_add_eq_max
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: cases' le_total a b with h h
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - b + b = max a b

tactic: rw [max_eq_right h, tsub_eq_zero_of_le h, zero_add]
state_before: case inl
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ a - b + b = max a b

tactic: rw [max_eq_left h, tsub_add_cancel_of_le h]
state_before: case inr
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : b ≤ a
⊢ a - b + b = max a b
Theorem: Nat.mul_mod_left
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.mul_comm, mul_mod_right]
state_before: m n : Nat
⊢ m * n % n = 0
Theorem: Multiset.rel_refl_of_refl_on
File: Mathlib/Data/Multiset/Basic.lean

tactic: refine' m.induction_on _ _
state_before: α : Type u_1
β : Type ?u.438879
γ : Type ?u.438882
δ : Type ?u.438885
r✝ : α → β → Prop
p : γ → δ → Prop
m : Multiset α
r : α → α → Prop
⊢ (∀ (x : α), x ∈ m → r x x) → Rel r m m

tactic: intros
state_before: case refine'_1
α : Type u_1
β : Type ?u.438879
γ : Type ?u.438882
δ : Type ?u.438885
r✝ : α → β → Prop
p : γ → δ → Prop
m : Multiset α
r : α → α → Prop
⊢ (∀ (x : α), x ∈ 0 → r x x) → Rel r 0 0

tactic: apply Rel.zero
state_before: case refine'_1
α : Type u_1
β : Type ?u.438879
γ : Type ?u.438882
δ : Type ?u.438885
r✝ : α → β → Prop
p : γ → δ → Prop
m : Multiset α
r : α → α → Prop
a✝ : ∀ (x : α), x ∈ 0 → r x x
⊢ Rel r 0 0

tactic: intro a m ih h
state_before: case refine'_2
α : Type u_1
β : Type ?u.438879
γ : Type ?u.438882
δ : Type ?u.438885
r✝ : α → β → Prop
p : γ → δ → Prop
m : Multiset α
r : α → α → Prop
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    ((∀ (x : α), x ∈ s → r x x) → Rel r s s) → (∀ (x : α), x ∈ a ::ₘ s → r x x) → Rel r (a ::ₘ s) (a ::ₘ s)

tactic: exact Rel.cons (h _ (mem_cons_self _ _)) (ih fun _ ha => h _ (mem_cons_of_mem ha))
state_before: case refine'_2
α : Type u_1
β : Type ?u.438879
γ : Type ?u.438882
δ : Type ?u.438885
r✝ : α → β → Prop
p : γ → δ → Prop
m✝ : Multiset α
r : α → α → Prop
a : α
m : Multiset α
ih : (∀ (x : α), x ∈ m → r x x) → Rel r m m
h : ∀ (x : α), x ∈ a ::ₘ m → r x x
⊢ Rel r (a ::ₘ m) (a ::ₘ m)
Theorem: Set.Finite.toFinset_image2
File: Mathlib/Data/Finset/NAry.lean

tactic: simp
state_before: α : Type u_1
α' : Type ?u.107842
β : Type u_2
β' : Type ?u.107848
γ : Type u_3
γ' : Type ?u.107854
δ : Type ?u.107857
δ' : Type ?u.107860
ε : Type ?u.107863
ε' : Type ?u.107866
ζ : Type ?u.107869
ζ' : Type ?u.107872
ν : Type ?u.107875
inst✝ : DecidableEq γ
s : Set α
t : Set β
f : α → β → γ
hs : Set.Finite s
ht : Set.Finite t
hf : optParam (Set.Finite (image2 f s t)) (_ : Set.Finite (image2 f s t))
⊢ ↑(Finite.toFinset hf) = ↑(Finset.image₂ f (Finite.toFinset hs) (Finite.toFinset ht))
Theorem: MeasureTheory.SimpleFunc.lintegral_congr
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp [hx]
state_before: α : Type u_1
β : Type ?u.901885
γ : Type ?u.901888
δ : Type ?u.901891
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
h : ↑f =ᵐ[μ] ↑g
y : ℝ≥0∞
x : α
hx : ↑f x = ↑g x
⊢ x ∈ ↑f ⁻¹' {y} ↔ x ∈ ↑g ⁻¹' {y}
Theorem: MeasureTheory.weightedSMul_apply
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp [weightedSMul]
state_before: α : Type u_1
E : Type ?u.3861
F : Type u_2
𝕜 : Type ?u.3867
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
s : Set α
x : F
⊢ ↑(weightedSMul μ s) x = ENNReal.toReal (↑↑μ s) • x
Theorem: Set.Finite.exists_finset
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', ∀ (a : α), a ∈ s' ↔ a ∈ s

tactic: exact ⟨s.toFinset, fun _ => mem_toFinset⟩
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
a✝ : Fintype ↑s
⊢ ∃ s', ∀ (a : α), a ∈ s' ↔ a ∈ s
Theorem: Stream'.append_append_stream
File: Mathlib/Data/Stream/Init.lean

tactic: rw [List.cons_append, cons_append_stream, cons_append_stream, append_append_stream l₁]
state_before: α : Type u
β : Type v
δ : Type w
a : α
l₁ l₂ : List α
s : Stream' α
⊢ a :: l₁ ++ l₂ ++ₛ s = a :: l₁ ++ₛ (l₂ ++ₛ s)
Theorem: Polynomial.natDegree_nat_cast
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp only [← C_eq_nat_cast, natDegree_C]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ natDegree ↑n = 0
Theorem: Mathlib.Meta.NormNum.isNat_ratCast
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝ : DivisionRing R
n✝ : ℕ
⊢ ↑↑n✝ = ↑n✝
Theorem: Filter.compl_mem_coprod
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [Filter.coprod, mem_sup, compl_mem_comap]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.59876
δ : Type ?u.59879
ι : Sort ?u.59882
f : Filter α
g : Filter β
s : Set (α × β)
la : Filter α
lb : Filter β
⊢ sᶜ ∈ Filter.coprod la lb ↔ (Prod.fst '' s)ᶜ ∈ la ∧ (Prod.snd '' s)ᶜ ∈ lb
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_zero_apply
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: cases isEmpty_or_nonempty α <;> simp [setToSimpleFunc]
state_before: α : Type u_1
E : Type ?u.148632
F : Type u_2
F' : Type u_3
G : Type ?u.148641
𝕜 : Type ?u.148644
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 α
m : MeasurableSpace α
T : Set α → F →L[ℝ] F'
⊢ setToSimpleFunc T 0 = 0
Theorem: xInTermsOfW_aux
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: rw [xInTermsOfW_eq, mul_assoc, ← C_mul, ← mul_pow, invOf_mul_self,
  one_pow, C_1, mul_one]
state_before: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
inst✝ : Invertible ↑p
n : ℕ
⊢ xInTermsOfW p R n * ↑C (↑p ^ n) = X n - ∑ i in range n, ↑C (↑p ^ i) * xInTermsOfW p R i ^ p ^ (n - i)
Theorem: PNat.dvd_iff'
File: Mathlib/Data/PNat/Basic.lean

tactic: rw [dvd_iff]
state_before: k m : ℕ+
⊢ k ∣ m ↔ mod m k = k

tactic: rw [Nat.dvd_iff_mod_eq_zero]
state_before: k m : ℕ+
⊢ ↑k ∣ ↑m ↔ mod m k = k

tactic: constructor
state_before: k m : ℕ+
⊢ ↑m % ↑k = 0 ↔ mod m k = k

tactic: intro h
state_before: case mp
k m : ℕ+
⊢ ↑m % ↑k = 0 → mod m k = k

tactic: apply PNat.eq
state_before: case mp
k m : ℕ+
h : ↑m % ↑k = 0
⊢ mod m k = k

tactic: rw [mod_coe, if_pos h]
state_before: case mp.a
k m : ℕ+
h : ↑m % ↑k = 0
⊢ ↑(mod m k) = ↑k

tactic: intro h
state_before: case mpr
k m : ℕ+
⊢ mod m k = k → ↑m % ↑k = 0

tactic: by_cases h' : (m : ℕ) % (k : ℕ) = 0
state_before: case mpr
k m : ℕ+
h : mod m k = k
⊢ ↑m % ↑k = 0

tactic: exact h'
state_before: case pos
k m : ℕ+
h : mod m k = k
h' : ↑m % ↑k = 0
⊢ ↑m % ↑k = 0

tactic: replace h : (mod m k : ℕ) = (k : ℕ) := congr_arg _ h
state_before: case neg
k m : ℕ+
h : mod m k = k
h' : ¬↑m % ↑k = 0
⊢ ↑m % ↑k = 0

tactic: rw [mod_coe, if_neg h'] at h
state_before: case neg
k m : ℕ+
h' : ¬↑m % ↑k = 0
h : ↑(mod m k) = ↑k
⊢ ↑m % ↑k = 0

tactic: exact ((Nat.mod_lt (m : ℕ) k.pos).ne h).elim
state_before: case neg
k m : ℕ+
h' : ¬↑m % ↑k = 0
h : ↑m % ↑k = ↑k
⊢ ↑m % ↑k = 0
Theorem: constantCoeff_wittStructureRat_zero
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: simp only [wittStructureRat, bind₁, map_aeval, xInTermsOfW_zero, constantCoeff_rename,
  constantCoeff_wittPolynomial, aeval_X, constantCoeff_comp_algebraMap, eval₂Hom_zero'_apply,
  RingHom.id_apply]
state_before: p : ℕ
R : Type ?u.1881167
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
⊢ ↑constantCoeff (wittStructureRat p Φ 0) = ↑constantCoeff Φ
Theorem: ENNReal.toReal_ofReal_eq_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← h]
state_before: α : Type ?u.25525
β : Type ?u.25528
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
h : ENNReal.toReal (ENNReal.ofReal a) = a
⊢ 0 ≤ a

tactic: exact toReal_nonneg
state_before: α : Type ?u.25525
β : Type ?u.25528
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
h : ENNReal.toReal (ENNReal.ofReal a) = a
⊢ 0 ≤ ENNReal.toReal (ENNReal.ofReal a)
Theorem: Matrix.empty_vecAppend
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext
state_before: α : Type u
m n o : ℕ
m' : Type ?u.27911
n' : Type ?u.27914
o' : Type ?u.27917
v : Fin n → α
⊢ vecAppend (_ : n = 0 + n) ![] v = v

tactic: simp [vecAppend_eq_ite]
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.27911
n' : Type ?u.27914
o' : Type ?u.27917
v : Fin n → α
x✝ : Fin n
⊢ vecAppend (_ : n = 0 + n) ![] v x✝ = v x✝
Theorem: AffineBasis.toMatrix_row_sum_one
File: Mathlib/LinearAlgebra/AffineSpace/Matrix.lean

tactic: simp
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : Ring k
inst✝² : Module k V
b : AffineBasis ι k P
ι'✝ : Type ?u.9376
inst✝¹ : Fintype ι'✝
inst✝ : Fintype ι
b₂ : AffineBasis ι k P
ι' : Type u_1
q : ι' → P
i : ι'
⊢ ∑ j : ι, toMatrix b q i j = 1
Theorem: Polynomial.eraseLead_add_of_natDegree_lt_right
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: ext n
state_before: R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree p < natDegree q
⊢ eraseLead (p + q) = p + eraseLead q

tactic: by_cases nd : n = q.natDegree
state_before: case a
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree p < natDegree q
n : ℕ
⊢ coeff (eraseLead (p + q)) n = coeff (p + eraseLead q) n

tactic: rw [nd, eraseLead_coeff, if_pos (natDegree_add_eq_right_of_natDegree_lt pq).symm]
state_before: case pos
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree p < natDegree q
n : ℕ
nd : n = natDegree q
⊢ coeff (eraseLead (p + q)) n = coeff (p + eraseLead q) n

tactic: simpa using (coeff_eq_zero_of_natDegree_lt pq).symm
state_before: case pos
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree p < natDegree q
n : ℕ
nd : n = natDegree q
⊢ 0 = coeff (p + eraseLead q) (natDegree q)

tactic: rw [eraseLead_coeff, coeff_add, coeff_add, eraseLead_coeff, if_neg, if_neg nd]
state_before: case neg
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree p < natDegree q
n : ℕ
nd : ¬n = natDegree q
⊢ coeff (eraseLead (p + q)) n = coeff (p + eraseLead q) n

tactic: rintro rfl
state_before: case neg.hnc
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree p < natDegree q
n : ℕ
nd : ¬n = natDegree q
⊢ ¬n = natDegree (p + q)

tactic: exact nd (natDegree_add_eq_right_of_natDegree_lt pq)
state_before: case neg.hnc
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree p < natDegree q
nd : ¬natDegree (p + q) = natDegree q
⊢ False
Theorem: Equiv.Perm.Disjoint.cycleOf_mul_distrib
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: cases' (disjoint_iff_eq_or_eq.mp h) x with hfx hgx
state_before: ι : Type ?u.2510500
α : Type u_1
β : Type ?u.2510506
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y : α
h : Disjoint f g
x : α
⊢ cycleOf (f * g) x = cycleOf f x * cycleOf g x

tactic: simp [h.commute.eq, cycleOf_mul_of_apply_right_eq_self h.symm.commute, hfx]
state_before: case inl
ι : Type ?u.2510500
α : Type u_1
β : Type ?u.2510506
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y : α
h : Disjoint f g
x : α
hfx : ↑f x = x
⊢ cycleOf (f * g) x = cycleOf f x * cycleOf g x

tactic: simp [cycleOf_mul_of_apply_right_eq_self h.commute, hgx]
state_before: case inr
ι : Type ?u.2510500
α : Type u_1
β : Type ?u.2510506
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x✝ y : α
h : Disjoint f g
x : α
hgx : ↑g x = x
⊢ cycleOf (f * g) x = cycleOf f x * cycleOf g x
Theorem: Finset.cons_eq_insert
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.105127
γ : Type ?u.105130
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝¹ b a✝ : α
s : Finset α
h : ¬a✝ ∈ s
a : α
⊢ a ∈ cons a✝ s h ↔ a ∈ insert a✝ s
Theorem: Dfinsupp.induction₂
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
f✝ : Π₀ (i : ι), β i
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (f + single i b)
i : ι
b : β i
f : Π₀ (i : ι), β i
h1 : ↑f i = 0
h2 : b ≠ 0
h3 : p f
⊢ f + single i b = single i b + f

tactic: by_cases H : i = j
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
f✝ : Π₀ (i : ι), β i
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (f + single i b)
i : ι
b : β i
f : Π₀ (i : ι), β i
h1 : ↑f i = 0
h2 : b ≠ 0
h3 : p f
j : ι
⊢ ↑(f + single i b) j = ↑(single i b + f) j

tactic: subst H
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
f✝ : Π₀ (i : ι), β i
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (f + single i b)
i : ι
b : β i
f : Π₀ (i : ι), β i
h1 : ↑f i = 0
h2 : b ≠ 0
h3 : p f
j : ι
H : i = j
⊢ ↑(f + single i b) j = ↑(single i b + f) j

tactic: simp [h1]
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
f✝ : Π₀ (i : ι), β i
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (f + single i b)
i : ι
b : β i
f : Π₀ (i : ι), β i
h1 : ↑f i = 0
h2 : b ≠ 0
h3 : p f
⊢ ↑(f + single i b) i = ↑(single i b + f) i

tactic: simp [H]
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
f✝ : Π₀ (i : ι), β i
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (f + single i b)
i : ι
b : β i
f : Π₀ (i : ι), β i
h1 : ↑f i = 0
h2 : b ≠ 0
h3 : p f
j : ι
H : ¬i = j
⊢ ↑(f + single i b) j = ↑(single i b + f) j
Theorem: ENNReal.inv_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [*, h.ne', top_mul]
state_before: α : Type ?u.215338
β : Type ?u.215341
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
h : 0 < a
⊢ a ∈ {b | 1 ≤ ⊤ * b}
Theorem: Real.diam_Icc
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp [Metric.diam, ENNReal.toReal_ofReal (sub_nonneg.2 h)]
state_before: α : Type ?u.561104
β : Type ?u.561107
γ : Type ?u.561110
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : a ≤ b
⊢ Metric.diam (Icc a b) = b - a
Theorem: Submodule.map_le_smul_top
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rintro _ ⟨y, hy, rfl⟩
state_before: R : Type u
M : Type v
F : Type ?u.56157
G : Type ?u.56160
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
f : R →ₗ[R] M
⊢ map f I ≤ I • ⊤

tactic: rw [← mul_one y, ← smul_eq_mul, f.map_smul]
state_before: case intro.intro
R : Type u
M : Type v
F : Type ?u.56157
G : Type ?u.56160
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
f : R →ₗ[R] M
y : R
hy : y ∈ ↑I
⊢ ↑f y ∈ I • ⊤

tactic: exact smul_mem_smul hy mem_top
state_before: case intro.intro
R : Type u
M : Type v
F : Type ?u.56157
G : Type ?u.56160
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
f : R →ₗ[R] M
y : R
hy : y ∈ ↑I
⊢ y • ↑f 1 ∈ I • ⊤
Theorem: Complex.ofReal_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [Real.rpow_def_of_nonneg hx, Complex.cpow_def, ofReal_eq_zero]
state_before: x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ ↑(x ^ y) = ↑x ^ ↑y

tactic: split_ifs <;>
simp [Complex.ofReal_log hx]
state_before: x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ ↑(if x = 0 then if y = 0 then 1 else 0 else Real.exp (Real.log x * y)) =
    if x = 0 then if y = 0 then 1 else 0 else exp (log ↑x * ↑y)
Theorem: List.revzip_map_fst
File: Mathlib/Data/List/Zip.lean

tactic: rw [← unzip_left, unzip_revzip]
state_before: α : Type u
β : Type ?u.93517
γ : Type ?u.93520
δ : Type ?u.93523
ε : Type ?u.93526
l : List α
⊢ map Prod.fst (revzip l) = l
Theorem: Equiv.ofInjective_symm_apply
File: Mathlib/Logic/Equiv/Set.lean

tactic: apply (ofInjective f hf).injective
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Type u_2
f : α → β
hf : Injective f
a : α
⊢ ↑(ofInjective f hf).symm { val := f a, property := (_ : ∃ y, f y = f a) } = a

tactic: simp [apply_ofInjective_symm hf]
state_before: case a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Type u_2
f : α → β
hf : Injective f
a : α
⊢ ↑(ofInjective f hf) (↑(ofInjective f hf).symm { val := f a, property := (_ : ∃ y, f y = f a) }) =
    ↑(ofInjective f hf) a
Theorem: Multiset.map_add_left_Ioo
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: classical rw [Ioo, Ioo, ← Finset.image_add_left_Ioo, Finset.image_val,
    ((Finset.nodup _).map <| add_right_injective c).dedup]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map ((fun x x_1 => x + x_1) c) (Ioo a b) = Ioo (c + a) (c + b)

tactic: rw [Ioo, Ioo, ← Finset.image_add_left_Ioo, Finset.image_val,
((Finset.nodup _).map <| add_right_injective c).dedup]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map ((fun x x_1 => x + x_1) c) (Ioo a b) = Ioo (c + a) (c + b)
Theorem: HahnSeries.support_neg
File: Mathlib/RingTheory/HahnSeries.lean

tactic: ext
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x : HahnSeries Γ R
⊢ support (-x) = support x

tactic: simp
state_before: case h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x : HahnSeries Γ R
x✝ : Γ
⊢ x✝ ∈ support (-x) ↔ x✝ ∈ support x
Theorem: Nat.sqrt_add_eq
File: Mathlib/Data/Nat/Sqrt.lean

tactic: rw [succ_mul, mul_succ, add_succ, add_assoc]
state_before: n a : ℕ
h : a ≤ n + n
⊢ n * n + a < succ n * succ n

tactic: exact lt_succ_of_le (Nat.add_le_add_left h _)
state_before: n a : ℕ
h : a ≤ n + n
⊢ n * n + a < succ (n * n + (n + n))
Theorem: Finset.inter_biUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [inter_comm, biUnion_inter]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.513265
inst✝ : DecidableEq β
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
t : Finset β
s : Finset α
f : α → Finset β
⊢ t ∩ Finset.biUnion s f = Finset.biUnion s fun x => t ∩ f x

tactic: simp [inter_comm]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.513265
inst✝ : DecidableEq β
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
t : Finset β
s : Finset α
f : α → Finset β
⊢ (Finset.biUnion s fun x => f x ∩ t) = Finset.biUnion s fun x => t ∩ f x
Theorem: Nat.find_eq_zero
File: Mathlib/Data/Nat/Basic.lean

tactic: simp [find_eq_iff]
state_before: m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
⊢ Nat.find h = 0 ↔ p 0
Theorem: Seminorm.ball_sup
File: Mathlib/Analysis/Seminorm.lean

tactic: simp_rw [ball, ← Set.setOf_and, coe_sup, Pi.sup_apply, sup_lt_iff]
state_before: R : Type ?u.860119
R' : Type ?u.860122
𝕜 : Type u_1
𝕜₂ : Type ?u.860128
𝕜₃ : Type ?u.860131
𝕝 : Type ?u.860134
E : Type u_2
E₂ : Type ?u.860140
E₃ : Type ?u.860143
F : Type ?u.860146
G : Type ?u.860149
ι : Type ?u.860152
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r✝ : ℝ
p q : Seminorm 𝕜 E
e : E
r : ℝ
⊢ ball (p ⊔ q) e r = ball p e r ∩ ball q e r
Theorem: padicValInt.self
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValNat.self hp]
state_before: p : ℕ
hp : 1 < p
⊢ padicValInt p ↑p = 1
Theorem: LaurentPolynomial.degree_T
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: rw [← one_mul (T n), ← map_one C]
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
n : ℤ
⊢ degree (T n) = ↑n

tactic: exact degree_C_mul_T n 1 (one_ne_zero : (1 : R) ≠ 0)
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
n : ℤ
⊢ degree (↑C 1 * T n) = ↑n
Theorem: Nat.doubleFactorial_add_one
File: Mathlib/Data/Nat/Factorial/DoubleFactorial.lean

tactic: cases n <;> rfl
state_before: n : ℕ
⊢ (n + 1)‼ = (n + 1) * (n - 1)‼
Theorem: lt_of_mul_lt_mul_of_nonpos_left
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rwa [neg_mul, neg_mul, neg_lt_neg_iff]
state_before: α : Type u
β : Type ?u.194298
inst✝ : LinearOrderedRing α
a b c : α
h : c * a < c * b
hc : c ≤ 0
⊢ -c * b < -c * a
Theorem: IsROrC.intCast_re
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← ofReal_intCast, ofReal_re]
state_before: K : Type u_1
E : Type ?u.6456011
inst✝ : IsROrC K
n : ℤ
⊢ ↑re ↑n = ↑n