tasksource/leandojo huggingface dataset:
Theorem: ContinuousMultilinearMap.op_norm_smul_le
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: intro m
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁷ : Fintype ι
inst✝¹⁶ : Fintype ι'
inst✝¹⁵ : NontriviallyNormedField 𝕜
inst✝¹⁴ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹³ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹² : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝¹⁰ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁹ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁸ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁷ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c✝ : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
c : 𝕜'
⊢ ∀ (m : (i : ι) → E i), ‖↑(c • f) m‖ ≤ ‖c‖ * ‖f‖ * ∏ i : ι, ‖m i‖

tactic: erw [norm_smul, mul_assoc]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁷ : Fintype ι
inst✝¹⁶ : Fintype ι'
inst✝¹⁵ : NontriviallyNormedField 𝕜
inst✝¹⁴ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹³ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹² : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝¹⁰ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁹ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁸ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁷ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c✝ : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m✝ : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
c : 𝕜'
m : (i : ι) → E i
⊢ ‖↑(c • f) m‖ ≤ ‖c‖ * ‖f‖ * ∏ i : ι, ‖m i‖

tactic: exact mul_le_mul_of_nonneg_left (le_op_norm _ _) (norm_nonneg _)
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁷ : Fintype ι
inst✝¹⁶ : Fintype ι'
inst✝¹⁵ : NontriviallyNormedField 𝕜
inst✝¹⁴ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹³ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹² : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝¹⁰ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁹ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁸ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁷ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c✝ : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m✝ : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
c : 𝕜'
m : (i : ι) → E i
⊢ ‖c‖ * ‖↑f.toMultilinearMap m‖ ≤ ‖c‖ * (‖f‖ * ∏ i : ι, ‖m i‖)
Theorem: LaurentPolynomial.single_eq_C_mul_T
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: simp [C, T, single_mul_single]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
n : ℤ
⊢ Finsupp.single n r = ↑C r * T n
Theorem: IsROrC.ofNat_mul_im
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← ofReal_ofNat, ofReal_mul_im]
state_before: K : Type u_1
E : Type ?u.6397915
inst✝¹ : IsROrC K
n : ℕ
inst✝ : Nat.AtLeastTwo n
z : K
⊢ ↑im (OfNat.ofNat n * z) = OfNat.ofNat n * ↑im z
Theorem: Metric.hausdorffDist_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [hausdorffDist]
state_before: ι : Sort ?u.87243
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ hausdorffDist (closure s) (closure t) = hausdorffDist s t
Theorem: Finsupp.comapDomain_single
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rcases eq_or_ne m 0 with (rfl | hm)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.304875
ι : Type ?u.304878
M : Type u_3
M' : Type ?u.304884
N : Type ?u.304887
P : Type ?u.304890
G : Type ?u.304893
H : Type ?u.304896
R : Type ?u.304899
S : Type ?u.304902
inst✝ : Zero M
f : α → β
a : α
m : M
hif : Set.InjOn f (f ⁻¹' ↑(single (f a) m).support)
⊢ comapDomain f (single (f a) m) hif = single a m

tactic: simp only [single_zero, comapDomain_zero]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.304875
ι : Type ?u.304878
M : Type u_3
M' : Type ?u.304884
N : Type ?u.304887
P : Type ?u.304890
G : Type ?u.304893
H : Type ?u.304896
R : Type ?u.304899
S : Type ?u.304902
inst✝ : Zero M
f : α → β
a : α
hif : Set.InjOn f (f ⁻¹' ↑(single (f a) 0).support)
⊢ comapDomain f (single (f a) 0) hif = single a 0

tactic: rw [eq_single_iff, comapDomain_apply, comapDomain_support, ← Finset.coe_subset, coe_preimage,
  support_single_ne_zero _ hm, coe_singleton, coe_singleton, single_eq_same]
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.304875
ι : Type ?u.304878
M : Type u_3
M' : Type ?u.304884
N : Type ?u.304887
P : Type ?u.304890
G : Type ?u.304893
H : Type ?u.304896
R : Type ?u.304899
S : Type ?u.304902
inst✝ : Zero M
f : α → β
a : α
m : M
hif : Set.InjOn f (f ⁻¹' ↑(single (f a) m).support)
hm : m ≠ 0
⊢ comapDomain f (single (f a) m) hif = single a m

tactic: rw [support_single_ne_zero _ hm, coe_singleton] at hif
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.304875
ι : Type ?u.304878
M : Type u_3
M' : Type ?u.304884
N : Type ?u.304887
P : Type ?u.304890
G : Type ?u.304893
H : Type ?u.304896
R : Type ?u.304899
S : Type ?u.304902
inst✝ : Zero M
f : α → β
a : α
m : M
hif : Set.InjOn f (f ⁻¹' ↑(single (f a) m).support)
hm : m ≠ 0
⊢ f ⁻¹' {f a} ⊆ {a} ∧ m = m

tactic: exact ⟨fun x hx => hif hx rfl hx, rfl⟩
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.304875
ι : Type ?u.304878
M : Type u_3
M' : Type ?u.304884
N : Type ?u.304887
P : Type ?u.304890
G : Type ?u.304893
H : Type ?u.304896
R : Type ?u.304899
S : Type ?u.304902
inst✝ : Zero M
f : α → β
a : α
m : M
hif : Set.InjOn f (f ⁻¹' {f a})
hm : m ≠ 0
⊢ f ⁻¹' {f a} ⊆ {a} ∧ m = m
Theorem: Polynomial.algHom_eval₂_algebraMap
File: Mathlib/Data/Polynomial/AlgebraMap.lean

tactic: simp only [eval₂_eq_sum, sum_def]
state_before: R✝ : Type u
S : Type v
T : Type w
A✝ : Type z
A' : Type ?u.272359
B' : Type ?u.272362
a✝ b : R✝
n : ℕ
inst✝⁹ : CommSemiring A'
inst✝⁸ : Semiring B'
inst✝⁷ : CommSemiring R✝
p✝ q r : R✝[X]
inst✝⁶ : Semiring A✝
inst✝⁵ : Algebra R✝ A✝
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
p : R[X]
f : A →ₐ[R] B
a : A
⊢ ↑f (eval₂ (algebraMap R A) a p) = eval₂ (algebraMap R B) (↑f a) p

tactic: simp only [f.map_sum, f.map_mul, f.map_pow, eq_intCast, map_intCast, AlgHom.commutes]
state_before: R✝ : Type u
S : Type v
T : Type w
A✝ : Type z
A' : Type ?u.272359
B' : Type ?u.272362
a✝ b : R✝
n : ℕ
inst✝⁹ : CommSemiring A'
inst✝⁸ : Semiring B'
inst✝⁷ : CommSemiring R✝
p✝ q r : R✝[X]
inst✝⁶ : Semiring A✝
inst✝⁵ : Algebra R✝ A✝
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
p : R[X]
f : A →ₐ[R] B
a : A
⊢ ↑f (∑ n in support p, ↑(algebraMap R A) (coeff p n) * a ^ n) =
    ∑ n in support p, ↑(algebraMap R B) (coeff p n) * ↑f a ^ n
Theorem: ChartedSpace.liftProp_iff
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: simp_rw [LiftProp, liftPropAt_iff, forall_and, continuous_iff_continuousAt]
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.10207
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
P : (H → H') → Set H → H → Prop
f : M → M'
⊢ LiftProp P f ↔
    Continuous f ∧
      ∀ (x : M), P (↑(chartAt H' (f x)) ∘ f ∘ ↑(LocalHomeomorph.symm (chartAt H x))) univ (↑(chartAt H x) x)
Theorem: Array.get?_len_le
File: Std/Data/Array/Lemmas.lean

tactic: simp [getElem?_neg, h]
state_before: α : Type u_1
a : Array α
i : Nat
h : size a ≤ i
⊢ a[i]? = none
Theorem: Finset.attach_eq_empty_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
β : Type ?u.292792
γ : Type ?u.292795
s : Finset α
⊢ attach s = ∅ ↔ s = ∅
Theorem: Set.mul_zero_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp [subset_def, mem_mul]
state_before: F : Type ?u.94562
α : Type u_1
β : Type ?u.94568
γ : Type ?u.94571
inst✝ : MulZeroClass α
s✝ t s : Set α
⊢ s * 0 ⊆ 0
Theorem: Polynomial.degree_add_eq_of_leadingCoeff_add_ne_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [degree_add_eq_right_of_degree_lt hlt, max_eq_right_of_lt hlt]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.557539
h : leadingCoeff p + leadingCoeff q ≠ 0
hlt : degree p < degree q
⊢ max (degree p) (degree q) ≤ degree (p + q)

tactic: rw [HEq, max_self] at hlt
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.557539
h : leadingCoeff p + leadingCoeff q ≠ 0
HEq : degree p = degree q
hlt : max (degree p) (degree q) > degree (p + q)
⊢ leadingCoeff p + leadingCoeff q = 0

tactic: rw [leadingCoeff, leadingCoeff, natDegree_eq_of_degree_eq HEq, ← coeff_add]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.557539
h : leadingCoeff p + leadingCoeff q ≠ 0
HEq : degree p = degree q
hlt : degree q > degree (p + q)
⊢ leadingCoeff p + leadingCoeff q = 0

tactic: exact coeff_natDegree_eq_zero_of_degree_lt hlt
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.557539
h : leadingCoeff p + leadingCoeff q ≠ 0
HEq : degree p = degree q
hlt : degree q > degree (p + q)
⊢ coeff (p + q) (natDegree q) = 0

tactic: rw [degree_add_eq_left_of_degree_lt hlt, max_eq_left_of_lt hlt]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.557539
h : leadingCoeff p + leadingCoeff q ≠ 0
hlt : degree q < degree p
⊢ max (degree p) (degree q) ≤ degree (p + q)
Theorem: toIcoDiv_eq_floor
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: refine' toIcoDiv_eq_of_sub_zsmul_mem_Ico hp _
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ toIcoDiv hp a b = ⌊(b - a) / p⌋

tactic: rw [Set.mem_Ico, zsmul_eq_mul, ← sub_nonneg, add_comm, sub_right_comm, ← sub_lt_iff_lt_add,
  sub_right_comm _ _ a]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ b - ⌊(b - a) / p⌋ • p ∈ Set.Ico a (a + p)

tactic: exact ⟨Int.sub_floor_div_mul_nonneg _ hp, Int.sub_floor_div_mul_lt _ hp⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ 0 ≤ b - a - ↑⌊(b - a) / p⌋ * p ∧ b - a - ↑⌊(b - a) / p⌋ * p < p
Theorem: continuousAt_dslope_same
File: Mathlib/Analysis/Calculus/Dslope.lean

tactic: simp only [dslope, continuousAt_update_same, ← hasDerivAt_deriv_iff, hasDerivAt_iff_tendsto_slope]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
⊢ ContinuousAt (dslope f a) a ↔ DifferentiableAt 𝕜 f a
Theorem: List.count_bind
File: Mathlib/Data/List/Count.lean

tactic: rw [List.bind, count_join, map_map]
state_before: α✝ : Type ?u.42445
l✝ : List α✝
inst✝¹ : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝ : DecidableEq β
l : List α
f : α → List β
x : β
⊢ count x (List.bind l f) = sum (map (count x ∘ f) l)
Theorem: NonUnitalAlgHom.fst_prod
File: Mathlib/Algebra/Hom/NonUnitalAlg.lean

tactic: rfl
state_before: R : Type u
A : Type v
B : Type w
C : Type w₁
inst✝⁶ : Monoid R
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction R B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction R C
f : A →ₙₐ[R] B
g : A →ₙₐ[R] C
⊢ comp (fst R B C) (prod f g) = f
Theorem: Finset.disjiUnion_empty
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type ?u.483531
β : Type ?u.483534
γ : Type ?u.483537
s s₁ s₂ : Finset α
t✝ t₁ t₂ t : α → Finset β
⊢ Set.PairwiseDisjoint (↑∅) t
Theorem: MeasureTheory.JordanDecomposition.toJordanDecomposition_toSignedMeasure
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.73773
inst✝ : MeasurableSpace α
j : JordanDecomposition α
⊢ toSignedMeasure j = toSignedMeasure (toJordanDecomposition (toSignedMeasure j))
Theorem: LinearEquiv.coe_ofIsUnitDet
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: ext x
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M →ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
h : IsUnit (det (↑(toMatrix v v') f))
⊢ ↑(ofIsUnitDet h) = f

tactic: rfl
state_before: case h
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M →ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
h : IsUnit (det (↑(toMatrix v v') f))
x : M
⊢ ↑↑(ofIsUnitDet h) x = ↑f x
Theorem: Disjoint.left_le_of_le_sup_left
File: Mathlib/Order/Disjoint.lean

tactic: rwa [sup_comm]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b c : α
h : a ≤ c ⊔ b
hd : Disjoint a c
⊢ a ≤ b ⊔ c
Theorem: pow_le_kstar
File: Mathlib/Algebra/Order/Kleene.lean

tactic: rw [pow_succ]
state_before: α : Type u_1
β : Type ?u.49483
ι : Type ?u.49486
π : ι → Type ?u.49491
inst✝ : KleeneAlgebra α
a b c : α
n : ℕ
⊢ a ^ (n + 1) ≤ a∗

tactic: exact (mul_le_mul_left' pow_le_kstar _).trans mul_kstar_le_kstar
state_before: α : Type u_1
β : Type ?u.49483
ι : Type ?u.49486
π : ι → Type ?u.49491
inst✝ : KleeneAlgebra α
a b c : α
n : ℕ
⊢ a * a ^ n ≤ a∗
Theorem: NormedRing.inverse_continuousAt
File: Mathlib/Analysis/NormedSpace/Units.lean

tactic: have h_is_o : (fun t : R => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] (fun _ => 1 : R → ℝ) :=
  (inverse_add_norm_diff_first_order x).trans_isLittleO (isLittleO_id_const one_ne_zero).norm_left
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
⊢ ContinuousAt inverse ↑x

tactic: have h_lim : Tendsto (fun y : R => y - x) (𝓝 x) (𝓝 0) := by
  refine' tendsto_zero_iff_norm_tendsto_zero.mpr _
  exact tendsto_iff_norm_tendsto_zero.mp tendsto_id
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
⊢ ContinuousAt inverse ↑x

tactic: rw [ContinuousAt, tendsto_iff_norm_tendsto_zero, inverse_unit]
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
h_lim : Tendsto (fun y => y - ↑x) (𝓝 ↑x) (𝓝 0)
⊢ ContinuousAt inverse ↑x

tactic: refine' tendsto_zero_iff_norm_tendsto_zero.mpr _
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
⊢ Tendsto (fun y => y - ↑x) (𝓝 ↑x) (𝓝 0)

tactic: exact tendsto_iff_norm_tendsto_zero.mp tendsto_id
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
⊢ Tendsto (fun e => ‖e - ↑x‖) (𝓝 ↑x) (𝓝 0)
Theorem: isAlgebraic_iff_isIntegral
File: Mathlib/RingTheory/Algebraic.lean

tactic: refine' ⟨_, IsIntegral.isAlgebraic K⟩
state_before: K : Type u
A : Type v
inst✝² : Field K
inst✝¹ : Ring A
inst✝ : Algebra K A
x : A
⊢ IsAlgebraic K x ↔ IsIntegral K x

tactic: rintro ⟨p, hp, hpx⟩
state_before: K : Type u
A : Type v
inst✝² : Field K
inst✝¹ : Ring A
inst✝ : Algebra K A
x : A
⊢ IsAlgebraic K x → IsIntegral K x

tactic: refine' ⟨_, monic_mul_leadingCoeff_inv hp, _⟩
state_before: case intro.intro
K : Type u
A : Type v
inst✝² : Field K
inst✝¹ : Ring A
inst✝ : Algebra K A
x : A
p : K[X]
hp : p ≠ 0
hpx : ↑(aeval x) p = 0
⊢ IsIntegral K x

tactic: rw [← aeval_def, AlgHom.map_mul, hpx, MulZeroClass.zero_mul]
state_before: case intro.intro
K : Type u
A : Type v
inst✝² : Field K
inst✝¹ : Ring A
inst✝ : Algebra K A
x : A
p : K[X]
hp : p ≠ 0
hpx : ↑(aeval x) p = 0
⊢ eval₂ (algebraMap K A) x (p * ↑C (leadingCoeff p)⁻¹) = 0
Theorem: ContinuousLinearMap.coe_eq_id
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: rw [← coe_id, coe_inj]
state_before: R₁ : Type u_1
R₂ : Type ?u.455284
R₃ : Type ?u.455287
inst✝¹⁶ : Semiring R₁
inst✝¹⁵ : Semiring R₂
inst✝¹⁴ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_2
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.455374
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type ?u.455383
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type ?u.455392
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.455401
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
f : M₁ →L[R₁] M₁
⊢ ↑f = LinearMap.id ↔ f = id R₁ M₁
Theorem: Real.arccos_eq_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: norm_num
state_before: x : ℝ
h : 0 ≤ x
⊢ 0 ≤ 2
Theorem: CategoryTheory.Adjunction.homEquiv_symm_rightAdjointUniq_hom_app
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: apply Quiver.Hom.op_inj
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
⊢ ↑(homEquiv adj2 (G.obj x) x).symm ((rightAdjointUniq adj1 adj2).hom.app x) = adj1.counit.app x

tactic: convert homEquiv_leftAdjointUniq_hom_app (opAdjointOpOfAdjoint _ F adj2)
  (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x)
state_before: case a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
⊢ (↑(homEquiv adj2 (G.obj x) x).symm ((rightAdjointUniq adj1 adj2).hom.app x)).op = (adj1.counit.app x).op

tactic: simp only [opAdjointOpOfAdjoint, Functor.op_obj, Opposite.unop_op, mkOfHomEquiv_unit_app,
  Equiv.trans_apply, homEquiv_counit, Functor.id_obj]
state_before: case h.e'_3.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ :
  (x.op ⟶ (F.obj (G.obj x)).op) =
    (fun x_1 => x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
      ((leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op)
⊢ (adj1.counit.app x).op = (opAdjointOpOfAdjoint G F adj1).unit.app x.op

tactic: erw [F.map_id]
state_before: case h.e'_3.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ :
  (x.op ⟶ (F.obj (G.obj x)).op) =
    (fun x_1 => x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
      ((leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op)
⊢ (adj1.counit.app x).op =
    ↑(opEquiv x.op (F.toPrefunctor.1 (G.obj x)).op).symm
      (F.map (↑(opEquiv (G.obj x).op (G.obj x).op) (𝟙 (G.obj x).op)) ≫ adj1.counit.app x)

tactic: rw [Category.id_comp]
state_before: case h.e'_3.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ :
  (x.op ⟶ (F.obj (G.obj x)).op) =
    (fun x_1 => x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
      ((leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op)
⊢ (adj1.counit.app x).op =
    ↑(opEquiv x.op (F.toPrefunctor.1 (G.obj x)).op).symm (𝟙 (F.obj (G.obj x)) ≫ adj1.counit.app x)

tactic: rfl
state_before: case h.e'_3.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ :
  (x.op ⟶ (F.obj (G.obj x)).op) =
    (fun x_1 => x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
      ((leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op)
⊢ (adj1.counit.app x).op = ↑(opEquiv x.op (F.toPrefunctor.1 (G.obj x)).op).symm (adj1.counit.app x)
Theorem: CategoryTheory.Limits.PushoutCocone.epi_of_isColimitMkIdId
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rcases PushoutCocone.IsColimit.desc' t _ _ eq with ⟨_, rfl, rfl⟩
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z✝ : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z✝
f : X ⟶ Y
t : IsColimit (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y))
Z : C
g h : Y ⟶ Z
eq : f ≫ g = f ≫ h
⊢ g = h

tactic: rfl
state_before: case mk.intro
C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z✝ : C
f✝ : X ⟶ Y
g : X ⟶ Z✝
f : X ⟶ Y
t : IsColimit (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y))
Z : C
val✝ : (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)).pt ⟶ Z
eq : f ≫ inl (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)) ≫ val✝ = f ≫ inr (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)) ≫ val✝
⊢ inl (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)) ≫ val✝ = inr (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)) ≫ val✝
Theorem: Complex.ofReal_mul
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [ofReal']
state_before: r s : ℝ
⊢ (↑(r * s)).re = (↑r * ↑s).re ∧ (↑(r * s)).im = (↑r * ↑s).im
Theorem: EReal.sign_eq_and_abs_eq_iff_eq
File: Mathlib/Data/Real/EReal.lean

tactic: constructor
state_before: x y : EReal
⊢ EReal.abs x = EReal.abs y ∧ ↑sign x = ↑sign y ↔ x = y

tactic: rintro ⟨habs, hsign⟩
state_before: case mp
x y : EReal
⊢ EReal.abs x = EReal.abs y ∧ ↑sign x = ↑sign y → x = y

tactic: rw [← x.sign_mul_abs, ← y.sign_mul_abs, habs, hsign]
state_before: case mp.intro
x y : EReal
habs : EReal.abs x = EReal.abs y
hsign : ↑sign x = ↑sign y
⊢ x = y

tactic: rintro rfl
state_before: case mpr
x y : EReal
⊢ x = y → EReal.abs x = EReal.abs y ∧ ↑sign x = ↑sign y

tactic: exact ⟨rfl, rfl⟩
state_before: case mpr
x : EReal
⊢ EReal.abs x = EReal.abs x ∧ ↑sign x = ↑sign x
Theorem: List.span.loop_eq_take_drop
File: Mathlib/Data/List/Basic.lean

tactic: simp [span.loop, takeWhile, dropWhile]
state_before: ι : Type ?u.381634
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ : List α
p : α → Bool
l₂ : List α
⊢ loop p [] l₂ = (reverse l₂ ++ takeWhile p [], dropWhile p [])

tactic: cases hp : p a <;> simp [hp, span.loop, span.loop_eq_take_drop, takeWhile, dropWhile]
state_before: ι : Type ?u.381634
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ : List α
p : α → Bool
a : α
l l₂ : List α
⊢ loop p (a :: l) l₂ = (reverse l₂ ++ takeWhile p (a :: l), dropWhile p (a :: l))
Theorem: CategoryTheory.Quotient.comp_left
File: Mathlib/CategoryTheory/Quotient.lean

tactic: simpa using CompClosure.intro (f ≫ x) m₁ m₂ y h
state_before: C : Type u_2
inst✝ : Category C
r : HomRel C
a b c : C
f : a ⟶ b
a✝ b✝ : C
x : b ⟶ a✝
m₁ m₂ : a✝ ⟶ b✝
y : b✝ ⟶ c
h : r m₁ m₂
⊢ CompClosure r (f ≫ x ≫ m₁ ≫ y) (f ≫ x ≫ m₂ ≫ y)
Theorem: List.reverse_revzip
File: Mathlib/Data/List/Zip.lean

tactic: rw [← zip_unzip (revzip l).reverse]
state_before: α : Type u
β : Type ?u.93715
γ : Type ?u.93718
δ : Type ?u.93721
ε : Type ?u.93724
l : List α
⊢ reverse (revzip l) = revzip (reverse l)

tactic: simp [unzip_eq_map, revzip, map_reverse, map_fst_zip, map_snd_zip]
state_before: α : Type u
β : Type ?u.93715
γ : Type ?u.93718
δ : Type ?u.93721
ε : Type ?u.93724
l : List α
⊢ zip (unzip (reverse (revzip l))).fst (unzip (reverse (revzip l))).snd = revzip (reverse l)
Theorem: Equiv.Perm.card_cycleType_eq_zero
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [card_eq_zero, cycleType_eq_zero]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
⊢ ↑card (cycleType σ) = 0 ↔ σ = 1
Theorem: sup_sdiff_right_self
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sup_sdiff, sdiff_self, sup_bot_eq]
state_before: ι : Type ?u.137388
α : Type u_1
β : Type ?u.137394
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ (a ⊔ b) \ b = a \ b