tasksource/leandojo huggingface dataset:
Theorem: Dfinsupp.support_neg
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddGroup (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
⊢ support (-f) = support f

tactic: simp
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddGroup (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
⊢ i ∈ support (-f) ↔ i ∈ support f
Theorem: Set.swap_mem_mulAntidiagonal
File: Mathlib/Data/Set/MulAntidiagonal.lean

tactic: simp [mul_comm, and_left_comm]
state_before: α : Type u_1
inst✝ : CommSemigroup α
s t : Set α
a : α
x : α × α
⊢ Prod.swap x ∈ mulAntidiagonal s t a ↔ x ∈ mulAntidiagonal t s a
Theorem: Set.univ_pi_eq_iInter
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [pi_def, iInter_true, mem_univ]
state_before: α : Type u_2
β : Type ?u.286650
γ : Type ?u.286653
ι : Sort ?u.286656
ι' : Sort ?u.286659
ι₂ : Sort ?u.286662
κ : ι → Sort ?u.286667
κ₁ : ι → Sort ?u.286672
κ₂ : ι → Sort ?u.286677
κ' : ι' → Sort ?u.286682
π : α → Type u_1
t : (i : α) → Set (π i)
⊢ pi univ t = ⋂ (i : α), eval i ⁻¹' t i
Theorem: intervalIntegral.integral_comp_mul_deriv'''
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: have hg2' : IntegrableOn (fun x => f' x • (g ∘ f) x) [[a, b]] := by simpa [mul_comm] using hg2
state_before: ι : Type ?u.1930290
𝕜 : Type ?u.1930293
E : Type ?u.1930296
F : Type ?u.1930299
A : Type ?u.1930302
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝¹ : ℝ → E
g' g✝ φ : ℝ → ℝ
f✝ f'✝ : ℝ → E
a b : ℝ
f f' g : ℝ → ℝ
hf : ContinuousOn f [[a, b]]
hff' : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivWithinAt f (f' x) (Ioi x) x
hg_cont : ContinuousOn g (f '' Ioo (min a b) (max a b))
hg1 : IntegrableOn g (f '' [[a, b]])
hg2 : IntegrableOn (fun x => (g ∘ f) x * f' x) [[a, b]]
⊢ (∫ (x : ℝ) in a..b, (g ∘ f) x * f' x) = ∫ (u : ℝ) in f a..f b, g u

tactic: simpa [mul_comm] using integral_comp_smul_deriv''' hf hff' hg_cont hg1 hg2'
state_before: ι : Type ?u.1930290
𝕜 : Type ?u.1930293
E : Type ?u.1930296
F : Type ?u.1930299
A : Type ?u.1930302
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝¹ : ℝ → E
g' g✝ φ : ℝ → ℝ
f✝ f'✝ : ℝ → E
a b : ℝ
f f' g : ℝ → ℝ
hf : ContinuousOn f [[a, b]]
hff' : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivWithinAt f (f' x) (Ioi x) x
hg_cont : ContinuousOn g (f '' Ioo (min a b) (max a b))
hg1 : IntegrableOn g (f '' [[a, b]])
hg2 : IntegrableOn (fun x => (g ∘ f) x * f' x) [[a, b]]
hg2' : IntegrableOn (fun x => f' x • (g ∘ f) x) [[a, b]]
⊢ (∫ (x : ℝ) in a..b, (g ∘ f) x * f' x) = ∫ (u : ℝ) in f a..f b, g u

tactic: simpa [mul_comm] using hg2
state_before: ι : Type ?u.1930290
𝕜 : Type ?u.1930293
E : Type ?u.1930296
F : Type ?u.1930299
A : Type ?u.1930302
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝¹ : ℝ → E
g' g✝ φ : ℝ → ℝ
f✝ f'✝ : ℝ → E
a b : ℝ
f f' g : ℝ → ℝ
hf : ContinuousOn f [[a, b]]
hff' : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivWithinAt f (f' x) (Ioi x) x
hg_cont : ContinuousOn g (f '' Ioo (min a b) (max a b))
hg1 : IntegrableOn g (f '' [[a, b]])
hg2 : IntegrableOn (fun x => (g ∘ f) x * f' x) [[a, b]]
⊢ IntegrableOn (fun x => f' x • (g ∘ f) x) [[a, b]]
Theorem: Complex.isPrimitiveRoot_iff
File: Mathlib/RingTheory/RootsOfUnity/Complex.lean

tactic: have hn0 : (n : ℂ) ≠ 0 := by exact_mod_cast hn
state_before: ζ : ℂ
n : ℕ
hn : n ≠ 0
⊢ IsPrimitiveRoot ζ n ↔ ∃ i, i < n ∧ ∃ x, exp (2 * ↑π * I * (↑i / ↑n)) = ζ

tactic: constructor
state_before: ζ : ℂ
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ IsPrimitiveRoot ζ n ↔ ∃ i, i < n ∧ ∃ x, exp (2 * ↑π * I * (↑i / ↑n)) = ζ

tactic: swap
state_before: case mp
ζ : ℂ
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ IsPrimitiveRoot ζ n → ∃ i, i < n ∧ ∃ x, exp (2 * ↑π * I * (↑i / ↑n)) = ζ

case mpr
ζ : ℂ
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ (∃ i, i < n ∧ ∃ x, exp (2 * ↑π * I * (↑i / ↑n)) = ζ) → IsPrimitiveRoot ζ n

tactic: intro h
state_before: case mp
ζ : ℂ
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ IsPrimitiveRoot ζ n → ∃ i, i < n ∧ ∃ x, exp (2 * ↑π * I * (↑i / ↑n)) = ζ

tactic: obtain ⟨i, hi, rfl⟩ :=
  (isPrimitiveRoot_exp n hn).eq_pow_of_pow_eq_one h.pow_eq_one (Nat.pos_of_ne_zero hn)
state_before: case mp
ζ : ℂ
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
h : IsPrimitiveRoot ζ n
⊢ ∃ i, i < n ∧ ∃ x, exp (2 * ↑π * I * (↑i / ↑n)) = ζ

tactic: refine' ⟨i, hi, ((isPrimitiveRoot_exp n hn).pow_iff_coprime (Nat.pos_of_ne_zero hn) i).mp h, _⟩
state_before: case mp.intro.intro
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
i : ℕ
hi : i < n
h : IsPrimitiveRoot (exp (2 * ↑π * I / ↑n) ^ i) n
⊢ ∃ i_1, i_1 < n ∧ ∃ x, exp (2 * ↑π * I * (↑i_1 / ↑n)) = exp (2 * ↑π * I / ↑n) ^ i

tactic: rw [← exp_nat_mul]
state_before: case mp.intro.intro
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
i : ℕ
hi : i < n
h : IsPrimitiveRoot (exp (2 * ↑π * I / ↑n) ^ i) n
⊢ exp (2 * ↑π * I * (↑i / ↑n)) = exp (2 * ↑π * I / ↑n) ^ i

tactic: congr 1
state_before: case mp.intro.intro
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
i : ℕ
hi : i < n
h : IsPrimitiveRoot (exp (2 * ↑π * I / ↑n) ^ i) n
⊢ exp (2 * ↑π * I * (↑i / ↑n)) = exp (↑i * (2 * ↑π * I / ↑n))

tactic: field_simp [hn0, mul_comm (i : ℂ)]
state_before: case mp.intro.intro.e_z
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
i : ℕ
hi : i < n
h : IsPrimitiveRoot (exp (2 * ↑π * I / ↑n) ^ i) n
⊢ 2 * ↑π * I * (↑i / ↑n) = ↑i * (2 * ↑π * I / ↑n)

tactic: exact_mod_cast hn
state_before: ζ : ℂ
n : ℕ
hn : n ≠ 0
⊢ ↑n ≠ 0

tactic: rintro ⟨i, -, hi, rfl⟩
state_before: case mpr
ζ : ℂ
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ (∃ i, i < n ∧ ∃ x, exp (2 * ↑π * I * (↑i / ↑n)) = ζ) → IsPrimitiveRoot ζ n

tactic: exact isPrimitiveRoot_exp_of_coprime i n hn hi
state_before: case mpr.intro.intro.intro
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
i : ℕ
hi : Nat.coprime i n
⊢ IsPrimitiveRoot (exp (2 * ↑π * I * (↑i / ↑n))) n
Theorem: neg_div_neg_eq
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [div_neg_eq_neg_div, neg_div, neg_neg]
state_before: α : Type ?u.33103
β : Type ?u.33106
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ -a / -b = a / b
Theorem: Membership.mem.lower
File: src/lean/Init/Data/Range.lean

tactic: simp [Membership.mem] at h
state_before: i : Nat
r : Std.Range
h : i ∈ r
⊢ r.start ≤ i

tactic: exact h.1
state_before: i : Nat
r : Std.Range
h : r.start ≤ i ∧ i < r.stop
⊢ r.start ≤ i
Theorem: NormedSpace.isClosed_polar
File: Mathlib/Analysis/NormedSpace/Dual.lean

tactic: dsimp only [NormedSpace.polar]
state_before: 𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ IsClosed (polar 𝕜 s)

tactic: simp only [LinearMap.polar_eq_iInter, LinearMap.flip_apply]
state_before: 𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ IsClosed (LinearMap.polar (LinearMap.flip (dualPairing 𝕜 E)) s)

tactic: refine' isClosed_biInter fun z _ => _
state_before: 𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ IsClosed (⋂ (x : E) (_ : x ∈ s), {y | ‖↑(↑(dualPairing 𝕜 E) y) x‖ ≤ 1})

tactic: exact isClosed_Iic.preimage (ContinuousLinearMap.apply 𝕜 𝕜 z).continuous.norm
state_before: 𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
z : E
x✝ : z ∈ s
⊢ IsClosed {y | ‖↑(↑(dualPairing 𝕜 E) y) z‖ ≤ 1}
Theorem: Set.LeftInvOn.image_inter
File: Mathlib/Data/Set/Function.lean

tactic: rw [hf.image_inter']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59565
ι : Sort ?u.59568
π : α → Type ?u.59573
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
⊢ f '' (s₁ ∩ s) = f' ⁻¹' (s₁ ∩ s) ∩ f '' s

tactic: refine' Subset.antisymm _ (inter_subset_inter_left _ (preimage_mono <| inter_subset_left _ _))
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59565
ι : Sort ?u.59568
π : α → Type ?u.59573
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
⊢ f' ⁻¹' s₁ ∩ f '' s = f' ⁻¹' (s₁ ∩ s) ∩ f '' s

tactic: rintro _ ⟨h₁, x, hx, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59565
ι : Sort ?u.59568
π : α → Type ?u.59573
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
⊢ f' ⁻¹' s₁ ∩ f '' s ⊆ f' ⁻¹' (s₁ ∩ s) ∩ f '' s

tactic: exact ⟨⟨h₁, by rwa [hf hx]⟩, mem_image_of_mem _ hx⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.59565
ι : Sort ?u.59568
π : α → Type ?u.59573
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
x : α
hx : x ∈ s
h₁ : f x ∈ f' ⁻¹' s₁
⊢ f x ∈ f' ⁻¹' (s₁ ∩ s) ∩ f '' s

tactic: rwa [hf hx]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59565
ι : Sort ?u.59568
π : α → Type ?u.59573
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
x : α
hx : x ∈ s
h₁ : f x ∈ f' ⁻¹' s₁
⊢ f' (f x) ∈ s
Theorem: Submodule.span_insert_zero
File: Mathlib/LinearAlgebra/Span.lean

tactic: refine' le_antisymm _ (Submodule.span_mono (Set.subset_insert 0 s))
state_before: R : Type u_2
R₂ : Type ?u.12510
K : Type ?u.12513
M : Type u_1
M₂ : Type ?u.12519
V : Type ?u.12522
S : Type ?u.12525
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
⊢ span R (insert 0 s) = span R s

tactic: rw [span_le, Set.insert_subset]
state_before: R : Type u_2
R₂ : Type ?u.12510
K : Type ?u.12513
M : Type u_1
M₂ : Type ?u.12519
V : Type ?u.12522
S : Type ?u.12525
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
⊢ span R (insert 0 s) ≤ span R s

tactic: exact ⟨by simp only [SetLike.mem_coe, Submodule.zero_mem], Submodule.subset_span⟩
state_before: R : Type u_2
R₂ : Type ?u.12510
K : Type ?u.12513
M : Type u_1
M₂ : Type ?u.12519
V : Type ?u.12522
S : Type ?u.12525
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
⊢ 0 ∈ ↑(span R s) ∧ s ⊆ ↑(span R s)

tactic: simp only [SetLike.mem_coe, Submodule.zero_mem]
state_before: R : Type u_2
R₂ : Type ?u.12510
K : Type ?u.12513
M : Type u_1
M₂ : Type ?u.12519
V : Type ?u.12522
S : Type ?u.12525
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
⊢ 0 ∈ ↑(span R s)
Theorem: List.rel_nodup
File: Mathlib/Data/List/Nodup.lean

tactic: simp only [nodup_nil]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
r : α → β → Prop
hr : Relator.BiUnique r
⊢ (fun x x_1 => x ↔ x_1) (Nodup []) (Nodup [])

tactic: simpa only [nodup_cons] using
  Relator.rel_and (Relator.rel_not (rel_mem hr hab h)) (rel_nodup hr h)
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
r : α → β → Prop
hr : Relator.BiUnique r
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
hab : r a✝ b✝
h : Forall₂ r l₁✝ l₂✝
⊢ (fun x x_1 => x ↔ x_1) (Nodup (a✝ :: l₁✝)) (Nodup (b✝ :: l₂✝))
Theorem: isOpenMap_sum
File: Mathlib/Topology/Constructions.lean

tactic: simp only [isOpenMap_iff_nhds_le, Sum.forall, nhds_inl, nhds_inr, Filter.map_map, comp]
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type ?u.143123
ε : Type ?u.143126
ζ : Type ?u.143129
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α ⊕ β → γ
⊢ IsOpenMap f ↔ (IsOpenMap fun a => f (inl a)) ∧ IsOpenMap fun b => f (inr b)
Theorem: MeasureTheory.lintegral_biUnion_finset₀
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [← Finset.mem_coe, lintegral_biUnion₀ s.countable_toSet hm hd, ← Finset.tsum_subtype']
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1024019
δ : Type ?u.1024022
m : MeasurableSpace α
μ ν : Measure α
s : Finset β
t : β → Set α
hd : Set.Pairwise (↑s) (AEDisjoint μ on t)
hm : ∀ (b : β), b ∈ s → NullMeasurableSet (t b)
f : α → ℝ≥0∞
⊢ (∫⁻ (a : α) in ⋃ (b : β) (_ : b ∈ s), t b, f a ∂μ) = ∑ b in s, ∫⁻ (a : α) in t b, f a ∂μ
Theorem: tsum_mul_tsum_eq_tsum_sum_antidiagonal
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: conv_rhs => congr; ext; rw [← Finset.sum_finset_coe, ← tsum_fintype]
state_before: ι : Type ?u.30248
κ : Type ?u.30251
R : Type ?u.30254
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
hf : Summable f
hg : Summable g
hfg : Summable fun x => f x.fst * g x.snd
⊢ ((∑' (n : ℕ), f n) * ∑' (n : ℕ), g n) = ∑' (n : ℕ), ∑ kl in Nat.antidiagonal n, f kl.fst * g kl.snd

tactic: rw [tsum_mul_tsum hf hg hfg, ← Nat.sigmaAntidiagonalEquivProd.tsum_eq (_ : ℕ × ℕ → α)]
state_before: ι : Type ?u.30248
κ : Type ?u.30251
R : Type ?u.30254
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
hf : Summable f
hg : Summable g
hfg : Summable fun x => f x.fst * g x.snd
⊢ ((∑' (n : ℕ), f n) * ∑' (n : ℕ), g n) = ∑' (x : ℕ) (b : ↑↑(Nat.antidiagonal x)), f (↑b).fst * g (↑b).snd

tactic: exact
  tsum_sigma' (fun n => (hasSum_fintype _).summable)
    (summable_mul_prod_iff_summable_mul_sigma_antidiagonal.mp hfg)
state_before: ι : Type ?u.30248
κ : Type ?u.30251
R : Type ?u.30254
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
hf : Summable f
hg : Summable g
hfg : Summable fun x => f x.fst * g x.snd
⊢ (∑' (c : (n : ℕ) × { x // x ∈ Nat.antidiagonal n }),
      f (↑Nat.sigmaAntidiagonalEquivProd c).fst * g (↑Nat.sigmaAntidiagonalEquivProd c).snd) =
    ∑' (x : ℕ) (b : ↑↑(Nat.antidiagonal x)), f (↑b).fst * g (↑b).snd
Theorem: List.map_eq_replicate_iff
File: Mathlib/Data/List/Basic.lean

tactic: simp [eq_replicate]
state_before: ι : Type ?u.139891
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
f : α → β
b : β
⊢ map f l = replicate (length l) b ↔ ∀ (x : α), x ∈ l → f x = b
Theorem: Finset.mem_sym2_iff
File: Mathlib/Data/Finset/Sym.lean

tactic: refine
  mem_image.trans
    ⟨?_, fun h ↦ ⟨m.out, mem_product.2 ⟨h _ m.out_fst_mem, h _ m.out_snd_mem⟩, m.out_eq⟩⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ m ∈ Finset.sym2 s ↔ ∀ (a : α), a ∈ m → a ∈ s

tactic: rintro ⟨⟨a, b⟩, h, rfl⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ (∃ a, a ∈ s ×ˢ s ∧ Quotient.mk' a = m) → ∀ (a : α), a ∈ m → a ∈ s

tactic: rw [Quotient.mk', @Sym2.ball _ (fun x ↦ x ∈ s)]
state_before: case intro.mk.intro
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a✝ b✝ a b : α
h : (a, b) ∈ s ×ˢ s
⊢ ∀ (a_1 : α), a_1 ∈ Quotient.mk' (a, b) → a_1 ∈ s

tactic: rwa [mem_product] at h
state_before: case intro.mk.intro
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a✝ b✝ a b : α
h : (a, b) ∈ s ×ˢ s
⊢ a ∈ s ∧ b ∈ s
Theorem: MeasureTheory.IsFundamentalDomain.measure_zero_of_invariant
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: rw [measure_eq_tsum h]
state_before: G : Type u_1
H : Type ?u.244096
α : Type u_2
β : Type ?u.244102
E : Type ?u.244105
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s
t : Set α
ht : ∀ (g : G), g • t = t
hts : ↑↑μ (t ∩ s) = 0
⊢ ↑↑μ t = 0

tactic: simp [ht, hts]
state_before: G : Type u_1
H : Type ?u.244096
α : Type u_2
β : Type ?u.244102
E : Type ?u.244105
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s
t : Set α
ht : ∀ (g : G), g • t = t
hts : ↑↑μ (t ∩ s) = 0
⊢ (∑' (g : G), ↑↑μ (g • t ∩ s)) = 0
Theorem: Asymptotics.isBigOWith_of_le
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rw [one_mul]
state_before: α : Type u_3
β : Type ?u.95599
E : Type u_1
F : Type u_2
G : Type ?u.95608
E' : Type ?u.95611
F' : Type ?u.95614
G' : Type ?u.95617
E'' : Type ?u.95620
F'' : Type ?u.95623
G'' : Type ?u.95626
R : Type ?u.95629
R' : Type ?u.95632
𝕜 : Type ?u.95635
𝕜' : Type ?u.95638
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
hfg : ∀ (x : α), ‖f x‖ ≤ ‖g x‖
x : α
⊢ ‖f x‖ ≤ 1 * ‖g x‖

tactic: exact hfg x
state_before: α : Type u_3
β : Type ?u.95599
E : Type u_1
F : Type u_2
G : Type ?u.95608
E' : Type ?u.95611
F' : Type ?u.95614
G' : Type ?u.95617
E'' : Type ?u.95620
F'' : Type ?u.95623
G'' : Type ?u.95626
R : Type ?u.95629
R' : Type ?u.95632
𝕜 : Type ?u.95635
𝕜' : Type ?u.95638
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
hfg : ∀ (x : α), ‖f x‖ ≤ ‖g x‖
x : α
⊢ ‖f x‖ ≤ ‖g x‖
Theorem: Set.countable_pi
File: Mathlib/Data/Set/Countable.lean

tactic: simpa only [← mem_univ_pi] using countable_univ_pi hs
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
π : α → Type u_1
inst✝ : Finite α
s : (a : α) → Set (π a)
hs : ∀ (a : α), Set.Countable (s a)
⊢ Set.Countable {f | ∀ (a : α), f a ∈ s a}
Theorem: Multiset.sections_add
File: Mathlib/Data/Multiset/Sections.lean

tactic: simp
state_before: α : Type u_1
s t : Multiset (Multiset α)
⊢ Sections (0 + t) = bind (Sections 0) fun m => map ((fun x x_1 => x + x_1) m) (Sections t)

tactic: simp [ih, bind_assoc, map_bind, bind_map]
state_before: α : Type u_1
s✝ t : Multiset (Multiset α)
a : Multiset α
s : Multiset (Multiset α)
ih : Sections (s + t) = bind (Sections s) fun m => map ((fun x x_1 => x + x_1) m) (Sections t)
⊢ Sections (a ::ₘ s + t) = bind (Sections (a ::ₘ s)) fun m => map ((fun x x_1 => x + x_1) m) (Sections t)
Theorem: Finset.erase_right_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.216947
γ : Type ?u.216950
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b✝ a b : α
s : Finset α
⊢ erase (erase s a) b = erase (erase s b) a

tactic: simp only [mem_erase, ← and_assoc]
state_before: case a
α : Type u_1
β : Type ?u.216947
γ : Type ?u.216950
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b✝ a b : α
s : Finset α
x : α
⊢ x ∈ erase (erase s a) b ↔ x ∈ erase (erase s b) a

tactic: rw [@and_comm (x ≠ a)]
state_before: case a
α : Type u_1
β : Type ?u.216947
γ : Type ?u.216950
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b✝ a b : α
s : Finset α
x : α
⊢ (x ≠ b ∧ x ≠ a) ∧ x ∈ s ↔ (x ≠ a ∧ x ≠ b) ∧ x ∈ s
Theorem: Encodable.encode_injective
File: Mathlib/Logic/Encodable/Basic.lean

tactic: rw [← encodek, e, encodek]
state_before: α : Type u_1
β : Type ?u.51
inst✝ : Encodable α
x y : α
e : encode x = encode y
⊢ some x = some y
Theorem: Finset.coe_filter_univ
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.31041
γ : Type ?u.31044
inst✝¹ : Fintype α
s t : Finset α
p : α → Prop
inst✝ : DecidablePred p
⊢ ↑(filter p univ) = {x | p x}
Theorem: Nat.size_shiftl'
File: Mathlib/Data/Nat/Size.lean

tactic: induction' n with n IH <;> simp [shiftl'] at h⊢
state_before: b : Bool
m n : ℕ
h : shiftl' b m n ≠ 0
⊢ size (shiftl' b m n) = size m + n

tactic: rw [size_bit h, Nat.add_succ]
state_before: case succ
b : Bool
m n✝ : ℕ
h✝ : shiftl' b m n✝ ≠ 0
n : ℕ
IH : shiftl' b m n ≠ 0 → size (shiftl' b m n) = size m + n
h : ¬bit b (shiftl' b m n) = 0
⊢ size (bit b (shiftl' b m n)) = size m + succ n

tactic: by_cases s0 : shiftl' b m n = 0 <;> [skip; rw [IH s0]]
state_before: case succ
b : Bool
m n✝ : ℕ
h✝ : shiftl' b m n✝ ≠ 0
n : ℕ
IH : shiftl' b m n ≠ 0 → size (shiftl' b m n) = size m + n
h : ¬bit b (shiftl' b m n) = 0
⊢ succ (size (shiftl' b m n)) = succ (size m + n)

tactic: rw [s0] at h⊢
state_before: case pos
b : Bool
m n✝ : ℕ
h✝ : shiftl' b m n✝ ≠ 0
n : ℕ
IH : shiftl' b m n ≠ 0 → size (shiftl' b m n) = size m + n
h : ¬bit b (shiftl' b m n) = 0
s0 : shiftl' b m n = 0
⊢ succ (size (shiftl' b m n)) = succ (size m + n)

tactic: cases b
state_before: case pos
b : Bool
m n✝ : ℕ
h✝ : shiftl' b m n✝ ≠ 0
n : ℕ
IH : shiftl' b m n ≠ 0 → size (shiftl' b m n) = size m + n
h : ¬bit b 0 = 0
s0 : shiftl' b m n = 0
⊢ succ (size 0) = succ (size m + n)

tactic: rw [shiftl'_tt_eq_mul_pow] at this
state_before: case pos.true
m n✝ n : ℕ
h✝ : shiftl' true m n✝ ≠ 0
IH : shiftl' true m n ≠ 0 → size (shiftl' true m n) = size m + n
h : ¬bit true 0 = 0
s0 : shiftl' true m n = 0
this : shiftl' true m n + 1 = 1
⊢ succ (size 0) = succ (size m + n)

tactic: obtain rfl := succ.inj (eq_one_of_dvd_one ⟨_, this.symm⟩)
state_before: case pos.true
m n✝ n : ℕ
h✝ : shiftl' true m n✝ ≠ 0
IH : shiftl' true m n ≠ 0 → size (shiftl' true m n) = size m + n
h : ¬bit true 0 = 0
s0 : shiftl' true m n = 0
this : (m + 1) * 2 ^ n = 1
⊢ succ (size 0) = succ (size m + n)

tactic: simp only [zero_add, one_mul] at this
state_before: case pos.true
n✝ n : ℕ
h✝ : ¬bit true 0 = 0
h : shiftl' true 0 n✝ ≠ 0
IH : shiftl' true 0 n ≠ 0 → size (shiftl' true 0 n) = size 0 + n
s0 : shiftl' true 0 n = 0
this : (0 + 1) * 2 ^ n = 1
⊢ succ (size 0) = succ (size 0 + n)

tactic: obtain rfl : n = 0 :=
  Nat.eq_zero_of_le_zero
    (le_of_not_gt fun hn => ne_of_gt (pow_lt_pow_of_lt_right (by decide) hn) this)
state_before: case pos.true
n✝ n : ℕ
h✝ : ¬bit true 0 = 0
h : shiftl' true 0 n✝ ≠ 0
IH : shiftl' true 0 n ≠ 0 → size (shiftl' true 0 n) = size 0 + n
s0 : shiftl' true 0 n = 0
this : 2 ^ n = 1
⊢ succ (size 0) = succ (size 0 + n)

tactic: rfl
state_before: case pos.true
n : ℕ
h✝ : ¬bit true 0 = 0
h : shiftl' true 0 n ≠ 0
IH : shiftl' true 0 0 ≠ 0 → size (shiftl' true 0 0) = size 0 + 0
s0 : shiftl' true 0 0 = 0
this : 2 ^ 0 = 1
⊢ succ (size 0) = succ (size 0 + 0)

tactic: exact absurd rfl h
state_before: case pos.false
m n✝ n : ℕ
h✝ : shiftl' false m n✝ ≠ 0
IH : shiftl' false m n ≠ 0 → size (shiftl' false m n) = size m + n
h : ¬bit false 0 = 0
s0 : shiftl' false m n = 0
⊢ succ (size 0) = succ (size m + n)

tactic: decide
state_before: n✝ n : ℕ
h✝ : ¬bit true 0 = 0
h : shiftl' true 0 n✝ ≠ 0
IH : shiftl' true 0 n ≠ 0 → size (shiftl' true 0 n) = size 0 + n
s0 : shiftl' true 0 n = 0
this : 2 ^ n = 1
hn : n > 0
⊢ 1 < 2
Theorem: Polynomial.roots_mul
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [count_add, count_roots, count_roots, count_roots, rootMultiplicity_mul hpq]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q✝ p q : R[X]
hpq : p * q ≠ 0
r : R
⊢ count r (roots (p * q)) = count r (roots p + roots q)