tasksource/leandojo huggingface dataset:
Theorem: MvPolynomial.exists_fin_rename
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: obtain ⟨s, q, rfl⟩ := exists_finset_rename p
state_before: σ : Type u_1
τ : Type ?u.859965
α : Type ?u.859968
R : Type u_2
S : Type ?u.859974
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : MvPolynomial σ R
⊢ ∃ n f _hf q, p = ↑(rename f) q

tactic: let n := Fintype.card { x // x ∈ s }
state_before: case intro.intro
σ : Type u_1
τ : Type ?u.859965
α : Type ?u.859968
R : Type u_2
S : Type ?u.859974
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Finset σ
q : MvPolynomial { x // x ∈ s } R
⊢ ∃ n f _hf q_1, ↑(rename Subtype.val) q = ↑(rename f) q_1

tactic: let e := Fintype.equivFin { x // x ∈ s }
state_before: case intro.intro
σ : Type u_1
τ : Type ?u.859965
α : Type ?u.859968
R : Type u_2
S : Type ?u.859974
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Finset σ
q : MvPolynomial { x // x ∈ s } R
n : ℕ := Fintype.card { x // x ∈ s }
⊢ ∃ n f _hf q_1, ↑(rename Subtype.val) q = ↑(rename f) q_1

tactic: refine' ⟨n, (↑) ∘ e.symm, Subtype.val_injective.comp e.symm.injective, rename e q, _⟩
state_before: case intro.intro
σ : Type u_1
τ : Type ?u.859965
α : Type ?u.859968
R : Type u_2
S : Type ?u.859974
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Finset σ
q : MvPolynomial { x // x ∈ s } R
n : ℕ := Fintype.card { x // x ∈ s }
e : { x // x ∈ s } ≃ Fin (Fintype.card { x // x ∈ s }) := Fintype.equivFin { x // x ∈ s }
⊢ ∃ n f _hf q_1, ↑(rename Subtype.val) q = ↑(rename f) q_1

tactic: rw [← rename_rename, rename_rename e]
state_before: case intro.intro
σ : Type u_1
τ : Type ?u.859965
α : Type ?u.859968
R : Type u_2
S : Type ?u.859974
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Finset σ
q : MvPolynomial { x // x ∈ s } R
n : ℕ := Fintype.card { x // x ∈ s }
e : { x // x ∈ s } ≃ Fin (Fintype.card { x // x ∈ s }) := Fintype.equivFin { x // x ∈ s }
⊢ ↑(rename Subtype.val) q = ↑(rename (Subtype.val ∘ ↑e.symm)) (↑(rename ↑e) q)

tactic: simp only [Function.comp, Equiv.symm_apply_apply, rename_rename]
state_before: case intro.intro
σ : Type u_1
τ : Type ?u.859965
α : Type ?u.859968
R : Type u_2
S : Type ?u.859974
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Finset σ
q : MvPolynomial { x // x ∈ s } R
n : ℕ := Fintype.card { x // x ∈ s }
e : { x // x ∈ s } ≃ Fin (Fintype.card { x // x ∈ s }) := Fintype.equivFin { x // x ∈ s }
⊢ ↑(rename Subtype.val) q = ↑(rename Subtype.val) (↑(rename (↑e.symm ∘ ↑e)) q)
Theorem: ContinuousLinearEquiv.comp_contDiff_iff
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp only [← contDiffOn_univ, e.comp_contDiffOn_iff]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.315358
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
e : F ≃L[𝕜] G
⊢ ContDiff 𝕜 n (↑e ∘ f) ↔ ContDiff 𝕜 n f
Theorem: Language.one_add_self_mul_kstar_eq_kstar
File: Mathlib/Computability/Language.lean

tactic: simp only [kstar_eq_iSup_pow, mul_iSup, ← pow_succ, ← pow_zero l]
state_before: α : Type u_1
β : Type ?u.122274
γ : Type ?u.122277
l✝ m : Language α
a b x : List α
l : Language α
⊢ 1 + l * l∗ = l∗

tactic: exact sup_iSup_nat_succ _
state_before: α : Type u_1
β : Type ?u.122274
γ : Type ?u.122277
l✝ m : Language α
a b x : List α
l : Language α
⊢ (l ^ 0 + ⨆ (i : ℕ), l ^ (i + 1)) = ⨆ (i : ℕ), l ^ i
Theorem: Set.toFinset_subset
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← Finset.coe_subset, coe_toFinset]
state_before: α : Type u_1
β : Type ?u.85647
γ : Type ?u.85650
s t✝ : Set α
inst✝ : Fintype ↑s
t : Finset α
⊢ toFinset s ⊆ t ↔ s ⊆ ↑t
Theorem: MeasureTheory.ofReal_integral_norm_eq_lintegral_nnnorm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [integral_norm_eq_lintegral_nnnorm hf.aestronglyMeasurable,
  ENNReal.ofReal_toReal (lt_top_iff_ne_top.mp hf.2)]
state_before: α : Type u_2
E : Type ?u.1053184
F : Type ?u.1053187
𝕜 : Type ?u.1053190
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.1055881
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
G : Type u_1
inst✝ : NormedAddCommGroup G
f : α → G
hf : Integrable f
⊢ ENNReal.ofReal (∫ (x : α), ‖f x‖ ∂μ) = ∫⁻ (x : α), ↑‖f x‖₊ ∂μ
Theorem: zero_div
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [div_eq_mul_inv, zero_mul]
state_before: α : Type ?u.23516
M₀ : Type ?u.23519
G₀ : Type u_1
M₀' : Type ?u.23525
G₀' : Type ?u.23528
F : Type ?u.23531
F' : Type ?u.23534
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ 0 / a = 0
Theorem: Polynomial.degree_update_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [degree, support_update]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.562120
p : R[X]
n : ℕ
a : R
⊢ degree (update p n a) ≤ max (degree p) ↑n

tactic: split_ifs
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.562120
p : R[X]
n : ℕ
a : R
⊢ Finset.max (if a = 0 then Finset.erase (support p) n else insert n (support p)) ≤ max (degree p) ↑n

tactic: exact (Finset.max_mono (erase_subset _ _)).trans (le_max_left _ _)
state_before: case inl
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.562120
p : R[X]
n : ℕ
a : R
h✝ : a = 0
⊢ Finset.max (Finset.erase (support p) n) ≤ max (degree p) ↑n

tactic: rw [max_insert, max_comm]
state_before: case inr
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.562120
p : R[X]
n : ℕ
a : R
h✝ : ¬a = 0
⊢ Finset.max (insert n (support p)) ≤ max (degree p) ↑n

tactic: exact le_rfl
state_before: case inr
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.562120
p : R[X]
n : ℕ
a : R
h✝ : ¬a = 0
⊢ max (Finset.max (support p)) ↑n ≤ max (degree p) ↑n
Theorem: Set.image_mul_right_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: cases eq_or_lt_of_le hc
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
hab : a ≤ b
hc : 0 ≤ c
⊢ (fun x => x * c) '' Icc a b = Icc (a * c) (b * c)

tactic: exact image_mul_right_Icc' a b ‹0 < c›
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
hab : a ≤ b
hc : 0 ≤ c
h✝ : 0 < c
⊢ (fun x => x * c) '' Icc a b = Icc (a * c) (b * c)

tactic: subst c
state_before: case inl
α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
hab : a ≤ b
hc : 0 ≤ c
h✝ : 0 = c
⊢ (fun x => x * c) '' Icc a b = Icc (a * c) (b * c)

tactic: simp [(nonempty_Icc.2 hab).image_const]
state_before: case inl
α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b : α
hab : a ≤ b
hc : 0 ≤ 0
⊢ (fun x => x * 0) '' Icc a b = Icc (a * 0) (b * 0)
Theorem: AddCircle.liftIco_coe_apply
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: have : (equivIco p a) x = ⟨x, hx⟩ := by
  rw [Equiv.apply_eq_iff_eq_symm_apply]
  rfl
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ico a (a + p)
⊢ liftIco p a f ↑x = f x

tactic: rw [liftIco, comp_apply, this]
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ico a (a + p)
this : ↑(equivIco p a) ↑x = { val := x, property := hx }
⊢ liftIco p a f ↑x = f x

tactic: rfl
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ico a (a + p)
this : ↑(equivIco p a) ↑x = { val := x, property := hx }
⊢ restrict (Ico a (a + p)) f { val := x, property := hx } = f x

tactic: rw [Equiv.apply_eq_iff_eq_symm_apply]
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ico a (a + p)
⊢ ↑(equivIco p a) ↑x = { val := x, property := hx }

tactic: rfl
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ico a (a + p)
⊢ ↑x = ↑(equivIco p a).symm { val := x, property := hx }
Theorem: List.bind_map
File: Std/Data/List/Lemmas.lean

tactic: simp only [cons_bind, map_append, bind_map _ _ l]
state_before: β : Type u_1
γ : Type u_2
α : Type u_3
f : β → γ
g : α → List β
a : α
l : List α
⊢ map f (List.bind (a :: l) g) = List.bind (a :: l) fun a => map f (g a)
Theorem: Finset.Nonempty.div_zero
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simpa [mem_div] using hs
state_before: F : Type ?u.663683
α : Type u_1
β : Type ?u.663689
γ : Type ?u.663692
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : GroupWithZero α
s t : Finset α
hs : Finset.Nonempty s
⊢ 0 ⊆ s / 0
Theorem: Sym.erase_mk
File: Mathlib/Data/Sym/Basic.lean

tactic: rw [Multiset.card_erase_of_mem h, hc]
state_before: α : Type ?u.16480
β : Type ?u.16483
n n' m✝ : ℕ
s : Sym α n
a✝ b : α
inst✝ : DecidableEq α
m : Multiset α
hc : ↑Multiset.card m = n + 1
a : α
h : a ∈ m
⊢ ↑Multiset.card (Multiset.erase m a) = n

tactic: rfl
state_before: α : Type ?u.16480
β : Type ?u.16483
n n' m✝ : ℕ
s : Sym α n
a✝ b : α
inst✝ : DecidableEq α
m : Multiset α
hc : ↑Multiset.card m = n + 1
a : α
h : a ∈ m
⊢ Nat.pred (n + 1) = n
Theorem: Ultrafilter.le_sup_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: simp only [← disjoint_iff_not_le, not_or, disjoint_sup_right]
state_before: α : Type u
β : Type v
γ : Type ?u.10908
f✝ g✝ : Ultrafilter α
s t : Set α
p q : α → Prop
u : Ultrafilter α
f g : Filter α
⊢ ¬↑u ≤ f ⊔ g ↔ ¬(↑u ≤ f ∨ ↑u ≤ g)
Theorem: Polynomial.eval₂_mul_C'
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eval₂_mul_noncomm, eval₂_C]
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
inst✝ : Semiring T
h : Commute (↑f a) x
⊢ eval₂ f x (p * ↑C a) = eval₂ f x p * ↑f a

tactic: intro k
state_before: case hf
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
inst✝ : Semiring T
h : Commute (↑f a) x
⊢ ∀ (k : ℕ), Commute (↑f (coeff (↑C a) k)) x

tactic: by_cases hk : k = 0
state_before: case hf
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
inst✝ : Semiring T
h : Commute (↑f a) x
k : ℕ
⊢ Commute (↑f (coeff (↑C a) k)) x

tactic: simp only [hk, h, coeff_C_zero, coeff_C_ne_zero]
state_before: case pos
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
inst✝ : Semiring T
h : Commute (↑f a) x
k : ℕ
hk : k = 0
⊢ Commute (↑f (coeff (↑C a) k)) x

tactic: simp only [coeff_C_ne_zero hk, RingHom.map_zero, Commute.zero_left]
state_before: case neg
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
inst✝ : Semiring T
h : Commute (↑f a) x
k : ℕ
hk : ¬k = 0
⊢ Commute (↑f (coeff (↑C a) k)) x
Theorem: Set.PartiallyWellOrderedOn.prod
File: Mathlib/Order/WellFoundedSet.lean

tactic: intro f hf
state_before: ι : Type ?u.91578
α : Type u_2
β : Type u_1
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t✝ : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
t : Set β
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r'
⊢ PartiallyWellOrderedOn (s ×ˢ t) fun x y => r x.fst y.fst ∧ r' x.snd y.snd

tactic: obtain ⟨g₁, h₁⟩ := hs.exists_monotone_subseq (Prod.fst ∘ f) fun n => (hf n).1
state_before: ι : Type ?u.91578
α : Type u_2
β : Type u_1
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t✝ : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
t : Set β
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r'
f : ℕ → α × β
hf : ∀ (n : ℕ), f n ∈ s ×ˢ t
⊢ ∃ m n, m < n ∧ (fun x y => r x.fst y.fst ∧ r' x.snd y.snd) (f m) (f n)

tactic: obtain ⟨m, n, hlt, hle⟩ := ht (Prod.snd ∘ f ∘ g₁) fun n => (hf _).2
state_before: case intro
ι : Type ?u.91578
α : Type u_2
β : Type u_1
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t✝ : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
t : Set β
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r'
f : ℕ → α × β
hf : ∀ (n : ℕ), f n ∈ s ×ˢ t
g₁ : ℕ ↪o ℕ
h₁ : ∀ (m n : ℕ), m ≤ n → r ((Prod.fst ∘ f) (↑g₁ m)) ((Prod.fst ∘ f) (↑g₁ n))
⊢ ∃ m n, m < n ∧ (fun x y => r x.fst y.fst ∧ r' x.snd y.snd) (f m) (f n)

tactic: exact ⟨g₁ m, g₁ n, g₁.strictMono hlt, h₁ _ _ hlt.le, hle⟩
state_before: case intro.intro.intro.intro
ι : Type ?u.91578
α : Type u_2
β : Type u_1
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t✝ : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
t : Set β
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r'
f : ℕ → α × β
hf : ∀ (n : ℕ), f n ∈ s ×ˢ t
g₁ : ℕ ↪o ℕ
h₁ : ∀ (m n : ℕ), m ≤ n → r ((Prod.fst ∘ f) (↑g₁ m)) ((Prod.fst ∘ f) (↑g₁ n))
m n : ℕ
hlt : m < n
hle : r' ((Prod.snd ∘ f ∘ ↑g₁) m) ((Prod.snd ∘ f ∘ ↑g₁) n)
⊢ ∃ m n, m < n ∧ (fun x y => r x.fst y.fst ∧ r' x.snd y.snd) (f m) (f n)
Theorem: Finsupp.sum_ite_self_eq_aux
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: simp only [mem_support_iff, ne_eq, ite_eq_left_iff, not_not]
state_before: α : Type u_1
ι : Type ?u.64782
γ : Type ?u.64785
A : Type ?u.64788
B : Type ?u.64791
C : Type ?u.64794
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.67924
M : Type ?u.67927
M' : Type ?u.67930
N✝ : Type ?u.67933
P : Type ?u.67936
G : Type ?u.67939
H : Type ?u.67942
R : Type ?u.67945
S : Type ?u.67948
inst✝⁴ : Zero M
inst✝³ : Zero M'
inst✝² : CommMonoid N✝
inst✝¹ : DecidableEq α
N : Type u_2
inst✝ : AddCommMonoid N
f : α →₀ N
a : α
⊢ (if a ∈ f.support then ↑f a else 0) = ↑f a

tactic: exact fun h ↦ h.symm
state_before: α : Type u_1
ι : Type ?u.64782
γ : Type ?u.64785
A : Type ?u.64788
B : Type ?u.64791
C : Type ?u.64794
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.67924
M : Type ?u.67927
M' : Type ?u.67930
N✝ : Type ?u.67933
P : Type ?u.67936
G : Type ?u.67939
H : Type ?u.67942
R : Type ?u.67945
S : Type ?u.67948
inst✝⁴ : Zero M
inst✝³ : Zero M'
inst✝² : CommMonoid N✝
inst✝¹ : DecidableEq α
N : Type u_2
inst✝ : AddCommMonoid N
f : α →₀ N
a : α
⊢ ↑f a = 0 → 0 = ↑f a
Theorem: Multiset.prod_map_add
File: Mathlib/Data/Multiset/Antidiagonal.lean

tactic: refine' s.induction_on _ _
state_before: α : Type u_2
β : Type u_1
inst✝ : CommSemiring β
s : Multiset α
f g : α → β
⊢ prod (map (fun a => f a + g a) s) = sum (map (fun p => prod (map f p.fst) * prod (map g p.snd)) (antidiagonal s))

tactic: simp only [map_zero, prod_zero, antidiagonal_zero, map_singleton, mul_one, sum_singleton]
state_before: case refine'_1
α : Type u_2
β : Type u_1
inst✝ : CommSemiring β
s : Multiset α
f g : α → β
⊢ prod (map (fun a => f a + g a) 0) = sum (map (fun p => prod (map f p.fst) * prod (map g p.snd)) (antidiagonal 0))

tactic: intro a s ih
state_before: case refine'_2
α : Type u_2
β : Type u_1
inst✝ : CommSemiring β
s : Multiset α
f g : α → β
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    prod (map (fun a => f a + g a) s) = sum (map (fun p => prod (map f p.fst) * prod (map g p.snd)) (antidiagonal s)) →
      prod (map (fun a => f a + g a) (a ::ₘ s)) =
        sum (map (fun p => prod (map f p.fst) * prod (map g p.snd)) (antidiagonal (a ::ₘ s)))

tactic: simp only [map_cons, prod_cons, ih, sum_map_mul_left.symm, add_mul, mul_left_comm (f a),
  mul_left_comm (g a), sum_map_add, antidiagonal_cons, Prod_map, id_eq, map_add, map_map,
  Function.comp_apply, mul_assoc, sum_add]
state_before: case refine'_2
α : Type u_2
β : Type u_1
inst✝ : CommSemiring β
s✝ : Multiset α
f g : α → β
a : α
s : Multiset α
ih : prod (map (fun a => f a + g a) s) = sum (map (fun p => prod (map f p.fst) * prod (map g p.snd)) (antidiagonal s))
⊢ prod (map (fun a => f a + g a) (a ::ₘ s)) =
    sum (map (fun p => prod (map f p.fst) * prod (map g p.snd)) (antidiagonal (a ::ₘ s)))

tactic: exact add_comm _ _
state_before: case refine'_2
α : Type u_2
β : Type u_1
inst✝ : CommSemiring β
s✝ : Multiset α
f g : α → β
a : α
s : Multiset α
ih : prod (map (fun a => f a + g a) s) = sum (map (fun p => prod (map f p.fst) * prod (map g p.snd)) (antidiagonal s))
⊢ sum (map (fun i => prod (map f i.fst) * (f a * prod (map g i.snd))) (antidiagonal s)) +
      sum (map (fun i => prod (map f i.fst) * (g a * prod (map g i.snd))) (antidiagonal s)) =
    sum (map (fun x => prod (map f x.fst) * (g a * prod (map g x.snd))) (antidiagonal s)) +
      sum (map (fun i => prod (map f i.fst) * (f a * prod (map g i.snd))) (antidiagonal s))
Theorem: Computable.ofOption
File: Mathlib/Computability/Partrec.lean

tactic: cases' decode (α := α) n with a <;> simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.37095
σ : Type ?u.37098
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
hf : Computable f
n : ℕ
⊢ (do
      let n ← Part.bind ↑(decode n) fun a => map encode (↑f a)
      ↑(Nat.ppred n)) =
    Part.bind ↑(decode n) fun a => map encode ((fun a => ↑(f a)) a)

tactic: cases' f a with b <;> simp
state_before: case some
α : Type u_2
β : Type u_1
γ : Type ?u.37095
σ : Type ?u.37098
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
hf : Computable f
n : ℕ
a : α
⊢ ↑(Nat.ppred (encode (f a))) = map encode ↑(f a)
Theorem: Real.continuousAt_rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: change ContinuousAt ((fun p : ℝ × ℝ => p.1 ^ p.2) ∘ fun y : ℝ => (y, q)) x
state_before: x q : ℝ
h : x ≠ 0 ∨ 0 < q
⊢ ContinuousAt (fun x => x ^ q) x

tactic: apply ContinuousAt.comp
state_before: x q : ℝ
h : x ≠ 0 ∨ 0 < q
⊢ ContinuousAt ((fun p => p.fst ^ p.snd) ∘ fun y => (y, q)) x

tactic: exact continuousAt_rpow (x, q) h
state_before: case hg
x q : ℝ
h : x ≠ 0 ∨ 0 < q
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (x, q)

tactic: exact (continuous_id'.prod_mk continuous_const).continuousAt
state_before: case hf
x q : ℝ
h : x ≠ 0 ∨ 0 < q
⊢ ContinuousAt (fun y => (y, q)) x
Theorem: Array.back_eq_back?
File: Std/Data/Array/Lemmas.lean

tactic: simp [back, back?]
state_before: α : Type u_1
inst✝ : Inhabited α
a : Array α
⊢ back a = Option.getD (back? a) default
Theorem: Filter.Tendsto.atTop_mul_neg
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: have := hf.atTop_mul (neg_pos.2 hC) hg.neg
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : C < 0
hf : Tendsto f l atTop
hg : Tendsto g l (𝓝 C)
⊢ Tendsto (fun x => f x * g x) l atBot
Theorem: Real.expNear_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [expNear]
state_before: x r : ℝ
⊢ expNear 0 x r = r
Theorem: NormedAddGroupHom.antilipschitz_of_norm_ge
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: simpa only [dist_eq_norm, map_sub] using h (x - y)
state_before: V : Type ?u.211727
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.211736
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
K : ℝ≥0
h : ∀ (x : V₁), ‖x‖ ≤ ↑K * ‖↑f x‖
x y : V₁
⊢ dist x y ≤ ↑K * dist (↑f x) (↑f y)
Theorem: Filter.HasBasis.inf_principal
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [mem_inf_principal, hl.mem_iff, subset_def, mem_setOf_eq, mem_inter_iff, and_imp]
state_before: α : Type u_1
β : Type ?u.43930
γ : Type ?u.43933
ι : Sort u_2
ι' : Sort ?u.43939
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s'✝ : ι' → Set α
i' : ι'
hl : HasBasis l p s
s' t : Set α
⊢ t ∈ l ⊓ 𝓟 s' ↔ ∃ i, p i ∧ s i ∩ s' ⊆ t
Theorem: List.rotate_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_rotate', rotate_eq_rotate', rotate_eq_rotate', rotate'_rotate']
state_before: α : Type u
l : List α
n m : ℕ
⊢ rotate (rotate l n) m = rotate l (n + m)
Theorem: Filter.lift'_pure
File: Mathlib/Order/Filter/Lift.lean

tactic: rw [← principal_singleton, lift'_principal hh]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.36150
ι : Sort ?u.36153
f f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
a : α
hh : Monotone h
⊢ Filter.lift' (pure a) h = 𝓟 (h {a})
Theorem: mem_omegaLimit_singleton_iff_map_cluster_point
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: simp_rw [mem_omegaLimit_iff_frequently, mapClusterPt_iff, singleton_inter_nonempty, mem_preimage]
state_before: τ : Type u_2
α : Type u_3
β : Type u_1
ι : Type ?u.31315
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
x : α
y : β
⊢ y ∈ ω f ϕ {x} ↔ MapClusterPt y f fun t => ϕ t x
Theorem: Set.pairwise_insert_of_symmetric_of_not_mem
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp only [pairwise_insert_of_not_mem ha, hr.iff a, and_self_iff]
state_before: α : Type u_1
β : Type ?u.11936
γ : Type ?u.11939
ι : Type ?u.11942
ι' : Type ?u.11945
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
hr : Symmetric r
ha : ¬a ∈ s
⊢ Set.Pairwise (insert a s) r ↔ Set.Pairwise s r ∧ ∀ (b : α), b ∈ s → r a b
Theorem: embedding_sigma_map
File: Mathlib/Topology/Constructions.lean

tactic: simp only [embedding_iff, Injective.sigma_map, inducing_sigma_map h, forall_and, h.sigma_map_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.534439
δ : Type ?u.534442
ε : Type ?u.534445
ζ : Type ?u.534448
ι : Type u_1
κ : Type u_2
σ : ι → Type u_3
τ : κ → Type u_4
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
f₁ : ι → κ
f₂ : (i : ι) → σ i → τ (f₁ i)
h : Injective f₁
⊢ _root_.Embedding (Sigma.map f₁ f₂) ↔ ∀ (i : ι), _root_.Embedding (f₂ i)
Theorem: Fin.cycleRange_last
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: ext i
state_before: n : ℕ
⊢ cycleRange (last n) = finRotate (n + 1)

tactic: rw [coe_cycleRange_of_le (le_last _), coe_finRotate]
state_before: case H.h
n : ℕ
i : Fin (n + 1)
⊢ ↑(↑(cycleRange (last n)) i) = ↑(↑(finRotate (n + 1)) i)
Theorem: SimpleGraph.Walk.tail_support_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [support_append, List.tail_append_of_ne_nil _ _ (support_ne_nil _)]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
p' : Walk G v w
⊢ List.tail (support (append p p')) = List.tail (support p) ++ List.tail (support p')
Theorem: CategoryTheory.MorphismProperty.isomorphisms.iff
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: rfl
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.59249
inst✝ : Category D
X Y : C
f : X ⟶ Y
⊢ isomorphisms C f ↔ IsIso f
Theorem: PicardLindelof.proj_of_mem
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: simp only [proj, projIcc_of_mem v.tMin_le_tMax ht]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ℝ
ht : t ∈ Icc v.tMin v.tMax
⊢ ↑(proj v t) = t