tasksource/leandojo huggingface dataset:
Theorem: Uniform.continuousAt_iff'_left
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [ContinuousAt, tendsto_nhds_left]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.197442
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
b : β
⊢ ContinuousAt f b ↔ Tendsto (fun x => (f x, f b)) (𝓝 b) (𝓤 α)
Theorem: CategoryTheory.Abelian.image_ι_comp_eq_zero
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: simp [h]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
R : C
g : Q ⟶ R
h : f ≫ g = 0
⊢ Abelian.factorThruImage f ≫ image.ι f ≫ g = 0
Theorem: parallelogram_law_with_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [← @inner_self_eq_norm_mul_norm 𝕜]
state_before: 𝕜 : Type ?u.2512953
E : Type u_1
F : Type ?u.2512959
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ‖x + y‖ * ‖x + y‖ + ‖x - y‖ * ‖x - y‖ = 2 * (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖)

tactic: rw [← re.map_add, parallelogram_law, two_mul, two_mul]
state_before: 𝕜 : Type ?u.2512953
E : Type u_1
F : Type ?u.2512959
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner (x + y) (x + y)) + ↑re (inner (x - y) (x - y)) = 2 * (↑re (inner x x) + ↑re (inner y y))

tactic: simp only [re.map_add]
state_before: 𝕜 : Type ?u.2512953
E : Type u_1
F : Type ?u.2512959
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner x x + inner y y + (inner x x + inner y y)) =
    ↑re (inner x x) + ↑re (inner y y) + (↑re (inner x x) + ↑re (inner y y))
Theorem: Set.neg_smul
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp_rw [← image_neg]
state_before: F : Type ?u.223934
α : Type u_2
β : Type u_1
γ : Type ?u.223943
inst✝² : Ring α
inst✝¹ : AddCommGroup β
inst✝ : Module α β
a : α
s : Set α
t : Set β
⊢ -s • t = -(s • t)

tactic: exact image2_image_left_comm neg_smul
state_before: F : Type ?u.223934
α : Type u_2
β : Type u_1
γ : Type ?u.223943
inst✝² : Ring α
inst✝¹ : AddCommGroup β
inst✝ : Module α β
a : α
s : Set α
t : Set β
⊢ Neg.neg '' s • t = Neg.neg '' (s • t)
Theorem: FractionalIdeal.spanSingleton_div_spanSingleton
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [div_spanSingleton, mul_comm, spanSingleton_mul_spanSingleton, div_eq_mul_inv]
state_before: R : Type ?u.42527
A : Type ?u.42530
K : Type u_1
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
R₁ : Type u_2
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type ?u.43541
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x y : K
⊢ spanSingleton R₁⁰ x / spanSingleton R₁⁰ y = spanSingleton R₁⁰ (x / y)
Theorem: Set.SurjOn.invOn_invFunOn
File: Mathlib/Data/Set/Function.lean

tactic: refine' ⟨_, h.rightInvOn_invFunOn⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.67189
ι : Sort ?u.67192
π : α → Type ?u.67197
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ InvOn (invFunOn f s) f (invFunOn f s '' t) t

tactic: rintro _ ⟨y, hy, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.67189
ι : Sort ?u.67192
π : α → Type ?u.67197
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ LeftInvOn (invFunOn f s) f (invFunOn f s '' t)

tactic: rw [h.rightInvOn_invFunOn hy]
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.67189
ι : Sort ?u.67192
π : α → Type ?u.67197
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
y : β
hy : y ∈ t
⊢ invFunOn f s (f (invFunOn f s y)) = invFunOn f s y
Theorem: WithTop.coe_sInf
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [coe_sInf' hs, sInf_image]
state_before: α : Type u_1
β : Type ?u.95849
γ : Type ?u.95852
ι : Sort ?u.95855
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set α
hs : Set.Nonempty s
⊢ ↑(sInf s) = ⨅ (a : α) (_ : a ∈ s), ↑a
Theorem: hasSum_subtype_iff_indicator
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [← Set.indicator_range_comp, Subtype.range_coe,
  hasSum_subtype_iff_of_support_subset Set.support_indicator_subset]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.29909
δ : Type ?u.29912
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s✝ : Finset β
s : Set β
⊢ HasSum (f ∘ Subtype.val) a ↔ HasSum (Set.indicator s f) a
Theorem: uniformity_dist_of_mem_uniformity
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp only [H, subset_def, Prod.forall, mem_setOf]
state_before: α : Type u
β : Type v
X : Type ?u.13
inst✝ : LinearOrder β
U : Filter (α × α)
z : β
D : α → α → β
H : ∀ (s : Set (α × α)), s ∈ U ↔ ∃ ε, ε > z ∧ ∀ {a b : α}, D a b < ε → (a, b) ∈ s
s : Set (α × α)
⊢ s ∈ U ↔ ∃ i, i > z ∧ {p | D p.fst p.snd < i} ⊆ s
Theorem: MeasureTheory.Content.mono
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: simp [apply_eq_coe_toFun, μ.mono' _ _ h]
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ ↑K₂
⊢ (fun s => ↑(toFun μ s)) K₁ ≤ (fun s => ↑(toFun μ s)) K₂
Theorem: Filter.pi_eq_bot
File: Mathlib/Order/Filter/Pi.lean

tactic: simpa using @pi_inf_principal_univ_pi_eq_bot ι α f fun _ => univ
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
⊢ pi f = ⊥ ↔ ∃ i, f i = ⊥
Theorem: nndist_vsub_vsub_le
File: Mathlib/Analysis/Normed/Group/AddTorsor.lean

tactic: simp only [← NNReal.coe_le_coe, NNReal.coe_add, ← dist_nndist, (dist_vsub_vsub_le)]
state_before: α : Type ?u.25622
V : Type u_1
P : Type u_2
W : Type ?u.25631
Q : Type ?u.25634
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ nndist p₁ p₃ + nndist p₂ p₄
Theorem: List.head?_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: rw [← get?_zero, get?_rotate (n.zero_le.trans_lt h), zero_add, Nat.mod_eq_of_lt h]
state_before: α : Type u
l : List α
n : ℕ
h : n < length l
⊢ head? (rotate l n) = get? l n
Theorem: irrational_mul_nat_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_coe_nat, irrational_mul_rat_iff, Nat.cast_ne_zero]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (x * ↑n) ↔ n ≠ 0 ∧ Irrational x
Theorem: Ordinal.typein_lt_self
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp_rw [← type_lt o]
state_before: α : Type ?u.71541
β : Type ?u.71544
γ : Type ?u.71547
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
i : (Quotient.out o).α
⊢ typein (fun x x_1 => x < x_1) i < o

tactic: apply typein_lt_type
state_before: α : Type ?u.71541
β : Type ?u.71544
γ : Type ?u.71547
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
i : (Quotient.out o).α
⊢ typein (fun x x_1 => x < x_1) i < type fun x x_1 => x < x_1
Theorem: Filter.subtype_coe_map_comap
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [map_comap, Subtype.range_coe]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.258805
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
f : Filter α
⊢ map Subtype.val (comap Subtype.val f) = f ⊓ 𝓟 s
Theorem: DirectSum.Decomposition.inductionOn
File: Mathlib/Algebra/DirectSum/Decomposition.lean

tactic: let ℳ' : ι → AddSubmonoid M := fun i ↦
  (⟨⟨ℳ i, fun x y ↦ AddMemClass.add_mem x y⟩, (ZeroMemClass.zero_mem _)⟩ : AddSubmonoid M)
state_before: ι : Type ?u.49490
R : Type ?u.49493
M : Type u_1
σ : Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : AddCommMonoid M
inst✝² : SetLike σ M
inst✝¹ : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝ : Decomposition ℳ
p : M → Prop
h_zero : p 0
h_homogeneous : ∀ {i : ι} (m : { x // x ∈ ℳ i }), p ↑m
h_add : ∀ (m m' : M), p m → p m' → p (m + m')
⊢ ∀ (m : M), p m

tactic: haveI t : DirectSum.Decomposition ℳ' :=
  { decompose' := DirectSum.decompose ℳ
    left_inv := fun _ ↦ (decompose ℳ).left_inv _
    right_inv := fun _ ↦ (decompose ℳ).right_inv _ }
state_before: ι : Type ?u.49490
R : Type ?u.49493
M : Type u_1
σ : Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : AddCommMonoid M
inst✝² : SetLike σ M
inst✝¹ : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝ : Decomposition ℳ
p : M → Prop
h_zero : p 0
h_homogeneous : ∀ {i : ι} (m : { x // x ∈ ℳ i }), p ↑m
h_add : ∀ (m m' : M), p m → p m' → p (m + m')
ℳ' : ι → AddSubmonoid M :=
  fun i =>
    { toAddSubsemigroup := { carrier := ↑(ℳ i), add_mem' := (_ : ∀ {a b : M}, a ∈ ↑(ℳ i) → b ∈ ↑(ℳ i) → a + b ∈ ℳ i) },
      zero_mem' := (_ : 0 ∈ ℳ i) }
⊢ ∀ (m : M), p m

tactic: have mem : ∀ m, m ∈ iSup ℳ' := fun _m ↦
  (DirectSum.IsInternal.addSubmonoid_iSup_eq_top ℳ' (Decomposition.isInternal ℳ')).symm ▸ trivial
state_before: ι : Type ?u.49490
R : Type ?u.49493
M : Type u_1
σ : Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : AddCommMonoid M
inst✝² : SetLike σ M
inst✝¹ : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝ : Decomposition ℳ
p : M → Prop
h_zero : p 0
h_homogeneous : ∀ {i : ι} (m : { x // x ∈ ℳ i }), p ↑m
h_add : ∀ (m m' : M), p m → p m' → p (m + m')
ℳ' : ι → AddSubmonoid M :=
  fun i =>
    { toAddSubsemigroup := { carrier := ↑(ℳ i), add_mem' := (_ : ∀ {a b : M}, a ∈ ↑(ℳ i) → b ∈ ↑(ℳ i) → a + b ∈ ℳ i) },
      zero_mem' := (_ : 0 ∈ ℳ i) }
t : Decomposition ℳ'
⊢ ∀ (m : M), p m

tactic: exact fun m ↦ @AddSubmonoid.iSup_induction _ _ _ ℳ' _ _ (mem m)
  (fun i m h ↦ h_homogeneous ⟨m, h⟩) h_zero h_add
state_before: ι : Type ?u.49490
R : Type ?u.49493
M : Type u_1
σ : Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : AddCommMonoid M
inst✝² : SetLike σ M
inst✝¹ : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝ : Decomposition ℳ
p : M → Prop
h_zero : p 0
h_homogeneous : ∀ {i : ι} (m : { x // x ∈ ℳ i }), p ↑m
h_add : ∀ (m m' : M), p m → p m' → p (m + m')
ℳ' : ι → AddSubmonoid M :=
  fun i =>
    { toAddSubsemigroup := { carrier := ↑(ℳ i), add_mem' := (_ : ∀ {a b : M}, a ∈ ↑(ℳ i) → b ∈ ↑(ℳ i) → a + b ∈ ℳ i) },
      zero_mem' := (_ : 0 ∈ ℳ i) }
t : Decomposition ℳ'
mem : ∀ (m : M), m ∈ iSup ℳ'
⊢ ∀ (m : M), p m
Theorem: Multiset.sum_smul_sum
File: Mathlib/Algebra/Module/BigOperators.lean

tactic: induction' s using Multiset.induction with a s ih
state_before: α : Type ?u.20507
β : Type ?u.20510
R : Type u_1
M : Type u_2
ι : Type ?u.20519
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
s : Multiset R
t : Multiset M
⊢ sum s • sum t = sum (map (fun p => p.fst • p.snd) (s ×ˢ t))

tactic: simp
state_before: case empty
α : Type ?u.20507
β : Type ?u.20510
R : Type u_1
M : Type u_2
ι : Type ?u.20519
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s : R
x y : M
t : Multiset M
⊢ sum 0 • sum t = sum (map (fun p => p.fst • p.snd) (0 ×ˢ t))

tactic: simp [add_smul, ih, ← Multiset.smul_sum]
state_before: case cons
α : Type ?u.20507
β : Type ?u.20510
R : Type u_1
M : Type u_2
ι : Type ?u.20519
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
t : Multiset M
a : R
s : Multiset R
ih : sum s • sum t = sum (map (fun p => p.fst • p.snd) (s ×ˢ t))
⊢ sum (a ::ₘ s) • sum t = sum (map (fun p => p.fst • p.snd) ((a ::ₘ s) ×ˢ t))
Theorem: CategoryTheory.Subobject.le_sInf
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: fapply le_of_comm
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ (g : Subobject A), g ∈ s → f ≤ g
⊢ f ≤ sInf s

tactic: exact Limits.limit.lift _ (leInfCone s f k) ≫ (underlyingIso _).inv
state_before: case f
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ (g : Subobject A), g ∈ s → f ≤ g
⊢ underlying.obj f ⟶ underlying.obj (sInf s)

tactic: dsimp [sInf]
state_before: case w
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ (g : Subobject A), g ∈ s → f ≤ g
⊢ (limit.lift (wideCospan s) (leInfCone s f k) ≫ (underlyingIso (widePullbackι s)).inv) ≫ arrow (sInf s) = arrow f

tactic: rw [assoc, underlyingIso_arrow, widePullbackι, limit.lift_π, leInfCone_π_app_none]
state_before: case w
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ (g : Subobject A), g ∈ s → f ≤ g
⊢ (limit.lift (wideCospan s) (leInfCone s f k) ≫ (underlyingIso (widePullbackι s)).inv) ≫ arrow (mk (widePullbackι s)) =
    arrow f
Theorem: YoungDiagram.mem_row_iff
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp [row]
state_before: μ : YoungDiagram
i : ℕ
c : ℕ × ℕ
⊢ c ∈ row μ i ↔ c ∈ μ ∧ c.fst = i
Theorem: MatrixEquivTensor.toFunAlgHom_apply
File: Mathlib/RingTheory/MatrixAlgebra.lean

tactic: simp [toFunAlgHom, algHomOfLinearMapTensorProduct, toFunLinear]
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
a : A
m : Matrix n n R
⊢ ↑(toFunAlgHom R A n) (a ⊗ₜ[R] m) = a • Matrix.map m ↑(algebraMap R A)

tactic: rfl
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
a : A
m : Matrix n n R
⊢ AddHom.toFun (lift (toFunBilinear R A n)).toAddHom (a ⊗ₜ[R] m) = a • Matrix.map m ↑(algebraMap R A)
Theorem: CategoryTheory.Preadditive.exact_iff_homology_zero
File: Mathlib/Algebra/Homology/Exact.lean

tactic: haveI := h.epi
state_before: V : Type u
inst✝⁵ : Category V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
h : Exact f g
⊢ homology f g (_ : f ≫ g = 0) ≅ 0

tactic: exact cokernel.ofEpi _
state_before: V : Type u
inst✝⁵ : Category V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
h : Exact f g
this : Epi (imageToKernel f g (_ : f ≫ g = 0))
⊢ homology f g (_ : f ≫ g = 0) ≅ 0

tactic: obtain ⟨w, ⟨i⟩⟩ := h
state_before: V : Type u
inst✝⁵ : Category V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
h : ∃ w, Nonempty (homology f g w ≅ 0)
⊢ Exact f g

tactic: exact ⟨w, Preadditive.epi_of_cokernel_zero ((cancel_mono i.hom).mp (by ext))⟩
state_before: case intro.intro
V : Type u
inst✝⁵ : Category V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
w : f ≫ g = 0
i : homology f g w ≅ 0
⊢ Exact f g

tactic: ext
state_before: V : Type u
inst✝⁵ : Category V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
w : f ≫ g = 0
i : homology f g w ≅ 0
⊢ cokernel.π (imageToKernel f g w) ≫ i.hom = 0 ≫ i.hom
Theorem: List.kerase_append_left
File: Mathlib/Data/List/Sigma.lean

tactic: cases h
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
x✝ : List (Sigma β)
h : a ∈ keys []
⊢ kerase a ([] ++ x✝) = kerase a [] ++ x✝

tactic: if h₂ : a = s.1 then simp [h₂]
else simp at h₁; cases' h₁ with h₁ h₁ <;> [exact absurd h₁ h₂; simp [h₂, kerase_append_left h₁]]
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
s : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h₁ : a ∈ keys (s :: l₁)
⊢ kerase a (s :: l₁ ++ l₂) = kerase a (s :: l₁) ++ l₂

tactic: simp [h₂]
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
s : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h₁ : a ∈ keys (s :: l₁)
h₂ : a = s.fst
⊢ kerase a (s :: l₁ ++ l₂) = kerase a (s :: l₁) ++ l₂

tactic: simp at h₁
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
s : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h₁ : a ∈ keys (s :: l₁)
h₂ : ¬a = s.fst
⊢ kerase a (s :: l₁ ++ l₂) = kerase a (s :: l₁) ++ l₂

tactic: cases' h₁ with h₁ h₁ <;> [exact absurd h₁ h₂; simp [h₂, kerase_append_left h₁]]
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
s : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h₂ : ¬a = s.fst
h₁ : a = s.fst ∨ a ∈ keys l₁
⊢ kerase a (s :: l₁ ++ l₂) = kerase a (s :: l₁) ++ l₂
Theorem: op_geom_sum
File: Mathlib/Algebra/GeomSum.lean

tactic: simp
state_before: α : Type u
inst✝ : Semiring α
x : α
n : ℕ
⊢ op (∑ i in range n, x ^ i) = ∑ i in range n, op x ^ i
Theorem: Rel.interedges_biUnion
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: simp_rw [product_biUnion, interedges_biUnion_left, interedges_biUnion_right]
state_before: 𝕜 : Type ?u.12270
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset ι
t : Finset κ
f : ι → Finset α
g : κ → Finset β
⊢ interedges r (Finset.biUnion s f) (Finset.biUnion t g) =
    Finset.biUnion (s ×ˢ t) fun ab => interedges r (f ab.fst) (g ab.snd)
Theorem: CategoryTheory.Limits.Multifork.pi_condition
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: ext
state_before: C : Type u
inst✝² : Category C
I : MulticospanIndex C
K : Multifork I
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
⊢ Pi.lift (ι K) ≫ MulticospanIndex.fstPiMap I = Pi.lift (ι K) ≫ MulticospanIndex.sndPiMap I

tactic: simp
state_before: case h
C : Type u
inst✝² : Category C
I : MulticospanIndex C
K : Multifork I
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
b✝ : I.R
⊢ (Pi.lift (ι K) ≫ MulticospanIndex.fstPiMap I) ≫ Pi.π I.right b✝ =
    (Pi.lift (ι K) ≫ MulticospanIndex.sndPiMap I) ≫ Pi.π I.right b✝
Theorem: CategoryTheory.Sieve.functorPullback_comp
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve ((F ⋙ G).obj X)
⊢ functorPullback (F ⋙ G) R = functorPullback F (functorPullback G R)

tactic: rfl
state_before: case h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve ((F ⋙ G).obj X)
Y✝ : C
f✝ : Y✝ ⟶ X
⊢ (functorPullback (F ⋙ G) R).arrows f✝ ↔ (functorPullback F (functorPullback G R)).arrows f✝
Theorem: IsOpen.tendstoLocallyUniformlyOn_iff_forall_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [hs.nhdsWithin_eq hx]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
hs : IsOpen s
x : α
hx : x ∈ s
⊢ Tendsto (fun y => (f y.snd, F y.fst y.snd)) (p ×ˢ 𝓝[s] x) (𝓤 β) ↔
    Tendsto (fun y => (f y.snd, F y.fst y.snd)) (p ×ˢ 𝓝 x) (𝓤 β)
Theorem: Real.sin_gt_sub_cube
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean

tactic: have hx : |x| = x := abs_of_nonneg h.le
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
⊢ x - x ^ 3 / 4 < sin x

tactic: have := neg_le_of_abs_le (sin_bound <| show |x| ≤ 1 by rwa [hx])
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
⊢ x - x ^ 3 / 4 < sin x

tactic: rw [le_sub_iff_add_le, hx] at this
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this : -(abs x ^ 4 * (5 / 96)) ≤ sin x - (x - x ^ 3 / 6)
⊢ x - x ^ 3 / 4 < sin x

tactic: refine' lt_of_lt_of_le _ this
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
⊢ x - x ^ 3 / 4 < sin x

tactic: have : x ^ 3 / ↑4 - x ^ 3 / ↑6 = x ^ 3 * 12⁻¹ := by ring
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
⊢ x - x ^ 3 / 4 < -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6)

tactic: rw [add_comm, sub_add, sub_neg_eq_add, sub_lt_sub_iff_left, ← lt_sub_iff_add_lt', this]
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this✝ : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
this : x ^ 3 / 4 - x ^ 3 / 6 = x ^ 3 * 12⁻¹
⊢ x - x ^ 3 / 4 < -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6)

tactic: refine' mul_lt_mul' _ (by norm_num) (by norm_num) (pow_pos h 3)
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this✝ : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
this : x ^ 3 / 4 - x ^ 3 / 6 = x ^ 3 * 12⁻¹
⊢ x ^ 4 * (5 / 96) < x ^ 3 * 12⁻¹

tactic: apply pow_le_pow_of_le_one h.le h'
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this✝ : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
this : x ^ 3 / 4 - x ^ 3 / 6 = x ^ 3 * 12⁻¹
⊢ x ^ 4 ≤ x ^ 3

tactic: norm_num
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this✝ : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
this : x ^ 3 / 4 - x ^ 3 / 6 = x ^ 3 * 12⁻¹
⊢ 3 ≤ 4

tactic: rwa [hx]
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
⊢ abs x ≤ 1

tactic: ring
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
⊢ x ^ 3 / 4 - x ^ 3 / 6 = x ^ 3 * 12⁻¹

tactic: norm_num
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this✝ : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
this : x ^ 3 / 4 - x ^ 3 / 6 = x ^ 3 * 12⁻¹
⊢ 5 / 96 < 12⁻¹

tactic: norm_num
state_before: x : ℝ
h : 0 < x
h' : x ≤ 1
hx : abs x = x
this✝ : -(x ^ 4 * (5 / 96)) + (x - x ^ 3 / 6) ≤ sin x
this : x ^ 3 / 4 - x ^ 3 / 6 = x ^ 3 * 12⁻¹
⊢ 0 ≤ 5 / 96
Theorem: selfAdjoint.mem_iff
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: rw [← AddSubgroup.mem_carrier]
state_before: R : Type u_1
A : Type ?u.59390
inst✝¹ : AddGroup R
inst✝ : StarAddMonoid R
x : R
⊢ x ∈ selfAdjoint R ↔ star x = x

tactic: exact Iff.rfl
state_before: R : Type u_1
A : Type ?u.59390
inst✝¹ : AddGroup R
inst✝ : StarAddMonoid R
x : R
⊢ x ∈ (selfAdjoint R).toAddSubmonoid.toAddSubsemigroup.carrier ↔ star x = x
Theorem: mul_divp_cancel
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [Units.mul_inv, mul_one]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c a : α
u : αˣ
⊢ a * (↑u * ↑u⁻¹) = a
Theorem: Path.truncate_const_continuous_family
File: Mathlib/Topology/PathConnected.lean

tactic: have key : Continuous (fun x => (t, x) : ℝ × I → ℝ × ℝ × I) := by continuity
state_before: X✝ : Type ?u.469179
Y : Type ?u.469182
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.469197
γ✝ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t : ℝ
⊢ Continuous ↿(truncate γ t)

tactic: exact γ.truncate_continuous_family.comp key
state_before: X✝ : Type ?u.469179
Y : Type ?u.469182
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.469197
γ✝ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t : ℝ
key : Continuous fun x => (t, x)
⊢ Continuous ↿(truncate γ t)

tactic: continuity
state_before: X✝ : Type ?u.469179
Y : Type ?u.469182
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.469197
γ✝ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t : ℝ
⊢ Continuous fun x => (t, x)