tasksource/leandojo huggingface dataset:
Theorem: List.Nodup.pmap
File: Mathlib/Data/List/Nodup.lean

tactic: rw [pmap_eq_map_attach]
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
hf : ∀ (a : α) (ha : p a) (b : α) (hb : p b), f a ha = f b hb → a = b
h : Nodup l
⊢ Nodup (List.pmap f l H)

tactic: exact h.attach.map fun ⟨a, ha⟩ ⟨b, hb⟩ h => by congr; exact hf a (H _ ha) b (H _ hb) h
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
hf : ∀ (a : α) (ha : p a) (b : α) (hb : p b), f a ha = f b hb → a = b
h : Nodup l
⊢ Nodup (map (fun x => f ↑x (_ : p ↑x)) (List.attach l))

tactic: congr
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b✝ : α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
hf : ∀ (a : α) (ha : p a) (b : α) (hb : p b), f a ha = f b hb → a = b
h✝ : Nodup l
x✝¹ x✝ : { x // x ∈ l }
a : α
ha : a ∈ l
b : α
hb : b ∈ l
h :
  f ↑{ val := a, property := ha } (_ : p ↑{ val := a, property := ha }) =
    f ↑{ val := b, property := hb } (_ : p ↑{ val := b, property := hb })
⊢ { val := a, property := ha } = { val := b, property := hb }

tactic: exact hf a (H _ ha) b (H _ hb) h
state_before: case e_val
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b✝ : α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
hf : ∀ (a : α) (ha : p a) (b : α) (hb : p b), f a ha = f b hb → a = b
h✝ : Nodup l
x✝¹ x✝ : { x // x ∈ l }
a : α
ha : a ∈ l
b : α
hb : b ∈ l
h :
  f ↑{ val := a, property := ha } (_ : p ↑{ val := a, property := ha }) =
    f ↑{ val := b, property := hb } (_ : p ↑{ val := b, property := hb })
⊢ a = b
Theorem: Nat.ofDigits_zmodeq'
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' L with d L ih
state_before: n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
L : List ℕ
⊢ ofDigits b L ≡ ofDigits b' L [ZMOD ↑k]

tactic: rfl
state_before: case nil
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
⊢ ofDigits b [] ≡ ofDigits b' [] [ZMOD ↑k]

tactic: dsimp [ofDigits]
state_before: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [ZMOD ↑k]
⊢ ofDigits b (d :: L) ≡ ofDigits b' (d :: L) [ZMOD ↑k]

tactic: dsimp [Int.ModEq] at *
state_before: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [ZMOD ↑k]
⊢ ↑d + b * ofDigits b L ≡ ↑d + b' * ofDigits b' L [ZMOD ↑k]

tactic: conv_lhs => rw [Int.add_emod, Int.mul_emod, h, ih]
state_before: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b % ↑k = b' % ↑k
d : ℕ
L : List ℕ
ih : ofDigits b L % ↑k = ofDigits b' L % ↑k
⊢ (↑d + b * ofDigits b L) % ↑k = (↑d + b' * ofDigits b' L) % ↑k

tactic: conv_rhs => rw [Int.add_emod, Int.mul_emod]
state_before: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b % ↑k = b' % ↑k
d : ℕ
L : List ℕ
ih : ofDigits b L % ↑k = ofDigits b' L % ↑k
⊢ (↑d % ↑k + b' % ↑k * (ofDigits b' L % ↑k) % ↑k) % ↑k = (↑d + b' * ofDigits b' L) % ↑k
Theorem: ZMod.nat_cast_toNat
File: Mathlib/Data/ZMod/Basic.lean

tactic: simp only [Int.cast_ofNat, Int.toNat_coe_nat]
state_before: p n : ℕ
_h : 0 ≤ ↑n
⊢ ↑(Int.toNat ↑n) = ↑↑n

tactic: simp at h
state_before: p n : ℕ
h : 0 ≤ Int.negSucc n
⊢ ↑(Int.toNat (Int.negSucc n)) = ↑(Int.negSucc n)
Theorem: uniformCauchySeqOnFilter_of_deriv
File: Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean

tactic: simp_rw [hasDerivAt_iff_hasFDerivAt] at hf
state_before: ι : Type u_3
l : Filter ι
𝕜 : Type u_1
inst✝² : IsROrC 𝕜
G : Type u_2
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : ι → 𝕜 → G
g : 𝕜 → G
f' : ι → 𝕜 → G
g' : 𝕜 → G
x : 𝕜
hf' : UniformCauchySeqOnFilter f' l (𝓝 x)
hf : ∀ᶠ (n : ι × 𝕜) in l ×ˢ 𝓝 x, HasDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : Cauchy (map (fun n => f n x) l)
⊢ UniformCauchySeqOnFilter f l (𝓝 x)

tactic: exact uniformCauchySeqOnFilter_of_fderiv hf'.one_smulRight hf hfg
state_before: ι : Type u_3
l : Filter ι
𝕜 : Type u_1
inst✝² : IsROrC 𝕜
G : Type u_2
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : ι → 𝕜 → G
g : 𝕜 → G
f' : ι → 𝕜 → G
g' : 𝕜 → G
x : 𝕜
hf' : UniformCauchySeqOnFilter f' l (𝓝 x)
hfg : Cauchy (map (fun n => f n x) l)
hf : ∀ᶠ (n : ι × 𝕜) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (ContinuousLinearMap.smulRight 1 (f' n.fst n.snd)) n.snd
⊢ UniformCauchySeqOnFilter f l (𝓝 x)
Theorem: isLeast_union_iff
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp [IsLeast, lowerBounds_union, or_and_right, and_comm (a := a ∈ t), and_assoc]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t✝ : Set α
a✝ b a : α
s t : Set α
⊢ IsLeast (s ∪ t) a ↔ IsLeast s a ∧ a ∈ lowerBounds t ∨ a ∈ lowerBounds s ∧ IsLeast t a
Theorem: AlgebraicIndependent.comp
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: intro p q
state_before: ι : Type u_2
ι' : Type u_1
R : Type u_3
K : Type ?u.166980
A : Type u_4
A' : Type ?u.166986
A'' : Type ?u.166989
V : Type u
V' : Type ?u.166994
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
hx : AlgebraicIndependent R x
f : ι' → ι
hf : Injective f
⊢ AlgebraicIndependent R (x ∘ f)

tactic: simpa [aeval_rename, (rename_injective f hf).eq_iff] using @hx (rename f p) (rename f q)
state_before: ι : Type u_2
ι' : Type u_1
R : Type u_3
K : Type ?u.166980
A : Type u_4
A' : Type ?u.166986
A'' : Type ?u.166989
V : Type u
V' : Type ?u.166994
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
hx : AlgebraicIndependent R x
f : ι' → ι
hf : Injective f
p q : MvPolynomial ι' R
⊢ ↑(aeval (x ∘ f)) p = ↑(aeval (x ∘ f)) q → p = q
Theorem: BoxIntegral.Box.coe_splitLower
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: rw [splitLower, coe_mk']
state_before: ι : Type u_1
M : Type ?u.775
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ ↑(splitLower I i x) = ↑I ∩ {y | y i ≤ x}

tactic: ext y
state_before: ι : Type u_1
M : Type ?u.775
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ (Set.pi univ fun i_1 => Ioc (lower I i_1) (update I.upper i (min x (upper I i)) i_1)) = ↑I ∩ {y | y i ≤ x}

tactic: simp only [mem_univ_pi, mem_Ioc, mem_inter_iff, mem_coe, mem_setOf_eq, forall_and, ← Pi.le_def,
  le_update_iff, le_min_iff, and_assoc, and_forall_ne (p := fun j => y j ≤ upper I j) i, mem_def]
state_before: case h
ι : Type u_1
M : Type ?u.775
n : ℕ
I : Box ι
i : ι
x : ℝ
y✝ y : ι → ℝ
⊢ (y ∈ Set.pi univ fun i_1 => Ioc (lower I i_1) (update I.upper i (min x (upper I i)) i_1)) ↔ y ∈ ↑I ∩ {y | y i ≤ x}

tactic: rw [and_comm (a := y i ≤ x), Pi.le_def]
state_before: case h
ι : Type u_1
M : Type ?u.775
n : ℕ
I : Box ι
i : ι
x : ℝ
y✝ y : ι → ℝ
⊢ ((∀ (x : ι), lower I x < y x) ∧ y i ≤ x ∧ (fun i => y i) ≤ fun i => upper I i) ↔
    (∀ (x : ι), lower I x < y x) ∧ ((fun i => y i) ≤ fun i => upper I i) ∧ y i ≤ x
Theorem: SimplicialObject.Splitting.ιSummand_comp_app
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: simp only [ιSummand_eq_assoc, φ, assoc]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f : X ⟶ Y
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ιSummand s A ≫ f.app Δ = φ s f (len A.fst.unop) ≫ Y.map (IndexSet.e A).op

tactic: erw [NatTrans.naturality]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f : X ⟶ Y
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ι s (len A.fst.unop) ≫ X.map (IndexSet.e A).op ≫ f.app Δ =
    ι s (len A.fst.unop) ≫ f.app [len A.fst.unop].op ≫ Y.map (IndexSet.e A).op
Theorem: Real.arctan_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: constructor <;> linarith [pi_pos]
state_before: ⊢ π / 4 ∈ Ioo (-(π / 2)) (π / 2)
Theorem: Finset.cast_card
File: Mathlib/Algebra/Module/BigOperators.lean

tactic: rw [Finset.sum_const, Nat.smul_one_eq_coe]
state_before: α : Type u_2
β : Type ?u.38166
R : Type u_1
M : Type ?u.38172
ι : Type ?u.38175
inst✝ : CommSemiring R
s : Finset α
⊢ ↑(card s) = ∑ a in s, 1
Theorem: List.Ico.map_sub
File: Mathlib/Data/List/Intervals.lean

tactic: rw [Ico, Ico, tsub_tsub_tsub_cancel_right h₁, map_sub_range' _ _ _ h₁]
state_before: n m k : ℕ
h₁ : k ≤ n
⊢ map (fun x => x - k) (Ico n m) = Ico (n - k) (m - k)
Theorem: Basis.constr_apply_fintype
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [b.constr_apply, b.equivFun_apply, Finsupp.sum_fintype]
state_before: ι : Type u_4
ι' : Type ?u.704791
R : Type u_3
R₂ : Type ?u.704797
K : Type ?u.704800
M : Type u_2
M' : Type u_1
M'' : Type ?u.704809
V : Type u
V' : Type ?u.704814
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : Module R M'
inst✝³ : Fintype ι
b : Basis ι R M
S : Type u_5
inst✝² : Semiring S
inst✝¹ : Module S M'
inst✝ : SMulCommClass R S M'
f : ι → M'
x : M
⊢ ↑(↑(constr b S) f) x = ∑ i : ι, ↑(equivFun b) x i • f i
Theorem: isSelfAdjoint_star_add_self
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, add_comm, star_add, star_star]
state_before: R : Type u_1
A : Type ?u.15141
inst✝¹ : AddCommMonoid R
inst✝ : StarAddMonoid R
x : R
⊢ IsSelfAdjoint (star x + x)
Theorem: multiplicity.exists_eq_pow_mul_and_not_dvd
File: Mathlib/RingTheory/Multiplicity.lean

tactic: obtain ⟨c, hc⟩ := multiplicity.pow_multiplicity_dvd hfin
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
⊢ ∃ c, b = a ^ Part.get (multiplicity a b) hfin * c ∧ ¬a ∣ c

tactic: refine' ⟨c, hc, _⟩
state_before: case intro
α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
c : α
hc : b = a ^ Part.get (multiplicity a b) hfin * c
⊢ ∃ c, b = a ^ Part.get (multiplicity a b) hfin * c ∧ ¬a ∣ c

tactic: rintro ⟨k, hk⟩
state_before: case intro
α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
c : α
hc : b = a ^ Part.get (multiplicity a b) hfin * c
⊢ ¬a ∣ c

tactic: rw [hk, ← mul_assoc, ← _root_.pow_succ'] at hc
state_before: case intro.intro
α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
c : α
hc : b = a ^ Part.get (multiplicity a b) hfin * c
k : α
hk : c = a * k
⊢ False

tactic: have h₁ : a ^ ((multiplicity a b).get hfin + 1) ∣ b := ⟨k, hc⟩
state_before: case intro.intro
α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
c k : α
hc : b = a ^ (Part.get (multiplicity a b) hfin + 1) * k
hk : c = a * k
⊢ False

tactic: exact (multiplicity.eq_coe_iff.1 (by simp)).2 h₁
state_before: case intro.intro
α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
c k : α
hc : b = a ^ (Part.get (multiplicity a b) hfin + 1) * k
hk : c = a * k
h₁ : a ^ (Part.get (multiplicity a b) hfin + 1) ∣ b
⊢ False

tactic: simp
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
c k : α
hc : b = a ^ (Part.get (multiplicity a b) hfin + 1) * k
hk : c = a * k
h₁ : a ^ (Part.get (multiplicity a b) hfin + 1) ∣ b
⊢ multiplicity a b = ↑(Part.get (multiplicity a b) hfin)
Theorem: Ordinal.sup_sum
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: apply (sup_le_iff.2 _).antisymm (max_le_iff.2 ⟨_, _⟩)
state_before: α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
⊢ sup f = max (sup fun a => f (Sum.inl a)) (sup fun b => f (Sum.inr b))

tactic: all_goals
  apply sup_le_of_range_subset.{_, max u v, w}
  rintro i ⟨a, rfl⟩
  apply mem_range_self
state_before: α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
⊢ (sup fun a => f (Sum.inl a)) ≤ sup f

α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
⊢ (sup fun b => f (Sum.inr b)) ≤ sup f

tactic: rintro (i | i)
state_before: α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
⊢ ∀ (i : α ⊕ β), f i ≤ max (sup fun a => f (Sum.inl a)) (sup fun b => f (Sum.inr b))

tactic: exact le_max_of_le_left (le_sup _ i)
state_before: case inl
α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
i : α
⊢ f (Sum.inl i) ≤ max (sup fun a => f (Sum.inl a)) (sup fun b => f (Sum.inr b))

tactic: exact le_max_of_le_right (le_sup _ i)
state_before: case inr
α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
i : β
⊢ f (Sum.inr i) ≤ max (sup fun a => f (Sum.inl a)) (sup fun b => f (Sum.inr b))

tactic: apply sup_le_of_range_subset.{_, max u v, w}
state_before: α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
⊢ (sup fun b => f (Sum.inr b)) ≤ sup f

tactic: rintro i ⟨a, rfl⟩
state_before: α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
⊢ (range fun b => f (Sum.inr b)) ⊆ range f

tactic: apply mem_range_self
state_before: case intro
α✝ : Type ?u.289176
β✝ : Type ?u.289179
γ : Type ?u.289182
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
f : α ⊕ β → Ordinal
a : β
⊢ (fun b => f (Sum.inr b)) a ∈ range f
Theorem: List.perm_of_nodup_nodup_toFinset_eq
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← Multiset.coe_eq_coe]
state_before: α : Type u_1
β : Type ?u.469969
γ : Type ?u.469972
inst✝ : DecidableEq α
l l' : List α
a : α
hl : Nodup l
hl' : Nodup l'
h : toFinset l = toFinset l'
⊢ l ~ l'

tactic: exact Multiset.Nodup.toFinset_inj hl hl' h
state_before: α : Type u_1
β : Type ?u.469969
γ : Type ?u.469972
inst✝ : DecidableEq α
l l' : List α
a : α
hl : Nodup l
hl' : Nodup l'
h : toFinset l = toFinset l'
⊢ ↑l = ↑l'
Theorem: Primrec.fin_curry
File: Mathlib/Computability/Primrec.lean

tactic: funext i
state_before: α : Type u_1
β : Type ?u.371824
γ : Type ?u.371827
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : α → Fin n → σ
h : Primrec₂ f
a : α
⊢ Vector.get (Vector.ofFn fun i => f a i) = f a

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.371824
γ : Type ?u.371827
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : α → Fin n → σ
h : Primrec₂ f
a : α
i : Fin n
⊢ Vector.get (Vector.ofFn fun i => f a i) i = f a i
Theorem: Finset.eq_of_mem_of_not_mem_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [mem_erase, not_and] at hsa
state_before: α : Type u_1
β : Type ?u.208349
γ : Type ?u.208352
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hs : b ∈ s
hsa : ¬b ∈ erase s a
⊢ b = a

tactic: exact not_imp_not.mp hsa hs
state_before: α : Type u_1
β : Type ?u.208349
γ : Type ?u.208352
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hs : b ∈ s
hsa : b ≠ a → ¬b ∈ s
⊢ b = a
Theorem: Set.zero_mem_smul_set_iff
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: refine' ⟨_, zero_mem_smul_set⟩
state_before: F : Type ?u.94503
α : Type u_1
β : Type u_2
γ : Type ?u.94512
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a : α
ha : a ≠ 0
⊢ 0 ∈ a • t ↔ 0 ∈ t

tactic: rintro ⟨b, hb, h⟩
state_before: F : Type ?u.94503
α : Type u_1
β : Type u_2
γ : Type ?u.94512
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a : α
ha : a ≠ 0
⊢ 0 ∈ a • t → 0 ∈ t

tactic: rwa [(eq_zero_or_eq_zero_of_smul_eq_zero h).resolve_left ha] at hb
state_before: case intro.intro
F : Type ?u.94503
α : Type u_1
β : Type u_2
γ : Type ?u.94512
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
a : α
ha : a ≠ 0
b : β
hb : b ∈ t
h : (fun x => a • x) b = 0
⊢ 0 ∈ t
Theorem: ContinuousMultilinearMap.op_norm_add_le
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: rw [add_mul]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m x : (i : ι) → E i
⊢ ‖↑(f + g) x‖ ≤ (‖f‖ + ‖g‖) * ∏ i : ι, ‖x i‖

tactic: exact norm_add_le_of_le (le_op_norm _ _) (le_op_norm _ _)
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m x : (i : ι) → E i
⊢ ‖↑(f + g) x‖ ≤ ‖f‖ * ∏ i : ι, ‖x i‖ + ‖g‖ * ∏ i : ι, ‖x i‖
Theorem: Finset.Ici_erase
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.113545
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderTop α
inst✝ : DecidableEq α
a : α
⊢ erase (Ici a) a = Ioi a

tactic: simp_rw [Finset.mem_erase, mem_Ici, mem_Ioi, lt_iff_le_and_ne, and_comm, ne_comm]
state_before: case a
ι : Type ?u.113545
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderTop α
inst✝ : DecidableEq α
a a✝ : α
⊢ a✝ ∈ erase (Ici a) a ↔ a✝ ∈ Ioi a
Theorem: Part.mem_restrict
File: Mathlib/Data/Part.lean

tactic: dsimp [restrict, mem_eq]
state_before: α : Type u_1
β : Type ?u.52027
γ : Type ?u.52030
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ a ∈ restrict p o h ↔ p ∧ a ∈ o

tactic: constructor
state_before: α : Type u_1
β : Type ?u.52027
γ : Type ?u.52030
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ h_1, get o (_ : o.Dom) = a) ↔ p ∧ ∃ h, get o h = a

tactic: rintro ⟨h₀, _, h₂⟩
state_before: case mpr
α : Type u_1
β : Type ?u.52027
γ : Type ?u.52030
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (p ∧ ∃ h, get o h = a) → ∃ h_1, get o (_ : o.Dom) = a

tactic: exact ⟨h₀, h₂⟩
state_before: case mpr.intro.intro
α : Type u_1
β : Type ?u.52027
γ : Type ?u.52030
p : Prop
o : Part α
h : p → o.Dom
a : α
h₀ : p
w✝ : o.Dom
h₂ : get o w✝ = a
⊢ ∃ h_1, get o (_ : o.Dom) = a

tactic: rintro ⟨h₀, h₁⟩
state_before: case mp
α : Type u_1
β : Type ?u.52027
γ : Type ?u.52030
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ h_1, get o (_ : o.Dom) = a) → p ∧ ∃ h, get o h = a

tactic: exact ⟨h₀, ⟨_, h₁⟩⟩
state_before: case mp.intro
α : Type u_1
β : Type ?u.52027
γ : Type ?u.52030
p : Prop
o : Part α
h : p → o.Dom
a : α
h₀ : p
h₁ : get o (_ : o.Dom) = a
⊢ p ∧ ∃ h, get o h = a
Theorem: intervalIntegral.integral_finset_sum
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegral_eq_integral_uIoc, integral_finset_sum s fun i hi => (h i hi).def,
  Finset.smul_sum]
state_before: ι✝ : Type ?u.12645175
𝕜 : Type ?u.12645178
E : Type u_2
F : Type ?u.12645184
A : Type ?u.12645187
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f✝ g : ℝ → E
μ : MeasureTheory.Measure ℝ
ι : Type u_1
s : Finset ι
f : ι → ℝ → E
h : ∀ (i : ι), i ∈ s → IntervalIntegrable (f i) μ a b
⊢ (∫ (x : ℝ) in a..b, ∑ i in s, f i x ∂μ) = ∑ i in s, ∫ (x : ℝ) in a..b, f i x ∂μ
Theorem: MeasureTheory.AEEqFun.coeFn_comp
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [comp_eq_mk]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.350267
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
hg : Continuous g
f : α →ₘ[μ] β
⊢ ↑(comp g hg f) =ᵐ[μ] g ∘ ↑f

tactic: apply coeFn_mk
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.350267
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
hg : Continuous g
f : α →ₘ[μ] β
⊢ ↑(mk (g ∘ ↑f) (_ : AEStronglyMeasurable (fun x => g (↑f x)) μ)) =ᵐ[μ] g ∘ ↑f
Theorem: Dfinsupp.single_eq_of_ne
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [single_apply, dif_neg h]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
b : β i
h : i ≠ i'
⊢ ↑(single i b) i' = 0
Theorem: List.getLastD_concat
File: Std/Data/List/Lemmas.lean

tactic: rw [getLastD_eq_getLast?, getLast?_concat]
state_before: α : Type u_1
a b : α
l : List α
⊢ getLastD (l ++ [b]) a = b

tactic: rfl
state_before: α : Type u_1
a b : α
l : List α
⊢ Option.getD (some b) a = b
Theorem: Pmf.toMeasure_injective
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: intro p q h
state_before: α : Type u_1
β : Type ?u.85918
γ : Type ?u.85921
inst✝¹ : MeasurableSpace α
p : Pmf α
s t : Set α
inst✝ : MeasurableSingletonClass α
⊢ Function.Injective toMeasure

tactic: ext x
state_before: α : Type u_1
β : Type ?u.85918
γ : Type ?u.85921
inst✝¹ : MeasurableSpace α
p✝ : Pmf α
s t : Set α
inst✝ : MeasurableSingletonClass α
p q : Pmf α
h : toMeasure p = toMeasure q
⊢ p = q

tactic: rw [← p.toMeasure_apply_singleton x <| measurableSet_singleton x,
  ← q.toMeasure_apply_singleton x <| measurableSet_singleton x, h]
state_before: case h
α : Type u_1
β : Type ?u.85918
γ : Type ?u.85921
inst✝¹ : MeasurableSpace α
p✝ : Pmf α
s t : Set α
inst✝ : MeasurableSingletonClass α
p q : Pmf α
h : toMeasure p = toMeasure q
x : α
⊢ ↑p x = ↑q x
Theorem: SimpleGraph.incMatrix_of_not_mem_incidenceSet
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

tactic: rw [incMatrix_apply, Set.indicator_of_not_mem h]
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝ : MulZeroOneClass R
a b : α
e : Sym2 α
h : ¬e ∈ incidenceSet G a
⊢ incMatrix R G a e = 0