tasksource/leandojo huggingface dataset:
Theorem: AlgebraicGeometry.StructureSheaf.to_global_factors
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [← Category.assoc]
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    CommRingCat.ofHom (algebraMap R (Localization.Away 1)) ≫
      toBasicOpen R 1 ≫ (structureSheaf R).val.map (eqToHom (_ : ⊤ = PrimeSpectrum.basicOpen 1)).op

tactic: change toOpen R ⊤ =
  (CommRingCat.ofHom <| (toBasicOpen R 1).comp (algebraMap R (Localization.Away 1))) ≫
  (structureSheaf R).1.map (eqToHom _).op
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    (CommRingCat.ofHom (algebraMap R (Localization.Away 1)) ≫ toBasicOpen R 1) ≫
      (structureSheaf R).val.map (eqToHom (_ : ⊤ = PrimeSpectrum.basicOpen 1)).op

tactic: unfold CommRingCat.ofHom
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    CommRingCat.ofHom (RingHom.comp (toBasicOpen R 1) (algebraMap R (Localization.Away 1))) ≫
      (structureSheaf R).val.map (eqToHom (_ : ⊤ = PrimeSpectrum.basicOpen 1)).op

tactic: rw [localization_toBasicOpen R, toOpen_res]
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    RingHom.comp (toBasicOpen R 1) (algebraMap R (Localization.Away 1)) ≫
      (structureSheaf R).val.map (eqToHom (_ : ⊤ = PrimeSpectrum.basicOpen 1)).op
Theorem: Finset.Nonempty.cSup_mem
File: Mathlib/Order/ConditionallyCompleteLattice/Finset.lean

tactic: rw [h.cSup_eq_max']
state_before: α : Type u_1
β : Type ?u.8944
γ : Type ?u.8947
inst✝ : ConditionallyCompleteLinearOrder α
s✝ t : Set α
a b : α
s : Finset α
h : Finset.Nonempty s
⊢ sSup ↑s ∈ s

tactic: exact s.max'_mem _
state_before: α : Type u_1
β : Type ?u.8944
γ : Type ?u.8947
inst✝ : ConditionallyCompleteLinearOrder α
s✝ t : Set α
a b : α
s : Finset α
h : Finset.Nonempty s
⊢ max' s h ∈ s
Theorem: biSup_prod
File: Mathlib/Order/CompleteLattice.lean

tactic: simp_rw [iSup_prod, mem_prod, iSup_and]
state_before: α : Type u_3
β : Type u_1
β₂ : Type ?u.166426
γ : Type u_2
ι : Sort ?u.166432
ι' : Sort ?u.166435
κ : ι → Sort ?u.166440
κ' : ι' → Sort ?u.166445
inst✝ : CompleteLattice α
f✝ g s✝ t✝ : ι → α
a b : α
f : β × γ → α
s : Set β
t : Set γ
⊢ (⨆ (x : β × γ) (_ : x ∈ s ×ˢ t), f x) = ⨆ (a : β) (_ : a ∈ s) (b : γ) (_ : b ∈ t), f (a, b)

tactic: exact iSup_congr fun _ => iSup_comm
state_before: α : Type u_3
β : Type u_1
β₂ : Type ?u.166426
γ : Type u_2
ι : Sort ?u.166432
ι' : Sort ?u.166435
κ : ι → Sort ?u.166440
κ' : ι' → Sort ?u.166445
inst✝ : CompleteLattice α
f✝ g s✝ t✝ : ι → α
a b : α
f : β × γ → α
s : Set β
t : Set γ
⊢ (⨆ (i : β) (j : γ) (_ : i ∈ s) (_ : j ∈ t), f (i, j)) = ⨆ (a : β) (_ : a ∈ s) (b : γ) (_ : b ∈ t), f (a, b)
Theorem: abs_pos
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rcases lt_trichotomy a 0 with (ha | rfl | ha)
state_before: α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ 0 < abs a ↔ a ≠ 0

tactic: simp [abs_of_neg ha, neg_pos, ha.ne, ha]
state_before: case inl
α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b c : α
ha : a < 0
⊢ 0 < abs a ↔ a ≠ 0

tactic: simp
state_before: case inr.inl
α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
b c : α
⊢ 0 < abs 0 ↔ 0 ≠ 0

tactic: simp [abs_of_pos ha, ha, ha.ne.symm]
state_before: case inr.inr
α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b c : α
ha : 0 < a
⊢ 0 < abs a ↔ a ≠ 0
Theorem: Combinatorics.Line.map_apply
File: Mathlib/Combinatorics/HalesJewett.lean

tactic: simp only [Line.apply, Line.map, Option.getD_map]
state_before: α : Type u_1
α' : Type u_2
ι : Type u_3
f : α → α'
l : Line α ι
x : α
⊢ (fun x i => Option.getD (idxFun (map f l) i) x) (f x) = f ∘ (fun x i => Option.getD (idxFun l i) x) x

tactic: rfl
state_before: α : Type u_1
α' : Type u_2
ι : Type u_3
f : α → α'
l : Line α ι
x : α
⊢ (fun i => f (Option.getD (idxFun l i) x)) = f ∘ fun i => Option.getD (idxFun l i) x
Theorem: BooleanRing.le_sup_inf
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: rw [le_sup_inf_aux, add_self, mul_self, zero_add]
state_before: α : Type u_1
β : Type ?u.18933
γ : Type ?u.18936
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ (a + b + a * b) * (a + c + a * c) + (a + b * c + a * (b * c)) +
      (a + b + a * b) * (a + c + a * c) * (a + b * c + a * (b * c)) =
    a + b * c + a * (b * c)
Theorem: Matrix.map_algebraMap
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [algebraMap_eq_diagonal, algebraMap_eq_diagonal, diagonal_map hf]
state_before: l : Type ?u.584026
m : Type ?u.584029
n : Type u_2
o : Type ?u.584035
m' : o → Type ?u.584040
n' : o → Type ?u.584045
R : Type u_1
S : Type ?u.584051
α : Type v
β : Type w
γ : Type ?u.584058
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommSemiring R
inst✝³ : Semiring α
inst✝² : Semiring β
inst✝¹ : Algebra R α
inst✝ : Algebra R β
r : R
f : α → β
hf : f 0 = 0
hf₂ : f (↑(algebraMap R α) r) = ↑(algebraMap R β) r
⊢ map (↑(algebraMap R (Matrix n n α)) r) f = ↑(algebraMap R (Matrix n n β)) r

tactic: simp only [Pi.algebraMap_apply, diagonal_eq_diagonal_iff]
state_before: l : Type ?u.584026
m : Type ?u.584029
n : Type u_2
o : Type ?u.584035
m' : o → Type ?u.584040
n' : o → Type ?u.584045
R : Type u_1
S : Type ?u.584051
α : Type v
β : Type w
γ : Type ?u.584058
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommSemiring R
inst✝³ : Semiring α
inst✝² : Semiring β
inst✝¹ : Algebra R α
inst✝ : Algebra R β
r : R
f : α → β
hf : f 0 = 0
hf₂ : f (↑(algebraMap R α) r) = ↑(algebraMap R β) r
⊢ (diagonal fun m => f (↑(algebraMap R (n → α)) r m)) = diagonal (↑(algebraMap R (n → β)) r)

tactic: intro
state_before: l : Type ?u.584026
m : Type ?u.584029
n : Type u_2
o : Type ?u.584035
m' : o → Type ?u.584040
n' : o → Type ?u.584045
R : Type u_1
S : Type ?u.584051
α : Type v
β : Type w
γ : Type ?u.584058
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommSemiring R
inst✝³ : Semiring α
inst✝² : Semiring β
inst✝¹ : Algebra R α
inst✝ : Algebra R β
r : R
f : α → β
hf : f 0 = 0
hf₂ : f (↑(algebraMap R α) r) = ↑(algebraMap R β) r
⊢ n → f (↑(algebraMap R α) r) = ↑(algebraMap R β) r

tactic: rw [hf₂]
state_before: l : Type ?u.584026
m : Type ?u.584029
n : Type u_2
o : Type ?u.584035
m' : o → Type ?u.584040
n' : o → Type ?u.584045
R : Type u_1
S : Type ?u.584051
α : Type v
β : Type w
γ : Type ?u.584058
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommSemiring R
inst✝³ : Semiring α
inst✝² : Semiring β
inst✝¹ : Algebra R α
inst✝ : Algebra R β
r : R
f : α → β
hf : f 0 = 0
hf₂ : f (↑(algebraMap R α) r) = ↑(algebraMap R β) r
i✝ : n
⊢ f (↑(algebraMap R α) r) = ↑(algebraMap R β) r
Theorem: Finset.uIcc_injective_left
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simpa only [uIcc_comm] using uIcc_injective_right a
state_before: ι : Type ?u.193752
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b b₁ b₂ c x a : α
⊢ Injective (uIcc a)
Theorem: Polynomial.coeff_mul_X_pow'
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: split_ifs with h
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
⊢ coeff (p * X ^ n) d = if n ≤ d then coeff p (d - n) else 0

tactic: rw [← tsub_add_cancel_of_le h, coeff_mul_X_pow, add_tsub_cancel_right]
state_before: case inl
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
h : n ≤ d
⊢ coeff (p * X ^ n) d = coeff p (d - n)

tactic: refine' (coeff_mul _ _ _).trans (Finset.sum_eq_zero fun x hx => _)
state_before: case inr
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
h : ¬n ≤ d
⊢ coeff (p * X ^ n) d = 0

tactic: rw [coeff_X_pow, if_neg, mul_zero]
state_before: case inr
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
h : ¬n ≤ d
x : ℕ × ℕ
hx : x ∈ Nat.antidiagonal d
⊢ coeff p x.fst * coeff (X ^ n) x.snd = 0

tactic: exact ((le_of_add_le_right (Finset.Nat.mem_antidiagonal.mp hx).le).trans_lt <| not_le.mp h).ne
state_before: case inr.hnc
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
h : ¬n ≤ d
x : ℕ × ℕ
hx : x ∈ Nat.antidiagonal d
⊢ ¬x.snd = n
Theorem: Submonoid.bot_or_nontrivial
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simp only [eq_bot_iff_forall, nontrivial_iff_exists_ne_one, ← not_forall, ← not_imp, Classical.em]
state_before: M : Type u_1
N : Type ?u.166126
P : Type ?u.166129
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S✝ : Submonoid M
A : Type ?u.166150
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
S : Submonoid M
⊢ S = ⊥ ∨ Nontrivial { x // x ∈ S }
Theorem: associated_one_iff_isUnit
File: Mathlib/Algebra/Associated.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type ?u.150247
γ : Type ?u.150250
δ : Type ?u.150253
inst✝ : Monoid α
a : α
x✝ : IsUnit a
c : αˣ
h : ↑c = a
⊢ 1 * ↑c = a
Theorem: min_div_div_left'
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: simp only [div_eq_mul_inv, min_mul_mul_left, min_inv_inv']
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ min (a / b) (a / c) = a / max b c
Theorem: IsLocalizedModule.mk'_add
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [mk'_add_mk', ← smul_add, mk'_cancel_left]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.847575
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s : { x // x ∈ S }
⊢ mk' f (m₁ + m₂) s = mk' f m₁ s + mk' f m₂ s
Theorem: Euclidean.isCompact_closedBall
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

tactic: rw [closedBall_eq_image]
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ IsCompact (closedBall x r)

tactic: exact (isCompact_closedBall _ _).image toEuclidean.symm.continuous
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ IsCompact (↑(ContinuousLinearEquiv.symm toEuclidean) '' Metric.closedBall (↑toEuclidean x) r)
Theorem: inner_map_complex
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← Complex.inner, f.inner_map_map]
state_before: 𝕜 : Type ?u.4079769
E : Type ?u.4079772
F : Type ?u.4079775
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : InnerProductSpace ℝ G
f : G ≃ₗᵢ[ℝ] ℂ
x y : G
⊢ inner x y = (↑(starRingEnd ℂ) (↑f x) * ↑f y).re
Theorem: Nat.choose_le_succ_of_lt_half_left
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: refine' le_of_mul_le_mul_right _ (lt_tsub_iff_left.mpr (lt_of_lt_of_le h (n.div_le_self 2)))
state_before: r n : ℕ
h : r < n / 2
⊢ choose n r ≤ choose n (r + 1)

tactic: rw [← choose_succ_right_eq]
state_before: r n : ℕ
h : r < n / 2
⊢ choose n r * (n - r) ≤ choose n (r + 1) * (n - r)

tactic: apply Nat.mul_le_mul_left
state_before: r n : ℕ
h : r < n / 2
⊢ choose n (r + 1) * (r + 1) ≤ choose n (r + 1) * (n - r)

tactic: rw [← Nat.lt_iff_add_one_le, lt_tsub_iff_left, ← mul_two]
state_before: case h
r n : ℕ
h : r < n / 2
⊢ r + 1 ≤ n - r

tactic: exact lt_of_lt_of_le (mul_lt_mul_of_pos_right h zero_lt_two) (n.div_mul_le_self 2)
state_before: case h
r n : ℕ
h : r < n / 2
⊢ r * 2 < n
Theorem: card_sylow_modEq_one
File: Mathlib/GroupTheory/Sylow.lean

tactic: refine' Sylow.nonempty.elim fun P : Sylow p G => _
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
⊢ card (Sylow p G) ≡ 1 [MOD p]

tactic: have : fixedPoints P.1 (Sylow p G) = {P} :=
  Set.ext fun Q : Sylow p G =>
    calc
      Q ∈ fixedPoints P (Sylow p G) ↔ P.1 ≤ Q := P.2.sylow_mem_fixedPoints_iff
      _ ↔ Q.1 = P.1 := ⟨P.3 Q.2, ge_of_eq⟩
      _ ↔ Q ∈ {P} := Sylow.ext_iff.symm.trans Set.mem_singleton_iff.symm
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
P : Sylow p G
⊢ card (Sylow p G) ≡ 1 [MOD p]

tactic: have fin : Fintype (fixedPoints P.1 (Sylow p G)) := by
  rw [this]
  infer_instance
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
P : Sylow p G
this : fixedPoints { x // x ∈ ↑P } (Sylow p G) = {P}
⊢ card (Sylow p G) ≡ 1 [MOD p]

tactic: have : card (fixedPoints P.1 (Sylow p G)) = 1 := by simp [this]
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
P : Sylow p G
this : fixedPoints { x // x ∈ ↑P } (Sylow p G) = {P}
fin : Fintype ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G))
⊢ card (Sylow p G) ≡ 1 [MOD p]

tactic: exact (P.2.card_modEq_card_fixedPoints (Sylow p G)).trans (by rw [this])
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
P : Sylow p G
this✝ : fixedPoints { x // x ∈ ↑P } (Sylow p G) = {P}
fin : Fintype ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G))
this : card ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G)) = 1
⊢ card (Sylow p G) ≡ 1 [MOD p]

tactic: rw [this]
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
P : Sylow p G
this : fixedPoints { x // x ∈ ↑P } (Sylow p G) = {P}
⊢ Fintype ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G))

tactic: infer_instance
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
P : Sylow p G
this : fixedPoints { x // x ∈ ↑P } (Sylow p G) = {P}
⊢ Fintype ↑{P}

tactic: simp [this]
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
P : Sylow p G
this : fixedPoints { x // x ∈ ↑P } (Sylow p G) = {P}
fin : Fintype ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G))
⊢ card ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G)) = 1

tactic: rw [this]
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype (Sylow p G)
P : Sylow p G
this✝ : fixedPoints { x // x ∈ ↑P } (Sylow p G) = {P}
fin : Fintype ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G))
this : card ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G)) = 1
⊢ card ↑(fixedPoints { x // x ∈ ↑P } (Sylow p G)) ≡ 1 [MOD p]
Theorem: iteratedFDeriv_tsum_apply
File: Mathlib/Analysis/Calculus/Series.lean

tactic: rw [iteratedFDeriv_tsum hf hv h'f hk]
state_before: α : Type u_4
β : Type ?u.117040
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
v : ℕ → α → ℝ
s : Set E
x₀ x✝ : E
N : ℕ∞
hf : ∀ (i : α), ContDiff 𝕜 N (f i)
hv : ∀ (k : ℕ), ↑k ≤ N → Summable (v k)
h'f : ∀ (k : ℕ) (i : α) (x : E), ↑k ≤ N → ‖iteratedFDeriv 𝕜 k (f i) x‖ ≤ v k i
k : ℕ
hk : ↑k ≤ N
x : E
⊢ iteratedFDeriv 𝕜 k (fun y => ∑' (n : α), f n y) x = ∑' (n : α), iteratedFDeriv 𝕜 k (f n) x
Theorem: pointed_innerDualCone
File: Mathlib/Analysis/Convex/Cone/Dual.lean

tactic: rw [inner_zero_right]
state_before: 𝕜 : Type ?u.9011
E : Type ?u.9014
F : Type ?u.9017
G : Type ?u.9020
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
x : H
x✝ : x ∈ s
⊢ 0 ≤ inner x 0
Theorem: Dfinsupp.neLocus_self_add_right
File: Mathlib/Data/Dfinsupp/NeLocus.lean

tactic: rw [← neLocus_zero_left, ← @neLocus_add_left α N _ _ _ f 0 g, add_zero]
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ neLocus f (f + g) = support g
Theorem: AlgebraicTopology.AlternatingFaceMapComplex.obj_d_eq
File: Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean

tactic: apply ChainComplex.of_d
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ Y X : SimplicialObject C
n : ℕ
⊢ HomologicalComplex.d (obj X) (n + 1) n = ∑ i : Fin (n + 2), (-1) ^ ↑i • SimplicialObject.δ X i
Theorem: Array.toListAppend_eq
File: Std/Data/Array/Init/Lemmas.lean

tactic: simp [toListAppend, foldr_eq_foldr_data]
state_before: α : Type u_1
arr : Array α
l : List α
⊢ toListAppend arr l = arr.data ++ l
Theorem: Cardinal.bddAbove_range
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rintro a ⟨i, rfl⟩
state_before: α β ι : Type u
f : ι → Cardinal
⊢ ?m.80685 f ∈ upperBounds (range f)

tactic: exact le_sum.{v,u} f i
state_before: case intro
α β ι : Type u
f : ι → Cardinal
i : ι
⊢ f i ≤ ?m.80685 f
Theorem: Ordinal.one_add_omega
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: refine' le_antisymm _ (le_add_left _ _)
state_before: α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ 1 + ω = ω

tactic: rw [omega, ← lift_one.{_, 0}, ← lift_add, lift_le, ← type_unit, ← type_sum_lex]
state_before: α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ 1 + ω ≤ ω

tactic: refine' ⟨RelEmbedding.collapse (RelEmbedding.ofMonotone _ _)⟩
state_before: α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ type (Sum.Lex EmptyRelation fun x x_1 => x < x_1) ≤ type fun x x_1 => x < x_1

tactic: apply Sum.rec
state_before: case refine'_1
α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ Unit ⊕ ℕ → ℕ

tactic: exact fun _ => 0
state_before: case refine'_1.inl
α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ Unit → ℕ

case refine'_1.inr
α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ℕ → ℕ

tactic: exact Nat.succ
state_before: case refine'_1.inr
α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ℕ → ℕ

tactic: intro a b
state_before: case refine'_2
α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ∀ (a b : Unit ⊕ ℕ),
    Sum.Lex EmptyRelation (fun x x_1 => x < x_1) a b → Sum.rec (fun x => 0) Nat.succ a < Sum.rec (fun x => 0) Nat.succ b

tactic: cases a <;> cases b <;> intro H <;> cases' H with _ _ H _ _ H <;>
  [exact H.elim; exact Nat.succ_pos _; exact Nat.succ_lt_succ H]
state_before: case refine'_2
α : Type ?u.134018
β : Type ?u.134021
γ : Type ?u.134024
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Unit ⊕ ℕ
⊢ Sum.Lex EmptyRelation (fun x x_1 => x < x_1) a b → Sum.rec (fun x => 0) Nat.succ a < Sum.rec (fun x => 0) Nat.succ b
Theorem: LinearMap.dualMap_bijective_iff
File: Mathlib/LinearAlgebra/Dual.lean

tactic: simp_rw [Function.Bijective, dualMap_surjective_iff, dualMap_injective_iff, and_comm]
state_before: K : Type u
inst✝⁵ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V₂
f : V₁ →ₗ[K] V₂
⊢ Function.Bijective ↑(dualMap f) ↔ Function.Bijective ↑f
Theorem: Set.image_neg_Ioi
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ Neg.neg '' Ioi a = Iio (-a)
Theorem: CategoryTheory.Limits.IsZero.iff_isSplitEpi_eq_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: rw [iff_id_eq_zero]
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ IsZero Y ↔ f = 0

tactic: constructor
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 Y = 0 ↔ f = 0

tactic: intro h
state_before: case mp
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 Y = 0 → f = 0

tactic: rw [← Category.comp_id f, h, comp_zero]
state_before: case mp
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
h : 𝟙 Y = 0
⊢ f = 0

tactic: intro h
state_before: case mpr
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ f = 0 → 𝟙 Y = 0

tactic: rw [← IsSplitEpi.id f]
state_before: case mpr
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
h : f = 0
⊢ 𝟙 Y = 0

tactic: simp [h]
state_before: case mpr
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
h : f = 0
⊢ section_ f ≫ f = 0
Theorem: CauSeq.sup_limZero
File: Mathlib/Data/Real/CauSeq.lean

tactic: let ⟨H₁, H₂⟩ := H _ ij
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g : CauSeq α abs
hf : LimZero f
hg : LimZero g
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abs (↑f j) < ε ∧ abs (↑g j) < ε
j : ℕ
ij : j ≥ i
⊢ abs (↑(f ⊔ g) j) < ε

tactic: rw [abs_lt] at H₁ H₂⊢
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g : CauSeq α abs
hf : LimZero f
hg : LimZero g
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abs (↑f j) < ε ∧ abs (↑g j) < ε
j : ℕ
ij : j ≥ i
H₁ : abs (↑f j) < ε
H₂ : abs (↑g j) < ε
⊢ abs (↑(f ⊔ g) j) < ε

tactic: exact ⟨lt_sup_iff.mpr (Or.inl H₁.1), sup_lt_iff.mpr ⟨H₁.2, H₂.2⟩⟩
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g : CauSeq α abs
hf : LimZero f
hg : LimZero g
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abs (↑f j) < ε ∧ abs (↑g j) < ε
j : ℕ
ij : j ≥ i
H₁ : -ε < ↑f j ∧ ↑f j < ε
H₂ : -ε < ↑g j ∧ ↑g j < ε
⊢ -ε < ↑(f ⊔ g) j ∧ ↑(f ⊔ g) j < ε
Theorem: Finpartition.card_parts_le_card
File: Mathlib/Order/Partition/Finpartition.lean

tactic: rw [← card_bot s]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P✝ P : Finpartition s
⊢ card P.parts ≤ card s

tactic: exact card_mono bot_le
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P✝ P : Finpartition s
⊢ card P.parts ≤ card ⊥.parts