tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.hasSum_integral_iUnion_ae
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: simp only [IntegrableOn, Measure.restrict_iUnion_ae hd hm] at hfi ⊢
state_before: α : Type u_2
β : Type ?u.62254
E : Type u_3
F : Type ?u.62260
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
f g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
ι : Type u_1
inst✝ : Countable ι
s : ι → Set α
hm : ∀ (i : ι), NullMeasurableSet (s i)
hd : Pairwise (AEDisjoint μ on s)
hfi : IntegrableOn f (⋃ (i : ι), s i)
⊢ HasSum (fun n => ∫ (a : α) in s n, f a ∂μ) (∫ (a : α) in ⋃ (n : ι), s n, f a ∂μ)

tactic: exact hasSum_integral_measure hfi
state_before: α : Type u_2
β : Type ?u.62254
E : Type u_3
F : Type ?u.62260
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
f g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
ι : Type u_1
inst✝ : Countable ι
s : ι → Set α
hm : ∀ (i : ι), NullMeasurableSet (s i)
hd : Pairwise (AEDisjoint μ on s)
hfi : Integrable f
⊢ HasSum (fun n => ∫ (a : α) in s n, f a ∂μ) (∫ (a : α), f a ∂Measure.sum fun i => Measure.restrict μ (s i))
Theorem: Valuation.map_add'
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: intro x y
state_before: K : Type ?u.419164
F : Type ?u.419167
R : Type u_2
inst✝⁴ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.419179
Γ''₀ : Type ?u.419182
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v : Valuation R Γ₀
x y z : R
⊢ ∀ (x y : R), ↑v (x + y) ≤ ↑v x ∨ ↑v (x + y) ≤ ↑v y

tactic: rw [← le_max_iff, ← ge_iff_le]
state_before: K : Type ?u.419164
F : Type ?u.419167
R : Type u_2
inst✝⁴ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.419179
Γ''₀ : Type ?u.419182
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v : Valuation R Γ₀
x✝ y✝ z x y : R
⊢ ↑v (x + y) ≤ ↑v x ∨ ↑v (x + y) ≤ ↑v y

tactic: apply map_add
state_before: K : Type ?u.419164
F : Type ?u.419167
R : Type u_2
inst✝⁴ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.419179
Γ''₀ : Type ?u.419182
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v : Valuation R Γ₀
x✝ y✝ z x y : R
⊢ max (↑v x) (↑v y) ≥ ↑v (x + y)
Theorem: AlgebraicGeometry.PresheafedSpace.hext
File: Mathlib/AlgebraicGeometry/PresheafedSpace.lean

tactic: cases α
state_before: C : Type u_1
inst✝ : Category C
X Y : PresheafedSpace C
α β : Hom X Y
w : α.base = β.base
h : HEq α.c β.c
⊢ α = β

tactic: cases β
state_before: case mk
C : Type u_1
inst✝ : Category C
X Y : PresheafedSpace C
β : Hom X Y
base✝ : ↑X ⟶ ↑Y
c✝ : Y.presheaf ⟶ base✝ _* X.presheaf
w : { base := base✝, c := c✝ }.base = β.base
h : HEq { base := base✝, c := c✝ }.c β.c
⊢ { base := base✝, c := c✝ } = β

tactic: congr
state_before: case mk.mk
C : Type u_1
inst✝ : Category C
X Y : PresheafedSpace C
base✝¹ : ↑X ⟶ ↑Y
c✝¹ : Y.presheaf ⟶ base✝¹ _* X.presheaf
base✝ : ↑X ⟶ ↑Y
c✝ : Y.presheaf ⟶ base✝ _* X.presheaf
w : { base := base✝¹, c := c✝¹ }.base = { base := base✝, c := c✝ }.base
h : HEq { base := base✝¹, c := c✝¹ }.c { base := base✝, c := c✝ }.c
⊢ { base := base✝¹, c := c✝¹ } = { base := base✝, c := c✝ }
Theorem: HeytingHom.cancel_left
File: Mathlib/Order/Heyting/Hom.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.86036
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.86048
inst✝³ : HeytingAlgebra α
inst✝² : HeytingAlgebra β
inst✝¹ : HeytingAlgebra γ
inst✝ : HeytingAlgebra δ
f f₁ f₂ : HeytingHom α β
g g₁ g₂ : HeytingHom β γ
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: Dense.borel_eq_generateFrom_Ico_mem
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simp
state_before: α✝ : Type ?u.653000
β : Type ?u.653003
γ : Type ?u.653006
γ₂ : Type ?u.653009
δ : Type ?u.653012
ι : Sort y
s✝ t u : Set α✝
inst✝²² : TopologicalSpace α✝
inst✝²¹ : MeasurableSpace α✝
inst✝²⁰ : OpensMeasurableSpace α✝
inst✝¹⁹ : TopologicalSpace β
inst✝¹⁸ : MeasurableSpace β
inst✝¹⁷ : OpensMeasurableSpace β
inst✝¹⁶ : TopologicalSpace γ
inst✝¹⁵ : MeasurableSpace γ
inst✝¹⁴ : BorelSpace γ
inst✝¹³ : TopologicalSpace γ₂
inst✝¹² : MeasurableSpace γ₂
inst✝¹¹ : BorelSpace γ₂
inst✝¹⁰ : MeasurableSpace δ
α' : Type ?u.653105
inst✝⁹ : TopologicalSpace α'
inst✝⁸ : MeasurableSpace α'
inst✝⁷ : LinearOrder α✝
inst✝⁶ : OrderClosedTopology α✝
a b x : α✝
α : Type u_1
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderTopology α
inst✝² : SecondCountableTopology α
inst✝¹ : DenselyOrdered α
inst✝ : NoMinOrder α
s : Set α
hd : Dense s
⊢ ∀ (x : α), IsBot x → x ∈ s
Theorem: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv_desc
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone G
r t : Cocone F
P : IsColimit t
Q : IsColimit s
w : F ≅ G
⊢ ∀ (j : J), s.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).inv ≫ desc P r = s.ι.app j ≫ map Q r w.inv
Theorem: Vector.mem_map_succ_iff
File: Mathlib/Data/Vector/Mem.lean

tactic: rw [mem_succ_iff, head_map, tail_map, mem_map_iff, @eq_comm _ b]
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
b : β
v : Vector α (n + 1)
f : α → β
⊢ b ∈ toList (map f v) ↔ f (head v) = b ∨ ∃ a, a ∈ toList (tail v) ∧ f a = b
Theorem: Int.add_lt_of_lt_sub_right
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h b
state_before: a b c : Int
h : a < c - b
⊢ a + b < c

tactic: rwa [Int.sub_add_cancel] at h
state_before: a b c : Int
h✝ : a < c - b
h : a + b < c - b + b
⊢ a + b < c
Theorem: lt_inv_mul_iff_lt
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_left b, mul_one, mul_inv_cancel_left]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ 1 < b⁻¹ * a ↔ b < a
Theorem: Complex.log_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp [log]
state_before: ⊢ log 0 = 0
Theorem: Relation.TransGen.swap
File: Mathlib/Logic/Relation.lean

tactic: induction' h with b h b c _ hbc ih
state_before: α : Type u_1
β : Type ?u.23725
γ : Type ?u.23728
δ : Type ?u.23731
r : α → α → Prop
a b c d : α
h : TransGen r b a
⊢ TransGen (Function.swap r) a b

tactic: exact TransGen.single h
state_before: case single
α : Type u_1
β : Type ?u.23725
γ : Type ?u.23728
δ : Type ?u.23731
r : α → α → Prop
a b✝ c d b : α
h : r b✝ b
⊢ TransGen (Function.swap r) b b✝

tactic: exact ih.head hbc
state_before: case tail
α : Type u_1
β : Type ?u.23725
γ : Type ?u.23728
δ : Type ?u.23731
r : α → α → Prop
a b✝ c✝ d b c : α
a✝ : TransGen r b✝ b
hbc : r b c
ih : TransGen (Function.swap r) b b✝
⊢ TransGen (Function.swap r) c b✝
Theorem: Hyperreal.isSt_iff_tendsto
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rcases ofSeq_surjective x with ⟨f, rfl⟩
state_before: x : ℝ*
r : ℝ
⊢ IsSt x r ↔ Germ.Tendsto x (𝓝 r)

tactic: exact isSt_ofSeq_iff_tendsto
state_before: case intro
r : ℝ
f : ℕ → ℝ
⊢ IsSt (ofSeq f) r ↔ Germ.Tendsto (ofSeq f) (𝓝 r)
Theorem: Basis.coe_toDual_self
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
i : ι
⊢ ↑(toDual b) (↑b i) = coord b i

tactic: apply toDual_apply_right
state_before: case h
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
i : ι
x✝ : M
⊢ ↑(↑(toDual b) (↑b i)) x✝ = ↑(coord b i) x✝
Theorem: imaginaryPart_apply_coe
File: Mathlib/Data/Complex/Module.lean

tactic: unfold imaginaryPart
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(↑ℑ a) = -I • 2⁻¹ • (a - star a)

tactic: simp only [LinearMap.coe_comp, Function.comp_apply, skewAdjoint.negISMul_apply_coe,
  skewAdjointPart_apply_coe, invOf_eq_inv, neg_smul]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(↑(LinearMap.comp skewAdjoint.negISMul (skewAdjointPart ℝ)) a) = -I • 2⁻¹ • (a - star a)
Theorem: continuous_finprod
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: refine' continuous_iff_continuousAt.2 fun x => _
state_before: ι : Type u_3
α : Type ?u.452056
X : Type u_1
M : Type u_2
N : Type ?u.452065
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
hc : ∀ (i : ι), Continuous (f i)
hf : LocallyFinite fun i => mulSupport (f i)
⊢ Continuous fun x => ∏ᶠ (i : ι), f i x

tactic: rcases finprod_eventually_eq_prod hf x with ⟨s, hs⟩
state_before: ι : Type u_3
α : Type ?u.452056
X : Type u_1
M : Type u_2
N : Type ?u.452065
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
hc : ∀ (i : ι), Continuous (f i)
hf : LocallyFinite fun i => mulSupport (f i)
x : X
⊢ ContinuousAt (fun x => ∏ᶠ (i : ι), f i x) x

tactic: refine' ContinuousAt.congr _ (EventuallyEq.symm hs)
state_before: case intro
ι : Type u_3
α : Type ?u.452056
X : Type u_1
M : Type u_2
N : Type ?u.452065
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
hc : ∀ (i : ι), Continuous (f i)
hf : LocallyFinite fun i => mulSupport (f i)
x : X
s : Finset ι
hs : ∀ᶠ (y : X) in 𝓝 x, (∏ᶠ (i : ι), f i y) = ∏ i in s, f i y
⊢ ContinuousAt (fun x => ∏ᶠ (i : ι), f i x) x

tactic: exact tendsto_finset_prod _ fun i _ => (hc i).continuousAt
state_before: case intro
ι : Type u_3
α : Type ?u.452056
X : Type u_1
M : Type u_2
N : Type ?u.452065
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
hc : ∀ (i : ι), Continuous (f i)
hf : LocallyFinite fun i => mulSupport (f i)
x : X
s : Finset ι
hs : ∀ᶠ (y : X) in 𝓝 x, (∏ᶠ (i : ι), f i y) = ∏ i in s, f i y
⊢ ContinuousAt (fun x => ∏ i in s, f i x) x
Theorem: geom_sum_ne_zero
File: Mathlib/Algebra/GeomSum.lean

tactic: obtain _ | _ | n := n
state_before: α : Type u
β : Type ?u.249597
n : ℕ
x : α
inst✝ : LinearOrderedRing α
hx : x ≠ -1
hn : n ≠ 0
⊢ ∑ i in range n, x ^ i ≠ 0

tactic: rw [Ne.def, eq_neg_iff_add_eq_zero, ← Ne.def] at hx
state_before: case succ.succ
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x ≠ -1
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
⊢ ∑ i in range (Nat.succ (Nat.succ n)), x ^ i ≠ 0

tactic: obtain h | h := hx.lt_or_lt
state_before: case succ.succ
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x + 1 ≠ 0
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
⊢ ∑ i in range (Nat.succ (Nat.succ n)), x ^ i ≠ 0

tactic: cases hn rfl
state_before: case zero
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x ≠ -1
hn : Nat.zero ≠ 0
⊢ ∑ i in range Nat.zero, x ^ i ≠ 0

tactic: simp only [Nat.zero_eq, ← Nat.one_eq_succ_zero, range_one, sum_singleton, pow_zero, ne_eq,
  one_ne_zero, not_false_iff]
state_before: case succ.zero
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x ≠ -1
hn : Nat.succ Nat.zero ≠ 0
⊢ ∑ i in range (Nat.succ Nat.zero), x ^ i ≠ 0

tactic: have := geom_sum_alternating_of_lt_neg_one h n.one_lt_succ_succ
state_before: case succ.succ.inl
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x + 1 ≠ 0
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
h : x + 1 < 0
⊢ ∑ i in range (Nat.succ (Nat.succ n)), x ^ i ≠ 0

tactic: split_ifs  at this
state_before: case succ.succ.inl
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x + 1 ≠ 0
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
h : x + 1 < 0
this :
  if Even (Nat.succ (Nat.succ n)) then ∑ i in range (Nat.succ (Nat.succ n)), x ^ i < 0
  else 1 < ∑ i in range (Nat.succ (Nat.succ n)), x ^ i
⊢ ∑ i in range (Nat.succ (Nat.succ n)), x ^ i ≠ 0

tactic: exact this.ne
state_before: case succ.succ.inl.inl
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x + 1 ≠ 0
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
h : x + 1 < 0
h✝ : Even (Nat.succ (Nat.succ n))
this : ∑ i in range (Nat.succ (Nat.succ n)), x ^ i < 0
⊢ ∑ i in range (Nat.succ (Nat.succ n)), x ^ i ≠ 0

tactic: exact (zero_lt_one.trans this).ne'
state_before: case succ.succ.inl.inr
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x + 1 ≠ 0
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
h : x + 1 < 0
h✝ : ¬Even (Nat.succ (Nat.succ n))
this : 1 < ∑ i in range (Nat.succ (Nat.succ n)), x ^ i
⊢ ∑ i in range (Nat.succ (Nat.succ n)), x ^ i ≠ 0

tactic: exact (geom_sum_pos' h n.succ.succ_ne_zero).ne'
state_before: case succ.succ.inr
α : Type u
β : Type ?u.249597
x : α
inst✝ : LinearOrderedRing α
hx : x + 1 ≠ 0
n : ℕ
hn : Nat.succ (Nat.succ n) ≠ 0
h : 0 < x + 1
⊢ ∑ i in range (Nat.succ (Nat.succ n)), x ^ i ≠ 0
Theorem: MaximalSpectrum.toPrimeSpectrum_range
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Maximal.lean

tactic: simp only [isClosed_singleton_iff_isMaximal]
state_before: R : Type u
inst✝ : CommRing R
⊢ range toPrimeSpectrum = {x | IsClosed {x}}

tactic: ext ⟨x, _⟩
state_before: R : Type u
inst✝ : CommRing R
⊢ range toPrimeSpectrum = {x | Ideal.IsMaximal x.asIdeal}

tactic: exact ⟨fun ⟨y, hy⟩ => hy ▸ y.IsMaximal, fun hx => ⟨⟨x, hx⟩, rfl⟩⟩
state_before: case h.mk
R : Type u
inst✝ : CommRing R
x : Ideal R
IsPrime✝ : Ideal.IsPrime x
⊢ { asIdeal := x, IsPrime := IsPrime✝ } ∈ range toPrimeSpectrum ↔
    { asIdeal := x, IsPrime := IsPrime✝ } ∈ {x | Ideal.IsMaximal x.asIdeal}
Theorem: List.Nodup.sigma
File: Mathlib/Data/List/Nodup.lean

tactic: injection h with _ h
state_before: α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a✝ b✝ : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : Nodup l₁
d₂ : ∀ (a : α), Nodup (l₂ a)
a : α
x✝ : a ∈ l₁
b b' : (fun a => σ a) a
h : { fst := a, snd := b } = { fst := a, snd := b' }
⊢ b = b'

tactic: rcases mem_map.1 h₁ with ⟨b₁, _, rfl⟩
state_before: α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : Nodup l₁
d₂ : ∀ (a : α), Nodup (l₂ a)
a₁ a₂ : α
n : a₁ ≠ a₂
x : (a : α) × σ a
h₁ : x ∈ map (Sigma.mk a₁) (l₂ a₁)
h₂ : x ∈ map (Sigma.mk a₂) (l₂ a₂)
⊢ False

tactic: rcases mem_map.1 h₂ with ⟨b₂, mb₂, ⟨⟩⟩
state_before: case intro.intro
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : Nodup l₁
d₂ : ∀ (a : α), Nodup (l₂ a)
a₁ a₂ : α
n : a₁ ≠ a₂
b₁ : σ a₁
left✝ : b₁ ∈ l₂ a₁
h₁ : { fst := a₁, snd := b₁ } ∈ map (Sigma.mk a₁) (l₂ a₁)
h₂ : { fst := a₁, snd := b₁ } ∈ map (Sigma.mk a₂) (l₂ a₂)
⊢ False

tactic: exact n rfl
state_before: case intro.intro.intro.intro.refl
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : Nodup l₁
d₂ : ∀ (a : α), Nodup (l₂ a)
a₁ : α
b₁ : σ a₁
left✝ : b₁ ∈ l₂ a₁
h₁ : { fst := a₁, snd := b₁ } ∈ map (Sigma.mk a₁) (l₂ a₁)
n : a₁ ≠ a₁
h₂ : { fst := a₁, snd := b₁ } ∈ map (Sigma.mk a₁) (l₂ a₁)
mb₂ : b₁ ∈ l₂ a₁
⊢ False
Theorem: mem_posTangentConeAt_of_segment_subset'
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: simpa only [add_sub_cancel'] using mem_posTangentConeAt_of_segment_subset h
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
x y : E
h : segment ℝ x (x + y) ⊆ s
⊢ y ∈ posTangentConeAt s x
Theorem: EuclideanDomain.gcd_eq_left
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [← h]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
h : gcd a b = a
⊢ a ∣ b

tactic: apply gcd_dvd_right
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
h : gcd a b = a
⊢ gcd a b ∣ b

tactic: rw [gcd_val, mod_eq_zero.2 h, gcd_zero_left]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
h : a ∣ b
⊢ gcd a b = a
Theorem: Polynomial.smul_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [← smul_one_smul R s p, comp, comp, eval₂_smul, ← smul_eq_C_mul, smul_assoc, one_smul]
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✝² : Monoid S
inst✝¹ : DistribMulAction S R
inst✝ : IsScalarTower S R R
s : S
p q : R[X]
⊢ comp (s • p) q = s • comp p q
Theorem: Set.indicator_mul_right
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: simp only [indicator]
state_before: α : Type u_1
β : Type ?u.122704
ι : Type ?u.122707
M : Type u_2
N : Type ?u.122713
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
⊢ indicator s (fun a => f a * g a) a = f a * indicator s g a

tactic: split_ifs
state_before: α : Type u_1
β : Type ?u.122704
ι : Type ?u.122707
M : Type u_2
N : Type ?u.122713
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
⊢ (if a ∈ s then f a * g a else 0) = f a * if a ∈ s then g a else 0

tactic: rw [mul_zero]
state_before: case inr
α : Type u_1
β : Type ?u.122704
ι : Type ?u.122707
M : Type u_2
N : Type ?u.122713
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
h✝ : ¬a ∈ s
⊢ 0 = f a * 0

tactic: rfl
state_before: case inl
α : Type u_1
β : Type ?u.122704
ι : Type ?u.122707
M : Type u_2
N : Type ?u.122713
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
h✝ : a ∈ s
⊢ f a * g a = f a * g a
Theorem: Dfinsupp.add_closure_iUnion_range_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: apply Dfinsupp.induction x
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
x : Π₀ (i : ι), β i
x✝ : x ∈ ⊤
⊢ x ∈ AddSubmonoid.closure (⋃ (i : ι), Set.range (single i))

tactic: exact AddSubmonoid.zero_mem _
state_before: case h0
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
x : Π₀ (i : ι), β i
x✝ : x ∈ ⊤
⊢ 0 ∈ AddSubmonoid.closure (⋃ (i : ι), Set.range (single i))

case ha
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
x : Π₀ (i : ι), β i
x✝ : x ∈ ⊤
⊢ ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i),
    ↑f i = 0 →
      b ≠ 0 →
        f ∈ AddSubmonoid.closure (⋃ (i : ι), Set.range (single i)) →
          single i b + f ∈ AddSubmonoid.closure (⋃ (i : ι), Set.range (single i))

tactic: exact fun a b f _ _ hf =>
  AddSubmonoid.add_mem _
    (AddSubmonoid.subset_closure <| Set.mem_iUnion.2 ⟨a, Set.mem_range_self _⟩) hf
state_before: case ha
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
x : Π₀ (i : ι), β i
x✝ : x ∈ ⊤
⊢ ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i),
    ↑f i = 0 →
      b ≠ 0 →
        f ∈ AddSubmonoid.closure (⋃ (i : ι), Set.range (single i)) →
          single i b + f ∈ AddSubmonoid.closure (⋃ (i : ι), Set.range (single i))
Theorem: List.cons_bagInter_of_pos
File: Mathlib/Data/List/Lattice.lean

tactic: cases l₂
state_before: α : Type u_1
l l₁✝ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : a ∈ l₂
⊢ List.bagInter (a :: l₁) l₂ = a :: List.bagInter l₁ (List.erase l₂ a)

tactic: exact if_pos h
state_before: case nil
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : a ∈ []
⊢ List.bagInter (a :: l₁) [] = a :: List.bagInter l₁ (List.erase [] a)

tactic: simp only [List.bagInter, if_pos (elem_eq_true_of_mem h)]
state_before: case cons
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
head✝ : α
tail✝ : List α
h : a ∈ head✝ :: tail✝
⊢ List.bagInter (a :: l₁) (head✝ :: tail✝) = a :: List.bagInter l₁ (List.erase (head✝ :: tail✝) a)
Theorem: Module.End.generalizedEigenspace_zero
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: simp [Module.End.generalizedEigenspace]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
k : ℕ
⊢ ↑(generalizedEigenspace f 0) k = LinearMap.ker (f ^ k)
Theorem: toTopologicalSpace_iInf
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp only [@nhds_eq_comap_uniformity _ (iInf u), nhds_iInf,
iInf_uniformity, @nhds_eq_comap_uniformity _ (u _), comap_iInf]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι✝ : Sort ?u.143260
ι : Sort u_1
u : ι → UniformSpace α
a : α
⊢ 𝓝 a = 𝓝 a
Theorem: LinearPMap.domRestrict_apply
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: have : Submodule.ofLe (by simp) x = y := by
  ext
  simp [h]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.442039
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑(domRestrict f S) x = ↑f y

tactic: rw [← this]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.442039
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
this : ↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x = y
⊢ ↑(domRestrict f S) x = ↑f y

tactic: exact LinearPMap.mk_apply _ _ _
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.442039
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
this : ↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x = y
⊢ ↑(domRestrict f S) x = ↑f (↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x)

tactic: simp
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.442039
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ S ⊓ f.domain ≤ f.domain

tactic: ext
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.442039
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x = y

tactic: simp [h]
state_before: case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.442039
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑(↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x) = ↑y
Theorem: ChainComplex.mk_d_1_0
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: change ite (1 = 0 + 1) (𝟙 X₁ ≫ d₀) 0 = d₀
state_before: ι : Type ?u.181945
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₁ ⟶ X₀
d₁ : X₂ ⟶ X₁
s : d₁ ≫ d₀ = 0
succ :
  (t : (X₀ : V) ×' (X₁ : V) ×' (X₂ : V) ×' (d₀ : X₁ ⟶ X₀) ×' (d₁ : X₂ ⟶ X₁) ×' d₁ ≫ d₀ = 0) →
    (X₃ : V) ×' (d₂ : X₃ ⟶ t.snd.snd.fst) ×' d₂ ≫ t.snd.snd.snd.snd.fst = 0
⊢ HomologicalComplex.d (mk X₀ X₁ X₂ d₀ d₁ s succ) 1 0 = d₀

tactic: rw [if_pos rfl, Category.id_comp]
state_before: ι : Type ?u.181945
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₁ ⟶ X₀
d₁ : X₂ ⟶ X₁
s : d₁ ≫ d₀ = 0
succ :
  (t : (X₀ : V) ×' (X₁ : V) ×' (X₂ : V) ×' (d₀ : X₁ ⟶ X₀) ×' (d₁ : X₂ ⟶ X₁) ×' d₁ ≫ d₀ = 0) →
    (X₃ : V) ×' (d₂ : X₃ ⟶ t.snd.snd.fst) ×' d₂ ≫ t.snd.snd.snd.snd.fst = 0
⊢ (if 1 = 0 + 1 then 𝟙 X₁ ≫ d₀ else 0) = d₀