tasksource/leandojo huggingface dataset:
Theorem: sSup_atoms_le_eq
File: Mathlib/Order/Atoms.lean

tactic: rcases eq_sSup_atoms b with ⟨s, rfl, hs⟩
state_before: α : Type u_1
β : Type ?u.19501
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
b : α
⊢ sSup {a | IsAtom a ∧ a ≤ b} = b

tactic: exact le_antisymm (sSup_le fun _ => And.right) (sSup_le_sSup fun a ha => ⟨hs a ha, le_sSup ha⟩)
state_before: case intro.intro
α : Type u_1
β : Type ?u.19501
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
s : Set α
hs : ∀ (a : α), a ∈ s → IsAtom a
⊢ sSup {a | IsAtom a ∧ a ≤ sSup s} = sSup s
Theorem: factorial_mul_pochhammer
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: rw_mod_cast [pochhammer_nat_eq_ascFactorial, Nat.factorial_mul_ascFactorial]
state_before: S✝ : Type ?u.29571
inst✝¹ : Semiring S✝
r✝ n✝ : ℕ
S : Type u_1
inst✝ : Semiring S
r n : ℕ
⊢ ↑r ! * eval (↑r + 1) (pochhammer S n) = ↑(r + n)!
Theorem: List.get_set
File: Std/Data/List/Lemmas.lean

tactic: if h : m = n then subst m; simp else simp [h]
state_before: α : Type u_1
a : α
m n : Nat
l : List α
h : n < length (set l m a)
⊢ get (set l m a) { val := n, isLt := h } = if m = n then a else get l { val := n, isLt := (_ : n < length l) }

tactic: subst m
state_before: α : Type u_1
a : α
m n : Nat
l : List α
h✝ : n < length (set l m a)
h : m = n
⊢ get (set l m a) { val := n, isLt := h✝ } = if m = n then a else get l { val := n, isLt := (_ : n < length l) }

tactic: simp
state_before: α : Type u_1
a : α
n : Nat
l : List α
h : n < length (set l n a)
⊢ get (set l n a) { val := n, isLt := h } = if n = n then a else get l { val := n, isLt := (_ : n < length l) }

tactic: simp [h]
state_before: α : Type u_1
a : α
m n : Nat
l : List α
h✝ : n < length (set l m a)
h : ¬m = n
⊢ get (set l m a) { val := n, isLt := h✝ } = if m = n then a else get l { val := n, isLt := (_ : n < length l) }
Theorem: String.Pos.zero_addString_byteIdx
File: Std/Data/String/Lemmas.lean

tactic: simp only [addString_byteIdx, byteIdx_zero, Nat.zero_add]
state_before: s : String
⊢ (0 + s).byteIdx = utf8ByteSize s
Theorem: Function.Antiperiodic.nat_odd_mul_antiperiodic
File: Mathlib/Algebra/Periodic.lean

tactic: rw [← add_assoc, h, h.periodic.nat_mul]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.148689
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : Semiring α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℕ
x : α
⊢ f (x + (↑n * (2 * c) + c)) = -f x
Theorem: LinearMap.compl₁₂_id_id
File: Mathlib/LinearAlgebra/BilinearMap.lean

tactic: ext
state_before: R : Type u_1
inst✝²³ : CommSemiring R
R₂ : Type ?u.481546
inst✝²² : CommSemiring R₂
R₃ : Type ?u.481552
inst✝²¹ : CommSemiring R₃
R₄ : Type ?u.481558
inst✝²⁰ : CommSemiring R₄
M : Type ?u.481564
N : Type ?u.481567
P : Type ?u.481570
Q : Type ?u.481573
Mₗ : Type u_2
Nₗ : Type u_4
Pₗ : Type u_3
Qₗ : Type ?u.481585
Qₗ' : Type ?u.481588
inst✝¹⁹ : AddCommMonoid M
inst✝¹⁸ : AddCommMonoid N
inst✝¹⁷ : AddCommMonoid P
inst✝¹⁶ : AddCommMonoid Q
inst✝¹⁵ : AddCommMonoid Mₗ
inst✝¹⁴ : AddCommMonoid Nₗ
inst✝¹³ : AddCommMonoid Pₗ
inst✝¹² : AddCommMonoid Qₗ
inst✝¹¹ : AddCommMonoid Qₗ'
inst✝¹⁰ : Module R M
inst✝⁹ : Module R₂ N
inst✝⁸ : Module R₃ P
inst✝⁷ : Module R₄ Q
inst✝⁶ : Module R Mₗ
inst✝⁵ : Module R Nₗ
inst✝⁴ : Module R Pₗ
inst✝³ : Module R Qₗ
inst✝² : Module R Qₗ'
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₄₂ : R₄ →+* R₂
σ₄₃ : R₄ →+* R₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : RingHomCompTriple σ₄₂ σ₂₃ σ₄₃
f✝ : M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P
f : Mₗ →ₗ[R] Nₗ →ₗ[R] Pₗ
⊢ compl₁₂ f id id = f

tactic: simp_rw [compl₁₂_apply, id_coe, id.def]
state_before: case h.h
R : Type u_1
inst✝²³ : CommSemiring R
R₂ : Type ?u.481546
inst✝²² : CommSemiring R₂
R₃ : Type ?u.481552
inst✝²¹ : CommSemiring R₃
R₄ : Type ?u.481558
inst✝²⁰ : CommSemiring R₄
M : Type ?u.481564
N : Type ?u.481567
P : Type ?u.481570
Q : Type ?u.481573
Mₗ : Type u_2
Nₗ : Type u_4
Pₗ : Type u_3
Qₗ : Type ?u.481585
Qₗ' : Type ?u.481588
inst✝¹⁹ : AddCommMonoid M
inst✝¹⁸ : AddCommMonoid N
inst✝¹⁷ : AddCommMonoid P
inst✝¹⁶ : AddCommMonoid Q
inst✝¹⁵ : AddCommMonoid Mₗ
inst✝¹⁴ : AddCommMonoid Nₗ
inst✝¹³ : AddCommMonoid Pₗ
inst✝¹² : AddCommMonoid Qₗ
inst✝¹¹ : AddCommMonoid Qₗ'
inst✝¹⁰ : Module R M
inst✝⁹ : Module R₂ N
inst✝⁸ : Module R₃ P
inst✝⁷ : Module R₄ Q
inst✝⁶ : Module R Mₗ
inst✝⁵ : Module R Nₗ
inst✝⁴ : Module R Pₗ
inst✝³ : Module R Qₗ
inst✝² : Module R Qₗ'
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₄₂ : R₄ →+* R₂
σ₄₃ : R₄ →+* R₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : RingHomCompTriple σ₄₂ σ₂₃ σ₄₃
f✝ : M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P
f : Mₗ →ₗ[R] Nₗ →ₗ[R] Pₗ
x✝¹ : Mₗ
x✝ : Nₗ
⊢ ↑(↑(compl₁₂ f id id) x✝¹) x✝ = ↑(↑f x✝¹) x✝
Theorem: SimpleGraph.Subgraph.deleteVerts_inter_verts_set_right_eq
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext <;> simp (config := { contextual := true }) [imp_false]
state_before: ι : Sort ?u.277333
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set V
⊢ deleteVerts G' (s ∩ G'.verts) = deleteVerts G' s
Theorem: EMetric.tendsto_nhdsWithin_nhdsWithin
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp
state_before: α : Type u
β : Type v
X : Type ?u.199771
inst✝¹ : PseudoEMetricSpace α
x✝² y z : α
ε✝ ε₁ ε₂ : ℝ≥0∞
s t✝ : Set α
inst✝ : PseudoEMetricSpace β
f : α → β
t : Set β
a : α
b : β
ε : ℝ≥0∞
x✝¹ : 0 < ε
δ : ℝ≥0∞
x✝ : 0 < δ
x : α
⊢ x ∈ ball a δ ∩ s → f x ∈ ball b ε ∩ t ↔ x ∈ s → edist x a < δ → f x ∈ t ∧ edist (f x) b < ε

tactic: tauto
state_before: α : Type u
β : Type v
X : Type ?u.199771
inst✝¹ : PseudoEMetricSpace α
x✝² y z : α
ε✝ ε₁ ε₂ : ℝ≥0∞
s t✝ : Set α
inst✝ : PseudoEMetricSpace β
f : α → β
t : Set β
a : α
b : β
ε : ℝ≥0∞
x✝¹ : 0 < ε
δ : ℝ≥0∞
x✝ : 0 < δ
x : α
⊢ edist x a < δ → x ∈ s → edist (f x) b < ε ∧ f x ∈ t ↔ x ∈ s → edist x a < δ → f x ∈ t ∧ edist (f x) b < ε
Theorem: HomotopyCategory.quotient_map_out_comp_out
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

tactic: simp
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomotopyCategory V c
f : C ⟶ D
g : D ⟶ E
⊢ (quotient V c).map (Quot.out f ≫ Quot.out g) = f ≫ g
Theorem: MeasureTheory.Integrable.withDensityᵥ_trim_absolutelyContinuous
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: refine' VectorMeasure.AbsolutelyContinuous.mk fun j hj₁ hj₂ => _
state_before: α : Type u_1
β : Type ?u.164970
m✝ : MeasurableSpace α
μ✝ ν : Measure α
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hfi : Integrable f
⊢ VectorMeasure.trim (withDensityᵥ μ f) hm ≪ᵥ toENNRealVectorMeasure (Measure.trim μ hm)

tactic: rw [Measure.toENNRealVectorMeasure_apply_measurable hj₁, trim_measurableSet_eq hm hj₁] at hj₂
state_before: α : Type u_1
β : Type ?u.164970
m✝ : MeasurableSpace α
μ✝ ν : Measure α
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hfi : Integrable f
j : Set α
hj₁ : MeasurableSet j
hj₂ : ↑(toENNRealVectorMeasure (Measure.trim μ hm)) j = 0
⊢ ↑(VectorMeasure.trim (withDensityᵥ μ f) hm) j = 0

tactic: rw [VectorMeasure.trim_measurableSet_eq hm hj₁, withDensityᵥ_apply hfi (hm _ hj₁)]
state_before: α : Type u_1
β : Type ?u.164970
m✝ : MeasurableSpace α
μ✝ ν : Measure α
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hfi : Integrable f
j : Set α
hj₁ : MeasurableSet j
hj₂ : ↑↑μ j = 0
⊢ ↑(VectorMeasure.trim (withDensityᵥ μ f) hm) j = 0

tactic: simp only [Measure.restrict_eq_zero.mpr hj₂, integral_zero_measure]
state_before: α : Type u_1
β : Type ?u.164970
m✝ : MeasurableSpace α
μ✝ ν : Measure α
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hfi : Integrable f
j : Set α
hj₁ : MeasurableSet j
hj₂ : ↑↑μ j = 0
⊢ (∫ (x : α) in j, f x ∂μ) = 0
Theorem: CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim_hom_π_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: dsimp [limitFlipCompLimIsoLimitCompLim]
state_before: J K : Type v
inst✝⁶ : SmallCategory J
inst✝⁵ : SmallCategory K
C : Type u
inst✝⁴ : Category C
F : J ⥤ K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape (J × K) C
inst✝ : HasLimitsOfShape (K × J) C
j : J
k : K
⊢ (limitFlipCompLimIsoLimitCompLim F).hom ≫ limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (Functor.flip F ⋙ lim) k ≫ limit.π ((Functor.flip F).obj k) j

tactic: simp
state_before: J K : Type v
inst✝⁶ : SmallCategory J
inst✝⁵ : SmallCategory K
C : Type u
inst✝⁴ : Category C
F : J ⥤ K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape (J × K) C
inst✝ : HasLimitsOfShape (K × J) C
j : J
k : K
⊢ ((limitUncurryIsoLimitCompLim (Functor.flip F)).inv ≫
        (HasLimit.isoOfNatIso (uncurryObjFlip F)).hom ≫
          (HasLimit.isoOfEquivalence (Prod.braiding K J)
                (NatIso.ofComponents fun x => Iso.refl ((F.obj x.snd).obj x.fst))).hom ≫
            (limitUncurryIsoLimitCompLim F).hom) ≫
      limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (Functor.flip F ⋙ lim) k ≫ limit.π ((Functor.flip F).obj k) j
Theorem: Fin.predAbove_left_monotone
File: Mathlib/Data/Fin/Basic.lean

tactic: dsimp [predAbove]
state_before: n m : ℕ
i : Fin (n + 1)
a b : Fin n
H : a ≤ b
⊢ (fun p => predAbove p i) a ≤ (fun p => predAbove p i) b

tactic: split_ifs with ha hb hb
state_before: n m : ℕ
i : Fin (n + 1)
a b : Fin n
H : a ≤ b
⊢ (if h : ↑castSucc a < i then pred i (_ : i ≠ 0) else castLT i (_ : ↑i < n)) ≤
    if h : ↑castSucc b < i then pred i (_ : i ≠ 0) else castLT i (_ : ↑i < n)

tactic: rfl
state_before: case inl.inl
n m : ℕ
i : Fin (n + 1)
a b : Fin n
H : a ≤ b
ha : ↑castSucc a < i
hb : ↑castSucc b < i
⊢ pred i (_ : i ≠ 0) ≤ pred i (_ : i ≠ 0)

tactic: exact pred_le _
state_before: case inl.inr
n m : ℕ
i : Fin (n + 1)
a b : Fin n
H : a ≤ b
ha : ↑castSucc a < i
hb : ¬↑castSucc b < i
⊢ pred i (_ : i ≠ 0) ≤ castLT i (_ : ↑i < n)

tactic: have : b < a := castSucc_lt_castSucc_iff.mpr (hb.trans_le (le_of_not_gt ha))
state_before: case inr.inl
n m : ℕ
i : Fin (n + 1)
a b : Fin n
H : a ≤ b
ha : ¬↑castSucc a < i
hb : ↑castSucc b < i
⊢ castLT i (_ : ↑i < n) ≤ pred i (_ : i ≠ 0)

tactic: exact absurd H this.not_le
state_before: case inr.inl
n m : ℕ
i : Fin (n + 1)
a b : Fin n
H : a ≤ b
ha : ¬↑castSucc a < i
hb : ↑castSucc b < i
this : b < a
⊢ castLT i (_ : ↑i < n) ≤ pred i (_ : i ≠ 0)

tactic: rfl
state_before: case inr.inr
n m : ℕ
i : Fin (n + 1)
a b : Fin n
H : a ≤ b
ha : ¬↑castSucc a < i
hb : ¬↑castSucc b < i
⊢ castLT i (_ : ↑i < n) ≤ castLT i (_ : ↑i < n)
Theorem: CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: simp [Iso.comp_inv_eq]
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ coprod.inl ≫ (pushoutZeroZeroIso X Y).inv = pushout.inl
Theorem: Pi.basisFun_apply
File: Mathlib/LinearAlgebra/StdBasis.lean

tactic: simp only [basisFun, Basis.coe_ofEquivFun, LinearEquiv.refl_symm, LinearEquiv.refl_apply,
  stdBasis_apply]
state_before: R : Type u_2
η : Type u_1
ιs : η → Type ?u.154579
Ms : η → Type ?u.154584
inst✝⁴ : Semiring R
inst✝³ : (i : η) → AddCommMonoid (Ms i)
inst✝² : (i : η) → Module R (Ms i)
inst✝¹ : Fintype η
inst✝ : DecidableEq η
i : η
⊢ ↑(basisFun R η) i = ↑(stdBasis R (fun x => R) i) 1
Theorem: IntermediateField.exists_finset_of_mem_supr'
File: Mathlib/FieldTheory/Adjoin.lean

tactic: refine' exists_finset_of_mem_iSup (SetLike.le_def.mp (iSup_le (fun i => _)) hx)
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_1
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ (i : ι), f i
⊢ ∃ s, x ∈ ⨆ (i : (i : ι) × { x // x ∈ f i }) (_ : i ∈ s), F⟮↑i.snd⟯

tactic: intro x h
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_1
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ (i : ι), f i
i : ι
⊢ f i ≤ ⨆ (i : (i : ι) × { x // x ∈ f i }), F⟮↑i.snd⟯

tactic: exact SetLike.le_def.mp (le_iSup_of_le ⟨i, x, h⟩ (by simp)) (mem_adjoin_simple_self F x)
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_1
f : ι → IntermediateField F E
x✝ : E
hx : x✝ ∈ ⨆ (i : ι), f i
i : ι
x : E
h : x ∈ f i
⊢ x ∈ ⨆ (i : (i : ι) × { x // x ∈ f i }), F⟮↑i.snd⟯

tactic: simp
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_1
f : ι → IntermediateField F E
x✝ : E
hx : x✝ ∈ ⨆ (i : ι), f i
i : ι
x : E
h : x ∈ f i
⊢ F⟮x⟯ ≤ F⟮↑{ fst := i, snd := { val := x, property := h } }.snd⟯
Theorem: Mathlib.Meta.NormNum.isRat_ofScientific_of_true
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp only [σh, Rat.ofScientific_true_def]
state_before: α : Type u_1
inst✝ : DivisionRing α
σα : OfScientific α
x✝¹ x✝ : ℕ
num✝ : ℤ
denom✝ : ℕ
σh : OfScientific.ofScientific = fun m s e => ↑(Rat.ofScientific m s e)
inv✝ : Invertible ↑denom✝
eq : ↑(mkRat (↑x✝¹) (10 ^ x✝)) = ↑num✝ * ⅟↑denom✝
⊢ OfScientific.ofScientific x✝¹ true x✝ = ↑num✝ * ⅟↑denom✝

tactic: exact eq
state_before: α : Type u_1
inst✝ : DivisionRing α
σα : OfScientific α
x✝¹ x✝ : ℕ
num✝ : ℤ
denom✝ : ℕ
σh : OfScientific.ofScientific = fun m s e => ↑(Rat.ofScientific m s e)
inv✝ : Invertible ↑denom✝
eq : ↑(mkRat (↑x✝¹) (10 ^ x✝)) = ↑num✝ * ⅟↑denom✝
⊢ ↑(mkRat (↑x✝¹) (10 ^ x✝)) = ↑num✝ * ⅟↑denom✝
Theorem: Ordnode.balancedSz_zero
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: simp (config := { contextual := true }) [BalancedSz]
state_before: α : Type ?u.7958
l : ℕ
⊢ BalancedSz l 0 ↔ l ≤ 1
Theorem: Real.cauchy_sub
File: Mathlib/Data/Real/Basic.lean

tactic: rw [sub_eq_add_neg, ← cauchy_neg, ← cauchy_add]
state_before: x y : ℝ
a b : Cauchy abs
⊢ ({ cauchy := a } - { cauchy := b }).cauchy = { cauchy := a }.cauchy - { cauchy := b }.cauchy

tactic: rfl
state_before: x y : ℝ
a b : Cauchy abs
⊢ ({ cauchy := a } - { cauchy := b }).cauchy = ({ cauchy := a } + -{ cauchy := b }).cauchy
Theorem: mul_add_eq_mul_add_iff_sub_mul_add_eq
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simp [add_comm]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
⊢ a * e + c = b * e + d ↔ a * e + c = d + b * e

tactic: rw [h]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
h : a * e + c = d + b * e
⊢ a * e + c - b * e = d

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
h : a * e + c = d + b * e
⊢ d + b * e - b * e = d

tactic: rw [← h]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
h : a * e + c - b * e = d
⊢ a * e + c = d + b * e

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
h : a * e + c - b * e = d
⊢ a * e + c = a * e + c - b * e + b * e

tactic: simp [sub_mul, sub_add_eq_add_sub]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c d e : α
⊢ a * e + c - b * e = d ↔ (a - b) * e + c = d
Theorem: WithTop.image_coe_Ioc
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← preimage_coe_Ioc, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left
    (Subset.trans Ioc_subset_Iic_self <| Iic_subset_Iio.2 <| coe_lt_top b)]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some '' Ioc a b = Ioc ↑a ↑b
Theorem: CategoryTheory.isSeparator_coprod_of_isSeparator_right
File: Mathlib/CategoryTheory/Generator.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
G H : C
inst✝ : HasBinaryCoproduct G H
hH : IsSeparator H
⊢ {H} ⊆ {G, H}
Theorem: Ordinal.dvd_of_mod_eq_zero
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa [H] using (div_add_mod a b).symm
state_before: α : Type ?u.262049
β : Type ?u.262052
γ : Type ?u.262055
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
H : a % b = 0
⊢ a = b * (a / b)
Theorem: spectrum.sub_singleton_eq
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: simpa only [neg_sub, neg_eq] using congr_arg Neg.neg (singleton_sub_eq a r)
state_before: R : Type u
A : Type v
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
r : R
⊢ σ a - {r} = σ (a - ↑↑ₐ r)
Theorem: coe_upperClosure
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.123224
γ : Type ?u.123227
ι : Sort ?u.123230
κ : ι → Sort ?u.123235
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
⊢ ↑(upperClosure s) = ⋃ (a : α) (_ : a ∈ s), Ici a

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.123224
γ : Type ?u.123227
ι : Sort ?u.123230
κ : ι → Sort ?u.123235
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
x✝ : α
⊢ x✝ ∈ ↑(upperClosure s) ↔ x✝ ∈ ⋃ (a : α) (_ : a ∈ s), Ici a
Theorem: Polynomial.eq_X_sub_C_of_splits_of_single_root
File: Mathlib/Data/Polynomial/Splits.lean

tactic: apply Polynomial.map_injective _ i.injective
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
x : K
h : K[X]
h_splits : Splits i h
h_roots : roots (map i h) = {↑i x}
⊢ h = ↑C (leadingCoeff h) * (X - ↑C x)

tactic: rw [eq_prod_roots_of_splits h_splits, h_roots]
state_before: case a
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
x : K
h : K[X]
h_splits : Splits i h
h_roots : roots (map i h) = {↑i x}
⊢ map i h = map i (↑C (leadingCoeff h) * (X - ↑C x))

tactic: simp
state_before: case a
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
x : K
h : K[X]
h_splits : Splits i h
h_roots : roots (map i h) = {↑i x}
⊢ ↑C (↑i (leadingCoeff h)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) {↑i x}) =
    map i (↑C (leadingCoeff h) * (X - ↑C x))
Theorem: Cardinal.mk_set
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp [←one_add_one_eq_two, Set, mk_arrow]
state_before: α✝ β α : Type u
⊢ (#Set α) = 2 ^ (#α)
Theorem: CategoryTheory.InjectiveResolution.homotopyEquiv_inv_ι
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

tactic: simp [homotopyEquiv]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X : C
I J : InjectiveResolution X
⊢ J.ι ≫ (homotopyEquiv I J).inv = I.ι
Theorem: Asymptotics.IsEquivalent.sub_isLittleO
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: simpa only [sub_eq_add_neg] using huv.add_isLittleO hwv.neg_left
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hwv : w =o[l] v
⊢ u - w ~[l] v
Theorem: Nat.perm_factors_mul_of_coprime
File: Mathlib/Data/Nat/Factors.lean

tactic: rcases a.eq_zero_or_pos with (rfl | ha)
state_before: a b : ℕ
hab : coprime a b
⊢ factors (a * b) ~ factors a ++ factors b

tactic: rcases b.eq_zero_or_pos with (rfl | hb)
state_before: case inr
a b : ℕ
hab : coprime a b
ha : a > 0
⊢ factors (a * b) ~ factors a ++ factors b

tactic: exact perm_factors_mul ha.ne' hb.ne'
state_before: case inr.inr
a b : ℕ
hab : coprime a b
ha : a > 0
hb : b > 0
⊢ factors (a * b) ~ factors a ++ factors b

tactic: simp [(coprime_zero_left _).mp hab]
state_before: case inl
b : ℕ
hab : coprime 0 b
⊢ factors (0 * b) ~ factors 0 ++ factors b

tactic: simp [(coprime_zero_right _).mp hab]
state_before: case inr.inl
a : ℕ
ha : a > 0
hab : coprime a 0
⊢ factors (a * 0) ~ factors a ++ factors 0
Theorem: Polynomial.natDegree_multiset_prod_X_sub_C_eq_card
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [natDegree_multiset_prod_of_monic, Multiset.map_map]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ natDegree (prod (Multiset.map (fun a => X - ↑C a) s)) = ↑Multiset.card s

tactic: exact Multiset.forall_mem_map_iff.2 fun a _ => monic_X_sub_C a
state_before: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ ∀ (f : R[X]), f ∈ Multiset.map (fun a => X - ↑C a) s → Monic f
Theorem: Finpartition.isEquipartition_iff_card_parts_eq_average
File: Mathlib/Order/Partition/Equipartition.lean

tactic: simp_rw [IsEquipartition, Finset.equitableOn_iff, P.sum_card_parts]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
⊢ IsEquipartition P ↔
    ∀ (a : Finset α),
      a ∈ P.parts →
        Finset.card a = Finset.card s / Finset.card P.parts ∨ Finset.card a = Finset.card s / Finset.card P.parts + 1
Theorem: Real.sInf_smul_of_nonneg
File: Mathlib/Data/Real/Pointwise.lean

tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: ι : Sort ?u.200
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
⊢ sInf (a • s) = a • sInf s

tactic: obtain rfl | ha' := ha.eq_or_lt
state_before: case inr
ι : Sort ?u.200
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : Set.Nonempty s
⊢ sInf (a • s) = a • sInf s

tactic: by_cases h : BddBelow s
state_before: case inr.inr
ι : Sort ?u.200
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : Set.Nonempty s
ha' : 0 < a
⊢ sInf (a • s) = a • sInf s

tactic: rw [smul_set_empty, Real.sInf_empty, smul_zero]
state_before: case inl
ι : Sort ?u.200
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
⊢ sInf (a • ∅) = a • sInf ∅

tactic: rw [zero_smul_set hs, zero_smul]
state_before: case inr.inl
ι : Sort ?u.200
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
s : Set ℝ
hs : Set.Nonempty s
ha : 0 ≤ 0
⊢ sInf (0 • s) = 0 • sInf s

tactic: exact csInf_singleton 0
state_before: case inr.inl
ι : Sort ?u.200
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
s : Set ℝ
hs : Set.Nonempty s
ha : 0 ≤ 0
⊢ sInf 0 = 0

tactic: exact ((OrderIso.smulLeft ℝ ha').map_csInf' hs h).symm
state_before: case pos
ι : Sort ?u.200
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : Set.Nonempty s
ha' : 0 < a
h : BddBelow s
⊢ sInf (a • s) = a • sInf s

tactic: rw [Real.sInf_of_not_bddBelow (mt (bddBelow_smul_iff_of_pos ha').1 h),
    Real.sInf_of_not_bddBelow h, smul_zero]
state_before: case neg
ι : Sort ?u.200
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : Set.Nonempty s
ha' : 0 < a
h : ¬BddBelow s
⊢ sInf (a • s) = a • sInf s
Theorem: List.get_zero_scanl
File: Mathlib/Data/List/Basic.lean

tactic: cases l
state_before: ι : Type ?u.240201
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : β → α → β
b : β
a : α
l : List α
h : 0 < length (scanl f b l)
⊢ get (scanl f b l) { val := 0, isLt := h } = b

tactic: simp only [get, scanl_nil]
state_before: case nil
ι : Type ?u.240201
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : β → α → β
b : β
a : α
h : 0 < length (scanl f b [])
⊢ get (scanl f b []) { val := 0, isLt := h } = b

tactic: simp only [get, scanl_cons, singleton_append]
state_before: case cons
ι : Type ?u.240201
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : β → α → β
b : β
a head✝ : α
tail✝ : List α
h : 0 < length (scanl f b (head✝ :: tail✝))
⊢ get (scanl f b (head✝ :: tail✝)) { val := 0, isLt := h } = b