ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Analysis/Calculus/Deriv/Prod.lean

full_name: HasDerivAtFilter.prod
code: nonrec theorem HasDerivAtFilter.prod (hf₁ : HasDerivAtFilter f₁ f₁' x L)
    (hf₂ : HasDerivAtFilter f₂ f₂' x L) : HasDerivAtFilter (fun x => (f₁ x, f₂ x)) (f₁', f₂') x L 
goal: HasDerivAtFilter (fun x => (f₁ x, f₂ x)) (f₁', f₂') x L

full_name: HasDerivWithinAt.prod
code: nonrec theorem HasDerivWithinAt.prod (hf₁ : HasDerivWithinAt f₁ f₁' s x)
    (hf₂ : HasDerivWithinAt f₂ f₂' s x) : HasDerivWithinAt (fun x => (f₁ x, f₂ x)) (f₁', f₂') s x 
goal: HasDerivWithinAt (fun x => (f₁ x, f₂ x)) (f₁', f₂') s x

full_name: HasDerivAt.prod
code: nonrec theorem HasDerivAt.prod (hf₁ : HasDerivAt f₁ f₁' x) (hf₂ : HasDerivAt f₂ f₂' x) :
    HasDerivAt (fun x => (f₁ x, f₂ x)) (f₁', f₂') x 
goal: HasDerivAt (fun x => (f₁ x, f₂ x)) (f₁', f₂') x

full_name: HasStrictDerivAt.prod
code: nonrec theorem HasStrictDerivAt.prod (hf₁ : HasStrictDerivAt f₁ f₁' x)
    (hf₂ : HasStrictDerivAt f₂ f₂' x) : HasStrictDerivAt (fun x => (f₁ x, f₂ x)) (f₁', f₂') x 
goal: HasStrictDerivAt (fun x => (f₁ x, f₂ x)) (f₁', f₂') x

full_name: hasStrictDerivAt_pi
code: @[simp]
theorem hasStrictDerivAt_pi :
    HasStrictDerivAt φ φ' x ↔ ∀ i, HasStrictDerivAt (fun x => φ x i) (φ' i) x 
goal: HasStrictDerivAt φ φ' x ↔ ∀ (i : ι), HasStrictDerivAt (fun x => φ x i) (φ' i) x

full_name: hasDerivAtFilter_pi
code: @[simp]
theorem hasDerivAtFilter_pi :
    HasDerivAtFilter φ φ' x L ↔ ∀ i, HasDerivAtFilter (fun x => φ x i) (φ' i) x L 
goal: HasDerivAtFilter φ φ' x L ↔ ∀ (i : ι), HasDerivAtFilter (fun x => φ x i) (φ' i) x L

full_name: hasDerivAt_pi
code: theorem hasDerivAt_pi : HasDerivAt φ φ' x ↔ ∀ i, HasDerivAt (fun x => φ x i) (φ' i) x 
goal: HasDerivAt φ φ' x ↔ ∀ (i : ι), HasDerivAt (fun x => φ x i) (φ' i) x

full_name: hasDerivWithinAt_pi
code: theorem hasDerivWithinAt_pi :
    HasDerivWithinAt φ φ' s x ↔ ∀ i, HasDerivWithinAt (fun x => φ x i) (φ' i) s x 
goal: HasDerivWithinAt φ φ' s x ↔ ∀ (i : ι), HasDerivWithinAt (fun x => φ x i) (φ' i) s x

full_name: derivWithin_pi
code: theorem derivWithin_pi (h : ∀ i, DifferentiableWithinAt 𝕜 (fun x => φ x i) s x)
    (hs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin φ s x = fun i => derivWithin (fun x => φ x i) s x 
goal: derivWithin φ s x = fun i => derivWithin (fun x => φ x i) s x

full_name: deriv_pi
code: theorem deriv_pi (h : ∀ i, DifferentiableAt 𝕜 (fun x => φ x i) x) :
    deriv φ x = fun i => deriv (fun x => φ x i) x 
goal: deriv φ x = fun i => deriv (fun x => φ x i) x
File: Mathlib/Analysis/Calculus/Deriv/Linear.lean

full_name: ContinuousLinearMap.hasDerivAtFilter
code: protected theorem ContinuousLinearMap.hasDerivAtFilter : HasDerivAtFilter e (e 1) x L 
goal: HasDerivAtFilter (⇑e) (e 1) x L

full_name: ContinuousLinearMap.hasStrictDerivAt
code: protected theorem ContinuousLinearMap.hasStrictDerivAt : HasStrictDerivAt e (e 1) x 
goal: HasStrictDerivAt (⇑e) (e 1) x

full_name: ContinuousLinearMap.hasDerivAt
code: protected theorem ContinuousLinearMap.hasDerivAt : HasDerivAt e (e 1) x 
goal: HasDerivAt (⇑e) (e 1) x

full_name: ContinuousLinearMap.hasDerivWithinAt
code: protected theorem ContinuousLinearMap.hasDerivWithinAt : HasDerivWithinAt e (e 1) s x 
goal: HasDerivWithinAt (⇑e) (e 1) s x

full_name: ContinuousLinearMap.deriv
code: @[simp]
protected theorem ContinuousLinearMap.deriv : deriv e x = e 1 
goal: deriv (⇑e) x = e 1

full_name: ContinuousLinearMap.derivWithin
code: protected theorem ContinuousLinearMap.derivWithin (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin e s x = e 1 
goal: derivWithin (⇑e) s x = e 1

full_name: LinearMap.hasDerivAtFilter
code: protected theorem LinearMap.hasDerivAtFilter : HasDerivAtFilter e (e 1) x L 
goal: HasDerivAtFilter (⇑e) (e 1) x L

full_name: LinearMap.hasStrictDerivAt
code: protected theorem LinearMap.hasStrictDerivAt : HasStrictDerivAt e (e 1) x 
goal: HasStrictDerivAt (⇑e) (e 1) x

full_name: LinearMap.hasDerivAt
code: protected theorem LinearMap.hasDerivAt : HasDerivAt e (e 1) x 
goal: HasDerivAt (⇑e) (e 1) x

full_name: LinearMap.hasDerivWithinAt
code: protected theorem LinearMap.hasDerivWithinAt : HasDerivWithinAt e (e 1) s x 
goal: HasDerivWithinAt (⇑e) (e 1) s x

full_name: LinearMap.deriv
code: @[simp]
protected theorem LinearMap.deriv : deriv e x = e 1 
goal: deriv (⇑e) x = e 1

full_name: LinearMap.derivWithin
code: protected theorem LinearMap.derivWithin (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin e s x = e 1 
goal: derivWithin (⇑e) s x = e 1
File: Mathlib/Analysis/Calculus/Deriv/Pow.lean

full_name: hasStrictDerivAt_pow
code: theorem hasStrictDerivAt_pow :
    ∀ (n : ℕ) (x : 𝕜), HasStrictDerivAt (fun x : 𝕜 ↦ x ^ n) ((n : 𝕜) * x ^ (n - 1)) x
  
goal: HasStrictDerivAt (fun x => x ^ n) (↑n * x ^ (n - 1)) x

full_name: hasDerivAt_pow
code: theorem hasDerivAt_pow (n : ℕ) (x : 𝕜) :
    HasDerivAt (fun x : 𝕜 => x ^ n) ((n : 𝕜) * x ^ (n - 1)) x 
goal: HasDerivAt (fun x => x ^ n) (↑n * x ^ (n - 1)) x

full_name: hasDerivWithinAt_pow
code: theorem hasDerivWithinAt_pow (n : ℕ) (x : 𝕜) (s : Set 𝕜) :
    HasDerivWithinAt (fun x : 𝕜 => x ^ n) ((n : 𝕜) * x ^ (n - 1)) s x 
goal: HasDerivWithinAt (fun x => x ^ n) (↑n * x ^ (n - 1)) s x

full_name: differentiableAt_pow
code: theorem differentiableAt_pow : DifferentiableAt 𝕜 (fun x : 𝕜 => x ^ n) x 
goal: DifferentiableAt 𝕜 (fun x => x ^ n) x

full_name: differentiableWithinAt_pow
code: theorem differentiableWithinAt_pow :
    DifferentiableWithinAt 𝕜 (fun x : 𝕜 => x ^ n) s x 
goal: DifferentiableWithinAt 𝕜 (fun x => x ^ n) s x

full_name: differentiable_pow
code: theorem differentiable_pow : Differentiable 𝕜 fun x : 𝕜 => x ^ n 
goal: Differentiable 𝕜 fun x => x ^ n

full_name: differentiableOn_pow
code: theorem differentiableOn_pow : DifferentiableOn 𝕜 (fun x : 𝕜 => x ^ n) s 
goal: DifferentiableOn 𝕜 (fun x => x ^ n) s

full_name: deriv_pow
code: theorem deriv_pow : deriv (fun x : 𝕜 => x ^ n) x = (n : 𝕜) * x ^ (n - 1) 
goal: deriv (fun x => x ^ n) x = ↑n * x ^ (n - 1)

full_name: deriv_pow'
code: @[simp]
theorem deriv_pow' : (deriv fun x : 𝕜 => x ^ n) = fun x => (n : 𝕜) * x ^ (n - 1) 
goal: (deriv fun x => x ^ n) = fun x => ↑n * x ^ (n - 1)

full_name: derivWithin_pow
code: theorem derivWithin_pow (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x : 𝕜 => x ^ n) s x = (n : 𝕜) * x ^ (n - 1) 
goal: derivWithin (fun x => x ^ n) s x = ↑n * x ^ (n - 1)

full_name: HasDerivWithinAt.pow
code: theorem HasDerivWithinAt.pow (hc : HasDerivWithinAt c c' s x) :
    HasDerivWithinAt (fun y => c y ^ n) ((n : 𝕜) * c x ^ (n - 1) * c') s x 
goal: HasDerivWithinAt (fun y => c y ^ n) (↑n * c x ^ (n - 1) * c') s x

full_name: HasDerivAt.pow
code: theorem HasDerivAt.pow (hc : HasDerivAt c c' x) :
    HasDerivAt (fun y => c y ^ n) ((n : 𝕜) * c x ^ (n - 1) * c') x 
goal: HasDerivAt (fun y => c y ^ n) (↑n * c x ^ (n - 1) * c') x

full_name: derivWithin_pow'
code: theorem derivWithin_pow' (hc : DifferentiableWithinAt 𝕜 c s x) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x => c x ^ n) s x = (n : 𝕜) * c x ^ (n - 1) * derivWithin c s x 
goal: derivWithin (fun x => c x ^ n) s x = ↑n * c x ^ (n - 1) * derivWithin c s x

full_name: deriv_pow''
code: @[simp]
theorem deriv_pow'' (hc : DifferentiableAt 𝕜 c x) :
    deriv (fun x => c x ^ n) x = (n : 𝕜) * c x ^ (n - 1) * deriv c x 
goal: deriv (fun x => c x ^ n) x = ↑n * c x ^ (n - 1) * deriv c x
File: Mathlib/Analysis/Calculus/Deriv/Star.lean

full_name: HasDerivAtFilter.star
code: protected nonrec theorem HasDerivAtFilter.star (h : HasDerivAtFilter f f' x L) :
    HasDerivAtFilter (fun x => star (f x)) (star f') x L 
goal: HasDerivAtFilter (fun x => star (f x)) (star f') x L

full_name: HasDerivWithinAt.star
code: protected nonrec theorem HasDerivWithinAt.star (h : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => star (f x)) (star f') s x 
goal: HasDerivWithinAt (fun x => star (f x)) (star f') s x

full_name: HasDerivAt.star
code: protected nonrec theorem HasDerivAt.star (h : HasDerivAt f f' x) :
    HasDerivAt (fun x => star (f x)) (star f') x 
goal: HasDerivAt (fun x => star (f x)) (star f') x

full_name: HasStrictDerivAt.star
code: protected nonrec theorem HasStrictDerivAt.star (h : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => star (f x)) (star f') x 
goal: HasStrictDerivAt (fun x => star (f x)) (star f') x

full_name: derivWithin.star
code: protected theorem derivWithin.star (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun y => star (f y)) s x = star (derivWithin f s x) 
goal: derivWithin (fun y => star (f y)) s x = star (derivWithin f s x)

full_name: deriv.star
code: protected theorem deriv.star : deriv (fun y => star (f y)) x = star (deriv f x) 
goal: deriv (fun y => star (f y)) x = star (deriv f x)

full_name: deriv.star'
code: @[simp]
protected theorem deriv.star' : (deriv fun y => star (f y)) = fun x => star (deriv f x) 
goal: (deriv fun y => star (f y)) = fun x => star (deriv f x)
File: Mathlib/Analysis/Calculus/BumpFunction/InnerProduct.lean

full_name: ContDiffBumpBase.ofInnerProductSpace
code: /-- A base bump function in an inner product space. This construction works in any space with a
norm smooth away from zero but we do not have a typeclass for this. -/
noncomputable def ContDiffBumpBase.ofInnerProductSpace : ContDiffBumpBase E 
goal: ContDiffBumpBase E

full_name: hasContDiffBump_of_innerProductSpace
code: /-- Any inner product space has smooth bump functions. -/
instance (priority := 100) hasContDiffBump_of_innerProductSpace : HasContDiffBump E 
goal: HasContDiffBump E
File: Mathlib/Analysis/Calculus/AddTorsor/Coord.lean

full_name: smooth_barycentric_coord
code: theorem smooth_barycentric_coord (b : AffineBasis ι 𝕜 E) (i : ι) : ContDiff 𝕜 ⊤ (b.coord i) 
goal: ContDiff 𝕜 ⊤ ⇑(b.coord i)
File: Mathlib/Analysis/Calculus/AddTorsor/AffineMap.lean

full_name: ContinuousAffineMap.contDiff
code: /-- A continuous affine map between normed vector spaces is smooth. -/
theorem contDiff {n : ℕ∞} (f : V →ᴬ[𝕜] W) : ContDiff 𝕜 n f 
goal: ContDiff 𝕜 n ⇑f
File: Mathlib/Analysis/Calculus/LineDeriv/QuadraticMap.lean

full_name: QuadraticMap.hasLineDerivAt
code: theorem hasLineDerivAt (f : QuadraticMap 𝕜 E F) (a b : E) :
    HasLineDerivAt 𝕜 f (polar f a b) a b 
goal: HasLineDerivAt 𝕜 (⇑f) (QuadraticMap.polar (⇑f) a b) a b

full_name: QuadraticMap.lineDifferentiableAt
code: theorem lineDifferentiableAt (f : QuadraticMap 𝕜 E F) (a b : E) : LineDifferentiableAt 𝕜 f a b 
goal: LineDifferentiableAt 𝕜 (⇑f) a b

full_name: QuadraticMap.lineDeriv
code: @[simp]
protected theorem lineDeriv (f : QuadraticMap 𝕜 E F) : lineDeriv 𝕜 f = polar f 
goal: lineDeriv 𝕜 ⇑f = QuadraticMap.polar ⇑f
File: Mathlib/Analysis/Calculus/LineDeriv/Measurable.lean

full_name: measurableSet_lineDifferentiableAt
code: theorem measurableSet_lineDifferentiableAt (hf : Continuous f) :
    MeasurableSet {x : E | LineDifferentiableAt 𝕜 f x v} 
goal: MeasurableSet {x | LineDifferentiableAt 𝕜 f x v}

full_name: measurable_lineDeriv
code: theorem measurable_lineDeriv [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f) : Measurable (fun x ↦ lineDeriv 𝕜 f x v) 
goal: Measurable fun x => lineDeriv 𝕜 f x v

full_name: stronglyMeasurable_lineDeriv
code: theorem stronglyMeasurable_lineDeriv [SecondCountableTopologyEither E F] (hf : Continuous f) :
    StronglyMeasurable (fun x ↦ lineDeriv 𝕜 f x v) 
goal: MeasureTheory.StronglyMeasurable fun x => lineDeriv 𝕜 f x v

full_name: aemeasurable_lineDeriv
code: theorem aemeasurable_lineDeriv [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f) (μ : Measure E) :
    AEMeasurable (fun x ↦ lineDeriv 𝕜 f x v) μ 
goal: AEMeasurable (fun x => lineDeriv 𝕜 f x v) μ

full_name: aestronglyMeasurable_lineDeriv
code: theorem aestronglyMeasurable_lineDeriv [SecondCountableTopologyEither E F]
    (hf : Continuous f) (μ : Measure E) :
    AEStronglyMeasurable (fun x ↦ lineDeriv 𝕜 f x v) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun x => lineDeriv 𝕜 f x v) μ

full_name: measurableSet_lineDifferentiableAt_uncurry
code: theorem measurableSet_lineDifferentiableAt_uncurry (hf : Continuous f) :
    MeasurableSet {p : E × E | LineDifferentiableAt 𝕜 f p.1 p.2} 
goal: MeasurableSet {p | LineDifferentiableAt 𝕜 f p.1 p.2}

full_name: measurable_lineDeriv_uncurry
code: theorem measurable_lineDeriv_uncurry [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f) : Measurable (fun (p : E × E) ↦ lineDeriv 𝕜 f p.1 p.2) 
goal: Measurable fun p => lineDeriv 𝕜 f p.1 p.2

full_name: stronglyMeasurable_lineDeriv_uncurry
code: theorem stronglyMeasurable_lineDeriv_uncurry (hf : Continuous f) :
    StronglyMeasurable (fun (p : E × E) ↦ lineDeriv 𝕜 f p.1 p.2) 
goal: MeasureTheory.StronglyMeasurable fun p => lineDeriv 𝕜 f p.1 p.2

full_name: aemeasurable_lineDeriv_uncurry
code: theorem aemeasurable_lineDeriv_uncurry [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f) (μ : Measure (E × E)) :
    AEMeasurable (fun (p : E × E) ↦ lineDeriv 𝕜 f p.1 p.2) μ 
goal: AEMeasurable (fun p => lineDeriv 𝕜 f p.1 p.2) μ

full_name: aestronglyMeasurable_lineDeriv_uncurry
code: theorem aestronglyMeasurable_lineDeriv_uncurry (hf : Continuous f) (μ : Measure (E × E)) :
    AEStronglyMeasurable (fun (p : E × E) ↦ lineDeriv 𝕜 f p.1 p.2) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun p => lineDeriv 𝕜 f p.1 p.2) μ
File: Mathlib/Analysis/Calculus/LocalExtr/Rolle.lean

full_name: exists_hasDerivAt_eq_zero
code: /-- **Rolle's Theorem** `HasDerivAt` version -/
theorem exists_hasDerivAt_eq_zero (hab : a < b) (hfc : ContinuousOn f (Icc a b)) (hfI : f a = f b)
    (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x) : ∃ c ∈ Ioo a b, f' c = 0 
goal: ∃ c ∈ Set.Ioo a b, f' c = 0

full_name: exists_deriv_eq_zero
code: /-- **Rolle's Theorem** `deriv` version -/
theorem exists_deriv_eq_zero (hab : a < b) (hfc : ContinuousOn f (Icc a b)) (hfI : f a = f b) :
    ∃ c ∈ Ioo a b, deriv f c = 0 
goal: ∃ c ∈ Set.Ioo a b, deriv f c = 0

full_name: exists_hasDerivAt_eq_zero'
code: /-- **Rolle's Theorem**, a version for a function on an open interval: if `f` has derivative `f'`
on `(a, b)` and has the same limit `l` at `𝓝[>] a` and `𝓝[<] b`, then `f' c = 0`
for some `c ∈ (a, b)`.  -/
theorem exists_hasDerivAt_eq_zero' (hab : a < b) (hfa : Tendsto f (𝓝[>] a) (𝓝 l))
    (hfb : Tendsto f (𝓝[<] b) (𝓝 l)) (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x) :
    ∃ c ∈ Ioo a b, f' c = 0 
goal: ∃ c ∈ Set.Ioo a b, f' c = 0

full_name: exists_deriv_eq_zero'
code: /-- **Rolle's Theorem**, a version for a function on an open interval: if `f` has the same limit
`l` at `𝓝[>] a` and `𝓝[<] b`, then `deriv f c = 0` for some `c ∈ (a, b)`. This version
does not require differentiability of `f` because we define `deriv f c = 0` whenever `f` is not
differentiable at `c`. -/
theorem exists_deriv_eq_zero' (hab : a < b) (hfa : Tendsto f (𝓝[>] a) (𝓝 l))
    (hfb : Tendsto f (𝓝[<] b) (𝓝 l)) : ∃ c ∈ Ioo a b, deriv f c = 0 
goal: ∃ c ∈ Set.Ioo a b, deriv f c = 0
File: Mathlib/Analysis/Calculus/LocalExtr/Polynomial.lean

full_name: Polynomial.card_roots_toFinset_le_card_roots_derivative_diff_roots_succ
code: /-- The number of roots of a real polynomial `p` is at most the number of roots of its derivative
that are not roots of `p` plus one. -/
theorem card_roots_toFinset_le_card_roots_derivative_diff_roots_succ (p : ℝ[X]) :
    p.roots.toFinset.card ≤ (p.derivative.roots.toFinset \ p.roots.toFinset).card + 1 
goal: p.roots.toFinset.card ≤ ((Polynomial.derivative p).roots.toFinset \ p.roots.toFinset).card + 1

full_name: Polynomial.card_roots_toFinset_le_derivative
code: /-- The number of roots of a real polynomial is at most the number of roots of its derivative plus
one. -/
theorem card_roots_toFinset_le_derivative (p : ℝ[X]) :
    p.roots.toFinset.card ≤ p.derivative.roots.toFinset.card + 1 
goal: p.roots.toFinset.card ≤ (Polynomial.derivative p).roots.toFinset.card + 1

full_name: Polynomial.card_roots_le_derivative
code: /-- The number of roots of a real polynomial (counted with multiplicities) is at most the number of
roots of its derivative (counted with multiplicities) plus one. -/
theorem card_roots_le_derivative (p : ℝ[X]) :
    Multiset.card p.roots ≤ Multiset.card (derivative p).roots + 1 
goal: Multiset.card p.roots ≤ Multiset.card (Polynomial.derivative p).roots + 1

full_name: Polynomial.card_rootSet_le_derivative
code: /-- The number of real roots of a polynomial is at most the number of roots of its derivative plus
one. -/
theorem card_rootSet_le_derivative {F : Type*} [CommRing F] [Algebra F ℝ] (p : F[X]) :
    Fintype.card (p.rootSet ℝ) ≤ Fintype.card (p.derivative.rootSet ℝ) + 1 
goal: Fintype.card ↑(p.rootSet ℝ) ≤ Fintype.card ↑((Polynomial.derivative p).rootSet ℝ) + 1
File: Mathlib/Analysis/Calculus/Conformal/InnerProduct.lean

full_name: conformalAt_iff'
code: /-- A real differentiable map `f` is conformal at point `x` if and only if its
    differential `fderiv ℝ f x` at that point scales every inner product by a positive scalar. -/
theorem conformalAt_iff' {f : E → F} {x : E} : ConformalAt f x ↔
    ∃ c : ℝ, 0 < c ∧ ∀ u v : E, ⟪fderiv ℝ f x u, fderiv ℝ f x v⟫ = c * ⟪u, v⟫ 
goal: ConformalAt f x ↔ ∃ c, 0 < c ∧ ∀ (u v : E), ⟪(fderiv ℝ f x) u, (fderiv ℝ f x) v⟫_ℝ = c * ⟪u, v⟫_ℝ

full_name: conformalAt_iff
code: /-- A real differentiable map `f` is conformal at point `x` if and only if its
    differential `f'` at that point scales every inner product by a positive scalar. -/
theorem conformalAt_iff {f : E → F} {x : E} {f' : E →L[ℝ] F} (h : HasFDerivAt f f' x) :
    ConformalAt f x ↔ ∃ c : ℝ, 0 < c ∧ ∀ u v : E, ⟪f' u, f' v⟫ = c * ⟪u, v⟫ 
goal: ConformalAt f x ↔ ∃ c, 0 < c ∧ ∀ (u v : E), ⟪f' u, f' v⟫_ℝ = c * ⟪u, v⟫_ℝ

full_name: conformalFactorAt
code: /-- The conformal factor of a conformal map at some point `x`. Some authors refer to this function
    as the characteristic function of the conformal map. -/
def conformalFactorAt {f : E → F} {x : E} (h : ConformalAt f x) : ℝ 
goal: ℝ

full_name: conformalFactorAt_pos
code: theorem conformalFactorAt_pos {f : E → F} {x : E} (h : ConformalAt f x) : 0 < conformalFactorAt h 
goal: 0 < conformalFactorAt h

full_name: conformalFactorAt_inner_eq_mul_inner'
code: theorem conformalFactorAt_inner_eq_mul_inner' {f : E → F} {x : E} (h : ConformalAt f x) (u v : E) :
    ⟪(fderiv ℝ f x) u, (fderiv ℝ f x) v⟫ = (conformalFactorAt h : ℝ) * ⟪u, v⟫ 
goal: ⟪(fderiv ℝ f x) u, (fderiv ℝ f x) v⟫_ℝ = conformalFactorAt h * ⟪u, v⟫_ℝ

full_name: conformalFactorAt_inner_eq_mul_inner
code: theorem conformalFactorAt_inner_eq_mul_inner {f : E → F} {x : E} {f' : E →L[ℝ] F}
    (h : HasFDerivAt f f' x) (H : ConformalAt f x) (u v : E) :
    ⟪f' u, f' v⟫ = (conformalFactorAt H : ℝ) * ⟪u, v⟫ 
goal: ⟪f' u, f' v⟫_ℝ = conformalFactorAt H * ⟪u, v⟫_ℝ
File: Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean

full_name: ConformalAt
code: /-- A map `f` is said to be conformal if it has a conformal differential `f'`. -/
def ConformalAt (f : X → Y) (x : X) 
goal: Prop

full_name: conformalAt_id
code: theorem conformalAt_id (x : X) : ConformalAt _root_.id x 
goal: ConformalAt id x

full_name: conformalAt_const_smul
code: theorem conformalAt_const_smul {c : ℝ} (h : c ≠ 0) (x : X) : ConformalAt (fun x' : X => c • x') x 
goal: ConformalAt (fun x' => c • x') x

full_name: Subsingleton.conformalAt
code: @[nontriviality]
theorem Subsingleton.conformalAt [Subsingleton X] (f : X → Y) (x : X) : ConformalAt f x 
goal: ConformalAt f x

full_name: conformalAt_iff_isConformalMap_fderiv
code: /-- A function is a conformal map if and only if its differential is a conformal linear map-/
theorem conformalAt_iff_isConformalMap_fderiv {f : X → Y} {x : X} :
    ConformalAt f x ↔ IsConformalMap (fderiv ℝ f x) 
goal: ConformalAt f x ↔ IsConformalMap (fderiv ℝ f x)

full_name: ConformalAt.differentiableAt
code: theorem differentiableAt {f : X → Y} {x : X} (h : ConformalAt f x) : DifferentiableAt ℝ f x 
goal: DifferentiableAt ℝ f x

full_name: ConformalAt.congr
code: theorem congr {f g : X → Y} {x : X} {u : Set X} (hx : x ∈ u) (hu : IsOpen u) (hf : ConformalAt f x)
    (h : ∀ x : X, x ∈ u → g x = f x) : ConformalAt g x 
goal: ConformalAt g x

full_name: ConformalAt.comp
code: theorem comp {f : X → Y} {g : Y → Z} (x : X) (hg : ConformalAt g (f x)) (hf : ConformalAt f x) :
    ConformalAt (g ∘ f) x 
goal: ConformalAt (g ∘ f) x

full_name: ConformalAt.const_smul
code: theorem const_smul {f : X → Y} {x : X} {c : ℝ} (hc : c ≠ 0) (hf : ConformalAt f x) :
    ConformalAt (c • f) x 
goal: ConformalAt (c • f) x

full_name: Conformal
code: /-- A map `f` is conformal if it's conformal at every point. -/
def Conformal (f : X → Y) 
goal: Prop

full_name: conformal_id
code: theorem conformal_id : Conformal (id : X → X) 
goal: Conformal id

full_name: conformal_const_smul
code: theorem conformal_const_smul {c : ℝ} (h : c ≠ 0) : Conformal fun x : X => c • x 
goal: Conformal fun x => c • x

full_name: Conformal.conformalAt
code: theorem conformalAt {f : X → Y} (h : Conformal f) (x : X) : ConformalAt f x 
goal: ConformalAt f x

full_name: Conformal.differentiable
code: theorem differentiable {f : X → Y} (h : Conformal f) : Differentiable ℝ f 
goal: Differentiable ℝ f

full_name: Conformal.comp
code: theorem comp {f : X → Y} {g : Y → Z} (hf : Conformal f) (hg : Conformal g) : Conformal (g ∘ f) 
goal: Conformal (g ∘ f)

full_name: Conformal.const_smul
code: theorem const_smul {f : X → Y} (hf : Conformal f) {c : ℝ} (hc : c ≠ 0) : Conformal (c • f) 
goal: Conformal (c • f)
File: Mathlib/Analysis/Calculus/FDeriv/Pi.lean

full_name: hasFDerivAt_update
code: @[fun_prop]
theorem hasFDerivAt_update (x : ∀ i, E i) {i : ι} (y : E i) :
    HasFDerivAt (Function.update x i) (.pi (Pi.single i (.id 𝕜 (E i)))) y 
goal: HasFDerivAt (Function.update x i) (ContinuousLinearMap.pi (Pi.single i (ContinuousLinearMap.id 𝕜 (E i)))) y

full_name: hasFDerivAt_single
code: @[fun_prop]
theorem hasFDerivAt_single {i : ι} (y : E i) :
    HasFDerivAt (Pi.single i) (.pi (Pi.single i (.id 𝕜 (E i)))) y 
goal: HasFDerivAt (Pi.single i) (ContinuousLinearMap.pi (Pi.single i (ContinuousLinearMap.id 𝕜 (E i)))) y

full_name: fderiv_update
code: theorem fderiv_update (x : ∀ i, E i) {i : ι} (y : E i) :
    fderiv 𝕜 (Function.update x i) y = .pi (Pi.single i (.id 𝕜 (E i))) 
goal: fderiv 𝕜 (Function.update x i) y = ContinuousLinearMap.pi (Pi.single i (ContinuousLinearMap.id 𝕜 (E i)))

full_name: fderiv_single
code: theorem fderiv_single {i : ι} (y : E i) :
    fderiv 𝕜 (Pi.single i) y = .pi (Pi.single i (.id 𝕜 (E i))) 
goal: fderiv 𝕜 (Pi.single i) y = ContinuousLinearMap.pi (Pi.single i (ContinuousLinearMap.id 𝕜 (E i)))
File: Mathlib/Analysis/Calculus/InverseFunctionTheorem/FiniteDimensional.lean

full_name: ApproximatesLinearOn.exists_homeomorph_extension
code: /-- In a real vector space, a function `f` that approximates a linear equivalence on a subset `s`
can be extended to a homeomorphism of the whole space. -/
theorem exists_homeomorph_extension {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F] {s : Set E}
    {f : E → F} {f' : E ≃L[ℝ] F} {c : ℝ≥0} (hf : ApproximatesLinearOn f (f' : E →L[ℝ] F) s c)
    (hc : Subsingleton E ∨ lipschitzExtensionConstant F * c < ‖(f'.symm : F →L[ℝ] E)‖₊⁻¹) :
    ∃ g : E ≃ₜ F, EqOn f g s 
goal: ∃ g, Set.EqOn f (⇑g) s
File: Mathlib/Analysis/Calculus/InverseFunctionTheorem/Deriv.lean

full_name: HasStrictDerivAt.localInverse
code: /-- A function that is inverse to `f` near `a`. -/
abbrev localInverse : 𝕜 → 𝕜 
goal: 𝕜 → 𝕜

full_name: HasStrictDerivAt.map_nhds_eq
code: theorem map_nhds_eq : map f (𝓝 a) = 𝓝 (f a) 
goal: Filter.map f (𝓝 a) = 𝓝 (f a)

full_name: HasStrictDerivAt.to_localInverse
code: theorem to_localInverse : HasStrictDerivAt (hf.localInverse f f' a hf') f'⁻¹ (f a) 
goal: HasStrictDerivAt (HasStrictDerivAt.localInverse f f' a hf hf') f'⁻¹ (f a)

full_name: HasStrictDerivAt.to_local_left_inverse
code: theorem to_local_left_inverse {g : 𝕜 → 𝕜} (hg : ∀ᶠ x in 𝓝 a, g (f x) = x) :
    HasStrictDerivAt g f'⁻¹ (f a) 
goal: HasStrictDerivAt g f'⁻¹ (f a)

full_name: isOpenMap_of_hasStrictDerivAt
code: /-- If a function has a non-zero strict derivative at all points, then it is an open map. -/
theorem isOpenMap_of_hasStrictDerivAt {f' : 𝕜 → 𝕜}
    (hf : ∀ x, HasStrictDerivAt f (f' x) x) (h0 : ∀ x, f' x ≠ 0) : IsOpenMap f 
goal: IsOpenMap f