File: Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean

full_name: expNegInvGlue
code: /-- `expNegInvGlue` is the real function given by `x ↦ exp (-1/x)` for `x > 0` and `0`
for `x ≤ 0`. It is a basic building block to construct smooth partitions of unity. Its main property
is that it vanishes for `x ≤ 0`, it is positive for `x > 0`, and the junction between the two
behaviors is flat enough to retain smoothness. The fact that this function is `C^∞` is proved in
`expNegInvGlue.contDiff`. -/
def expNegInvGlue (x : ℝ) : ℝ 
goal: ℝ

full_name: expNegInvGlue.zero_of_nonpos
code: /-- The function `expNegInvGlue` vanishes on `(-∞, 0]`. -/
theorem zero_of_nonpos {x : ℝ} (hx : x ≤ 0) : expNegInvGlue x = 0 
goal: expNegInvGlue x = 0

full_name: expNegInvGlue.zero
code: @[simp]
protected theorem zero : expNegInvGlue 0 = 0 
goal: expNegInvGlue 0 = 0

full_name: expNegInvGlue.pos_of_pos
code: /-- The function `expNegInvGlue` is positive on `(0, +∞)`. -/
theorem pos_of_pos {x : ℝ} (hx : 0 < x) : 0 < expNegInvGlue x 
goal: 0 < expNegInvGlue x

full_name: expNegInvGlue.nonneg
code: /-- The function `expNegInvGlue` is nonnegative. -/
theorem nonneg (x : ℝ) : 0 ≤ expNegInvGlue x 
goal: 0 ≤ expNegInvGlue x

full_name: expNegInvGlue.zero_iff_nonpos
code: @[simp] theorem zero_iff_nonpos {x : ℝ} : expNegInvGlue x = 0 ↔ x ≤ 0 
goal: expNegInvGlue x = 0 ↔ x ≤ 0

full_name: expNegInvGlue.tendsto_polynomial_inv_mul_zero
code: /-- Our function tends to zero at zero faster than any $P(x^{-1})$, $P∈ℝ[X]$, tends to infinity. -/
theorem tendsto_polynomial_inv_mul_zero (p : ℝ[X]) :
    Tendsto (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) (𝓝 0) (𝓝 0) 
goal: Filter.Tendsto (fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x) (𝓝 0) (𝓝 0)

full_name: expNegInvGlue.hasDerivAt_polynomial_eval_inv_mul
code: theorem hasDerivAt_polynomial_eval_inv_mul (p : ℝ[X]) (x : ℝ) :
    HasDerivAt (fun x ↦ p.eval x⁻¹ * expNegInvGlue x)
      ((X ^ 2 * (p - derivative (R := ℝ) p)).eval x⁻¹ * expNegInvGlue x) x 
goal: HasDerivAt (fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x)
  (Polynomial.eval x⁻¹ (Polynomial.X ^ 2 * (p - Polynomial.derivative p)) * expNegInvGlue x) x

full_name: expNegInvGlue.differentiable_polynomial_eval_inv_mul
code: theorem differentiable_polynomial_eval_inv_mul (p : ℝ[X]) :
    Differentiable ℝ (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) 
goal: Differentiable ℝ fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x

full_name: expNegInvGlue.continuous_polynomial_eval_inv_mul
code: theorem continuous_polynomial_eval_inv_mul (p : ℝ[X]) :
    Continuous (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) 
goal: Continuous fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x

full_name: expNegInvGlue.contDiff_polynomial_eval_inv_mul
code: theorem contDiff_polynomial_eval_inv_mul {n : ℕ∞} (p : ℝ[X]) :
    ContDiff ℝ n (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) 
goal: ContDiff ℝ n fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x

full_name: expNegInvGlue.contDiff
code: /-- The function `expNegInvGlue` is smooth. -/
protected theorem contDiff {n} : ContDiff ℝ n expNegInvGlue 
goal: ContDiff ℝ n expNegInvGlue

full_name: Real.smoothTransition
code: /-- An infinitely smooth function `f : ℝ → ℝ` such that `f x = 0` for `x ≤ 0`,
`f x = 1` for `1 ≤ x`, and `0 < f x < 1` for `0 < x < 1`. -/
def Real.smoothTransition (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.smoothTransition.pos_denom
code: theorem pos_denom (x) : 0 < expNegInvGlue x + expNegInvGlue (1 - x) 
goal: 0 < expNegInvGlue x + expNegInvGlue (1 - x)

full_name: Real.smoothTransition.one_of_one_le
code: theorem one_of_one_le (h : 1 ≤ x) : smoothTransition x = 1 
goal: x.smoothTransition = 1

full_name: Real.smoothTransition.zero_iff_nonpos
code: @[simp]
nonrec theorem zero_iff_nonpos : smoothTransition x = 0 ↔ x ≤ 0 
goal: x.smoothTransition = 0 ↔ x ≤ 0

full_name: Real.smoothTransition.zero_of_nonpos
code: theorem zero_of_nonpos (h : x ≤ 0) : smoothTransition x = 0 
goal: x.smoothTransition = 0

full_name: Real.smoothTransition.zero
code: @[simp]
protected theorem zero : smoothTransition 0 = 0 
goal: Real.smoothTransition 0 = 0

full_name: Real.smoothTransition.one
code: @[simp]
protected theorem one : smoothTransition 1 = 1 
goal: Real.smoothTransition 1 = 1

full_name: Real.smoothTransition.projIcc
code: /-- Since `Real.smoothTransition` is constant on $(-∞, 0]$ and $[1, ∞)$, applying it to the
projection of `x : ℝ` to $[0, 1]$ gives the same result as applying it to `x`. -/
@[simp]
protected theorem projIcc :
    smoothTransition (projIcc (0 : ℝ) 1 zero_le_one x) = smoothTransition x 
goal: (↑(Set.projIcc 0 1 ⋯ x)).smoothTransition = x.smoothTransition

full_name: Real.smoothTransition.le_one
code: theorem le_one (x : ℝ) : smoothTransition x ≤ 1 
goal: x.smoothTransition ≤ 1

full_name: Real.smoothTransition.nonneg
code: theorem nonneg (x : ℝ) : 0 ≤ smoothTransition x 
goal: 0 ≤ x.smoothTransition

full_name: Real.smoothTransition.lt_one_of_lt_one
code: theorem lt_one_of_lt_one (h : x < 1) : smoothTransition x < 1 
goal: x.smoothTransition < 1

full_name: Real.smoothTransition.pos_of_pos
code: theorem pos_of_pos (h : 0 < x) : 0 < smoothTransition x 
goal: 0 < x.smoothTransition

full_name: Real.smoothTransition.contDiff
code: protected theorem contDiff {n} : ContDiff ℝ n smoothTransition 
goal: ContDiff ℝ n Real.smoothTransition

full_name: Real.smoothTransition.contDiffAt
code: protected theorem contDiffAt {x n} : ContDiffAt ℝ n smoothTransition x 
goal: ContDiffAt ℝ n Real.smoothTransition x

full_name: Real.smoothTransition.continuous
code: protected theorem continuous : Continuous smoothTransition 
goal: Continuous Real.smoothTransition

full_name: Real.smoothTransition.continuousAt
code: protected theorem continuousAt : ContinuousAt smoothTransition x 
goal: ContinuousAt Real.smoothTransition x