tasksource/leandojo huggingface dataset:
Theorem: intervalIntegral.integral_eq_zero_iff_of_nonneg_ae
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: cases' le_total a b with hab hab <;>
  simp only [Ioc_eq_empty hab.not_lt, empty_union, union_empty] at hf ⊢
state_before: ι : Type ?u.19452276
𝕜 : Type ?u.19452279
E : Type ?u.19452282
F : Type ?u.19452285
A : Type ?u.19452288
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hf : 0 ≤ᵐ[Measure.restrict μ (Ioc a b ∪ Ioc b a)] f
hfi : IntervalIntegrable f μ a b
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = 0 ↔ f =ᵐ[Measure.restrict μ (Ioc a b ∪ Ioc b a)] 0

tactic: exact integral_eq_zero_iff_of_le_of_nonneg_ae hab hf hfi
state_before: case inl
ι : Type ?u.19452276
𝕜 : Type ?u.19452279
E : Type ?u.19452282
F : Type ?u.19452285
A : Type ?u.19452288
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hfi : IntervalIntegrable f μ a b
hab : a ≤ b
hf : 0 ≤ᵐ[Measure.restrict μ (Ioc a b)] f
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = 0 ↔ f =ᵐ[Measure.restrict μ (Ioc a b)] 0

tactic: rw [integral_symm, neg_eq_zero, integral_eq_zero_iff_of_le_of_nonneg_ae hab hf hfi.symm]
state_before: case inr
ι : Type ?u.19452276
𝕜 : Type ?u.19452279
E : Type ?u.19452282
F : Type ?u.19452285
A : Type ?u.19452288
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hfi : IntervalIntegrable f μ a b
hab : b ≤ a
hf : 0 ≤ᵐ[Measure.restrict μ (Ioc b a)] f
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = 0 ↔ f =ᵐ[Measure.restrict μ (Ioc b a)] 0
Theorem: Fin.preimage_insertNth_Icc_of_mem
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp only [mem_preimage, insertNth_mem_Icc, hx, true_and_iff]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
q₁ q₂ : (j : Fin (n + 1)) → α j
hx : x ∈ Icc (q₁ i) (q₂ i)
p : (j : Fin n) → α (↑(succAbove i) j)
⊢ p ∈ insertNth i x ⁻¹' Icc q₁ q₂ ↔ p ∈ Icc (fun j => q₁ (↑(succAbove i) j)) fun j => q₂ (↑(succAbove i) j)
Theorem: dualTensorHomEquivOfBasis_symm_cancel_left
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: rw [← dualTensorHomEquivOfBasis_apply b,
  LinearEquiv.symm_apply_apply <| dualTensorHomEquivOfBasis (N := N) b]
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
x : Dual R M ⊗[R] N
⊢ ↑(LinearEquiv.symm (dualTensorHomEquivOfBasis b)) (↑(dualTensorHom R M N) x) = x
Theorem: MvPowerSeries.algebraMap_apply
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: change (MvPowerSeries.map σ (algebraMap R A)).comp (C σ R) r = _
state_before: σ : Type u_1
R : Type u_3
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
r : R
⊢ ↑(algebraMap R (MvPowerSeries σ A)) r = ↑(C σ A) (↑(algebraMap R A) r)

tactic: simp
state_before: σ : Type u_1
R : Type u_3
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
r : R
⊢ ↑(RingHom.comp (map σ (algebraMap R A)) (C σ R)) r = ↑(C σ A) (↑(algebraMap R A) r)
Theorem: List.Nodup.filter
File: Mathlib/Data/List/Nodup.lean

tactic: simpa using Pairwise.filter (fun a ↦ p a)
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
p : α → Bool
l : List α
⊢ Nodup l → Nodup (List.filter p l)
Theorem: Nat.div_le_of_le_mul'
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rw [k0, Nat.div_zero]
state_before: m n k l : ℕ
h : m ≤ k * n
k0 : k = 0
⊢ m / k ≤ n

tactic: apply zero_le
state_before: m n k l : ℕ
h : m ≤ k * n
k0 : k = 0
⊢ 0 ≤ n
Theorem: Polynomial.toFinsupp_X_pow
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [X_pow_eq_monomial, toFinsupp_monomial]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ (X ^ n).toFinsupp = Finsupp.single n 1
Theorem: Multiset.map_erase
File: Mathlib/Data/Multiset/Basic.lean

tactic: induction' s using Multiset.induction_on with y s ih
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.127295
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x : α
s : Multiset α
⊢ map f (erase s x) = erase (map f s) (f x)

tactic: by_cases hxy : y = x
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type ?u.127295
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (erase s x) = erase (map f s) (f x)
⊢ map f (erase (y ::ₘ s) x) = erase (map f (y ::ₘ s)) (f x)

tactic: simp
state_before: case empty
α : Type u_1
β : Type u_2
γ : Type ?u.127295
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x : α
⊢ map f (erase 0 x) = erase (map f 0) (f x)

tactic: cases hxy
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.127295
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (erase s x) = erase (map f s) (f x)
hxy : y = x
⊢ map f (erase (y ::ₘ s) x) = erase (map f (y ::ₘ s)) (f x)

tactic: simp
state_before: case pos.refl
α : Type u_1
β : Type u_2
γ : Type ?u.127295
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x : α
s : Multiset α
ih : map f (erase s x) = erase (map f s) (f x)
⊢ map f (erase (x ::ₘ s) x) = erase (map f (x ::ₘ s)) (f x)

tactic: rw [s.erase_cons_tail hxy, map_cons, map_cons, (s.map f).erase_cons_tail (hf.ne hxy), ih]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.127295
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y : α
s : Multiset α
ih : map f (erase s x) = erase (map f s) (f x)
hxy : ¬y = x
⊢ map f (erase (y ::ₘ s) x) = erase (map f (y ::ₘ s)) (f x)
Theorem: Real.rpow_zero_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp
state_before: x : ℝ
⊢ 0 < x ^ 0
Theorem: strictConvex_iff_div
File: Mathlib/Analysis/Convex/Strict.lean

tactic: apply h hx hy hxy (div_pos ha <| add_pos ha hb) (div_pos hb <| add_pos ha hb)
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.221625
E : Type u_2
F : Type ?u.221631
β : Type ?u.221634
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x✝ : E
h : StrictConvex 𝕜 s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
⊢ (a / (a + b)) • x + (b / (a + b)) • y ∈ interior s

tactic: rw [← add_div]
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.221625
E : Type u_2
F : Type ?u.221631
β : Type ?u.221634
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x✝ : E
h : StrictConvex 𝕜 s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
⊢ a / (a + b) + b / (a + b) = 1

tactic: exact div_self (add_pos ha hb).ne'
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.221625
E : Type u_2
F : Type ?u.221631
β : Type ?u.221634
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x✝ : E
h : StrictConvex 𝕜 s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
⊢ (a + b) / (a + b) = 1

tactic: convert h hx hy hxy ha hb <;> rw [hab, div_one]
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.221625
E : Type u_2
F : Type ?u.221631
β : Type ?u.221634
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x✝ : E
h : Set.Pairwise s fun x y => ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → (a / (a + b)) • x + (b / (a + b)) • y ∈ interior s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y ∈ interior s
Theorem: Submonoid.closure_inv
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: apply le_antisymm
state_before: α : Type ?u.59382
G : Type u_1
M : Type ?u.59388
R : Type ?u.59391
A : Type ?u.59394
inst✝² : Monoid M
inst✝¹ : AddMonoid A
s✝ t u : Set M
inst✝ : Group G
s : Set G
⊢ closure s⁻¹ = (closure s)⁻¹

tactic: rw [closure_le, coe_inv, ← Set.inv_subset, inv_inv]
state_before: case a
α : Type ?u.59382
G : Type u_1
M : Type ?u.59388
R : Type ?u.59391
A : Type ?u.59394
inst✝² : Monoid M
inst✝¹ : AddMonoid A
s✝ t u : Set M
inst✝ : Group G
s : Set G
⊢ closure s⁻¹ ≤ (closure s)⁻¹

tactic: exact subset_closure
state_before: case a
α : Type ?u.59382
G : Type u_1
M : Type ?u.59388
R : Type ?u.59391
A : Type ?u.59394
inst✝² : Monoid M
inst✝¹ : AddMonoid A
s✝ t u : Set M
inst✝ : Group G
s : Set G
⊢ s ⊆ ↑(closure s)

tactic: rw [inv_le, closure_le, coe_inv, ← Set.inv_subset]
state_before: case a
α : Type ?u.59382
G : Type u_1
M : Type ?u.59388
R : Type ?u.59391
A : Type ?u.59394
inst✝² : Monoid M
inst✝¹ : AddMonoid A
s✝ t u : Set M
inst✝ : Group G
s : Set G
⊢ (closure s)⁻¹ ≤ closure s⁻¹

tactic: exact subset_closure
state_before: case a
α : Type ?u.59382
G : Type u_1
M : Type ?u.59388
R : Type ?u.59391
A : Type ?u.59394
inst✝² : Monoid M
inst✝¹ : AddMonoid A
s✝ t u : Set M
inst✝ : Group G
s : Set G
⊢ s⁻¹ ⊆ ↑(closure s⁻¹)
Theorem: Fintype.univ_Prop
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α : Type ?u.126304
β : Type ?u.126307
γ : Type ?u.126310
⊢ univ.val = {True, False}.val

tactic: rfl
state_before: α : Type ?u.126304
β : Type ?u.126307
γ : Type ?u.126310
⊢ univ.val = True ::ₘ {False}
Theorem: Option.map_injective
File: Mathlib/Data/Option/Basic.lean

tactic: rw [Hf (Option.some.inj H)]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.798
δ : Type ?u.801
f : α → β
Hf : Function.Injective f
a₁ a₂ : α
H : Option.map f (some a₁) = Option.map f (some a₂)
⊢ some a₁ = some a₂
Theorem: Order.le_cof
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [cof, le_csInf_iff'' (cof_nonempty r)]
state_before: α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsRefl α r
c : Cardinal
⊢ c ≤ cof r ↔ ∀ {S : Set α}, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) → c ≤ (#↑S)

tactic: use fun H S h => H _ ⟨S, h, rfl⟩
state_before: α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsRefl α r
c : Cardinal
⊢ (∀ (b : Cardinal), b ∈ {c | ∃ S, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) ∧ (#↑S) = c} → c ≤ b) ↔
    ∀ {S : Set α}, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) → c ≤ (#↑S)

tactic: rintro H d ⟨S, h, rfl⟩
state_before: α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsRefl α r
c : Cardinal
⊢ (∀ {S : Set α}, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) → c ≤ (#↑S)) →
    ∀ (b : Cardinal), b ∈ {c | ∃ S, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) ∧ (#↑S) = c} → c ≤ b

tactic: exact H h
state_before: case intro.intro
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsRefl α r
c : Cardinal
H : ∀ {S : Set α}, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) → c ≤ (#↑S)
S : Set α
h : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
⊢ c ≤ (#↑S)
Theorem: CategoryTheory.StructuredArrow.projectSubobject_factors
File: Mathlib/CategoryTheory/Subobject/Comma.lean

tactic: dsimp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
⊢ (P.hom ≫ T.map (Subobject.underlyingIso (MonoOver.arrow (MonoOver.mk' f)).right).inv) ≫
      T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) =
    A.hom

tactic: simp [← T.map_comp]
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
⊢ (P.hom ≫ T.map (Subobject.underlyingIso f.right).inv) ≫ T.map (Subobject.arrow (Subobject.mk f.right)) = A.hom
Theorem: InitialSeg.acc
File: Mathlib/Order/InitialSeg.lean

tactic: refine' fun h => Acc.recOn h fun a _ ha => Acc.intro _ fun b hb => _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.24005
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a : α
⊢ Acc r a → Acc s (↑f a)

tactic: obtain ⟨a', rfl⟩ := f.init hb
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.24005
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a✝ : α
h : Acc r a✝
a : α
x✝ : ∀ (y : α), r y a → Acc r y
ha : ∀ (y : α), r y a → Acc s (↑f y)
b : β
hb : s b (↑f a)
⊢ Acc s b

tactic: exact ha _ (f.map_rel_iff.mp hb)
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.24005
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a✝ : α
h : Acc r a✝
a : α
x✝ : ∀ (y : α), r y a → Acc r y
ha : ∀ (y : α), r y a → Acc s (↑f y)
a' : α
hb : s (↑f a') (↑f a)
⊢ Acc s (↑f a')
Theorem: LieHom.idealRange_eq_map
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: ext
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ idealRange f = LieIdeal.map f ⊤

tactic: simp only [idealRange, range_eq_map]
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : L'
⊢ m✝ ∈ idealRange f ↔ m✝ ∈ LieIdeal.map f ⊤

tactic: rfl
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : L'
⊢ m✝ ∈ LieSubmodule.lieSpan R L' ↑(LieSubalgebra.map f ⊤) ↔ m✝ ∈ LieIdeal.map f ⊤
Theorem: Int.le_add_of_neg_add_le_left
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_comm] at h
state_before: a b c : Int
h : -b + a ≤ c
⊢ a ≤ b + c

tactic: exact Int.le_add_of_sub_left_le h
state_before: a b c : Int
h : a + -b ≤ c
⊢ a ≤ b + c
Theorem: mul_add_mul
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: have : a + b = a + b + (a * b + b * a) :=
  calc
    a + b = (a + b) * (a + b) := by rw [mul_self]
    _ = a * a + a * b + (b * a + b * b) := by rw [add_mul, mul_add, mul_add]
    _ = a + a * b + (b * a + b) := by simp only [mul_self]
    _ = a + b + (a * b + b * a) := by abel
state_before: α : Type u_1
β : Type ?u.4614
γ : Type ?u.4617
inst✝ : BooleanRing α
a b : α
⊢ a * b + b * a = 0

tactic: rwa [self_eq_add_right] at this
state_before: α : Type u_1
β : Type ?u.4614
γ : Type ?u.4617
inst✝ : BooleanRing α
a b : α
this : a + b = a + b + (a * b + b * a)
⊢ a * b + b * a = 0

tactic: rw [mul_self]
state_before: α : Type u_1
β : Type ?u.4614
γ : Type ?u.4617
inst✝ : BooleanRing α
a b : α
⊢ a + b = (a + b) * (a + b)

tactic: rw [add_mul, mul_add, mul_add]
state_before: α : Type u_1
β : Type ?u.4614
γ : Type ?u.4617
inst✝ : BooleanRing α
a b : α
⊢ (a + b) * (a + b) = a * a + a * b + (b * a + b * b)

tactic: simp only [mul_self]
state_before: α : Type u_1
β : Type ?u.4614
γ : Type ?u.4617
inst✝ : BooleanRing α
a b : α
⊢ a * a + a * b + (b * a + b * b) = a + a * b + (b * a + b)

tactic: abel
state_before: α : Type u_1
β : Type ?u.4614
γ : Type ?u.4617
inst✝ : BooleanRing α
a b : α
⊢ a + a * b + (b * a + b) = a + b + (a * b + b * a)
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ''
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ ↑Fin.castSucc j
⊢ δ X (Fin.succ j) ≫ δ X (Fin.castLT i (_ : ↑i < n + 2)) = δ X i ≫ δ X j

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ'' H]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ ↑Fin.castSucc j
⊢ X.map (SimplexCategory.δ (Fin.succ j)).op ≫ X.map (SimplexCategory.δ (Fin.castLT i (_ : ↑i < n + 2))).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.δ j).op
Theorem: CategoryTheory.IsPullback.of_horiz_isIso
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: refine'
  PullbackCone.IsLimit.mk _ (fun s => s.fst ≫ inv fst) (by aesop_cat)
    (fun s => _) (by aesop_cat)
state_before: C : Type u₁
inst✝² : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso fst
inst✝ : IsIso g
sq : CommSq fst snd f g
⊢ IsLimit (CommSq.cone sq)

tactic: simp only [← cancel_mono g, Category.assoc, ← sq.w, IsIso.inv_hom_id_assoc, s.condition]
state_before: C : Type u₁
inst✝² : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso fst
inst✝ : IsIso g
sq : CommSq fst snd f g
s : PullbackCone f g
⊢ (fun s => PullbackCone.fst s ≫ inv fst) s ≫ snd = PullbackCone.snd s

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso fst
inst✝ : IsIso g
sq : CommSq fst snd f g
⊢ ∀ (s : PullbackCone f g), (fun s => PullbackCone.fst s ≫ inv fst) s ≫ fst = PullbackCone.fst s

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso fst
inst✝ : IsIso g
sq : CommSq fst snd f g
⊢ ∀ (s : PullbackCone f g) (m : s.pt ⟶ P),
    m ≫ fst = PullbackCone.fst s → m ≫ snd = PullbackCone.snd s → m = (fun s => PullbackCone.fst s ≫ inv fst) s
Theorem: mem_nhds_uniformity_iff_left
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [uniformity_eq_symm, mem_nhds_uniformity_iff_right]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.58164
inst✝ : UniformSpace α
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ {p | p.snd = x → p.fst ∈ s} ∈ 𝓤 α

tactic: rfl
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.58164
inst✝ : UniformSpace α
x : α
s : Set α
⊢ {p | p.fst = x → p.snd ∈ s} ∈ 𝓤 α ↔ {p | p.snd = x → p.fst ∈ s} ∈ Prod.swap <$> 𝓤 α
Theorem: Submodule.map_zero
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simp [this, eq_comm]
state_before: R : Type u_3
R₁ : Type ?u.482742
R₂ : Type u_2
R₃ : Type ?u.482748
R₄ : Type ?u.482751
S : Type ?u.482754
K : Type ?u.482757
K₂ : Type ?u.482760
M : Type u_4
M' : Type ?u.482766
M₁ : Type ?u.482769
M₂ : Type u_1
M₃ : Type ?u.482775
M₄ : Type ?u.482778
N : Type ?u.482781
N₂ : Type ?u.482784
ι : Type ?u.482787
V : Type ?u.482790
V₂ : Type ?u.482793
inst✝¹⁴ : Semiring R
inst✝¹³ : Semiring R₂
inst✝¹² : Semiring R₃
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M'
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₂₁ : R₂ →+* R
inst✝³ : RingHomInvPair σ₁₂ σ₂₁
inst✝² : RingHomInvPair σ₂₁ σ₁₂
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p p' : Submodule R M
q q' : Submodule R₂ M₂
q₁ q₁' : Submodule R M'
r : R
x y : M
inst✝ : RingHomSurjective σ₁₂
F : Type ?u.483374
sc : SemilinearMapClass F σ₁₂ M M₂
this : ∃ x, x ∈ p
⊢ ∀ (x : M₂), x ∈ map 0 p ↔ x ∈ ⊥
Theorem: Nat.two_mul_odd_div_two
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: conv =>
  rhs
  rw [← Nat.mod_add_div n 2, hn, @add_tsub_cancel_left]
state_before: m n k l : ℕ
hn : n % 2 = 1
⊢ 2 * (n / 2) = n - 1
Theorem: LieModule.map_lowerCentralSeries_le
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
k : ℕ
f : M →ₗ⁅R,L⁆ M₂
⊢ LieSubmodule.map f (lowerCentralSeries R L M k) ≤ lowerCentralSeries R L M₂ k

tactic: simp only [Nat.zero_eq, lowerCentralSeries_zero, le_top]
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
f : M →ₗ⁅R,L⁆ M₂
⊢ LieSubmodule.map f (lowerCentralSeries R L M Nat.zero) ≤ lowerCentralSeries R L M₂ Nat.zero

tactic: simp only [LieModule.lowerCentralSeries_succ, LieSubmodule.map_bracket_eq]
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
f : M →ₗ⁅R,L⁆ M₂
k : ℕ
ih : LieSubmodule.map f (lowerCentralSeries R L M k) ≤ lowerCentralSeries R L M₂ k
⊢ LieSubmodule.map f (lowerCentralSeries R L M (Nat.succ k)) ≤ lowerCentralSeries R L M₂ (Nat.succ k)

tactic: exact LieSubmodule.mono_lie_right _ _ ⊤ ih
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
f : M →ₗ⁅R,L⁆ M₂
k : ℕ
ih : LieSubmodule.map f (lowerCentralSeries R L M k) ≤ lowerCentralSeries R L M₂ k
⊢ ⁅⊤, LieSubmodule.map f (lowerCentralSeries R L M k)⁆ ≤ ⁅⊤, lowerCentralSeries R L M₂ k⁆
Theorem: Polynomial.natDegree_eq_of_degree_eq
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: unfold natDegree
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : degree p = degree q
⊢ natDegree p = natDegree q

tactic: rw [h]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : degree p = degree q
⊢ WithBot.unbot' 0 (degree p) = WithBot.unbot' 0 (degree q)
Theorem: HasFDerivAtFilter.const_sub
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [sub_eq_add_neg] using hf.neg.const_add c
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.531341
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.531436
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasFDerivAtFilter f f' x L
c : F
⊢ HasFDerivAtFilter (fun x => c - f x) (-f') x L
Theorem: CategoryTheory.MonoidalCategory.unitors_inv_equal
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

tactic: coherence
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : MonoidalCategory C
⊢ (λ_ (𝟙_ C)).inv = (ρ_ (𝟙_ C)).inv
Theorem: mem_vectorSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [vectorSpan_pair, Submodule.mem_span_singleton]
state_before: k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.372847
p₁ p₂ : P
v : V
⊢ v ∈ vectorSpan k {p₁, p₂} ↔ ∃ r, r • (p₁ -ᵥ p₂) = v
Theorem: Even.isSquare_zpow
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨n, rfl⟩ a
state_before: F : Type ?u.50615
α : Type u_1
β : Type ?u.50621
R : Type ?u.50624
inst✝ : Group α
n : ℤ
⊢ Even n → ∀ (a : α), IsSquare (a ^ n)

tactic: exact ⟨a ^ n, zpow_add _ _ _⟩
state_before: case intro
F : Type ?u.50615
α : Type u_1
β : Type ?u.50621
R : Type ?u.50624
inst✝ : Group α
n : ℤ
a : α
⊢ IsSquare (a ^ (n + n))