import Mathlib
/-!
# Formal Calculus

We introduce formal structures for integration and differentiation. Properties should be added to make these mathematically sound. But correctness can be ensured temporarily by making sure individual definitions are correct.

## Formal Integrals
-/

/--
Integrability of `f`, i.e., given an interval `[a, b]`, we can compute the integral of `f` over that interval. Additivity over intervals is also required.
-/
class Integrable: {f : ℝ → ℝ} → (integral : ℝ → ℝ → ℝ) → (∀ (a b c : ℝ), integral a c = integral a b + integral b c) → Integrable f
Integrable (f: ℝ → ℝ
f: ℝ: Type
ℝ → ℝ: Type
ℝ) where
  integral: (f : ℝ → ℝ) → [self : Integrable f] → ℝ → ℝ → ℝ
integral (a: ℝ
a b: ℝ
b : ℝ: Type
ℝ) : ℝ: Type
ℝ  
  interval_union: ∀ {f : ℝ → ℝ} [self : Integrable f] (a b c : ℝ),
  Integrable.integral f a c = Integrable.integral f a b + Integrable.integral f b c
interval_union (a: ℝ
a b: ℝ
b c: ℝ
c : ℝ: Type
ℝ) :
    integral: ℝ → ℝ → ℝ
integral a: ℝ
a c: ℝ
c = integral: ℝ → ℝ → ℝ
integral a: ℝ
a b: ℝ
b + integral: ℝ → ℝ → ℝ
integral b: ℝ
b c: ℝ
c

/-- The integral of a function, with the typeclass derived -/
def integral: (f : ℝ → ℝ) → [int : Integrable f] → (a b : ℝ) → ?m.81 f a b
integral (f: ℝ → ℝ
f: ℝ: Type
ℝ → ℝ: Type
ℝ)[int: Integrable f
int : Integrable: (ℝ → ℝ) → Type
Integrable f: ℝ → ℝ
f]
  (a: ℝ
a b: ℝ
b : ℝ: Type
ℝ ) :=
  int: Integrable f
int.integral: (f : ℝ → ℝ) → [self : Integrable f] → ℝ → ℝ → ℝ
integral a: ℝ
a b: ℝ
b

/-- The integral over a single point is zero, proved as an illustration. -/
theorem integral_point: ∀ (f : ℝ → ℝ) [int : Integrable f] (a : ℝ), integral f a a = 0
integral_point(f: ℝ → ℝ
f: ℝ: Type
ℝ → ℝ: Type
ℝ)[int: Integrable f
int : Integrable: (ℝ → ℝ) → Type
Integrable f: ℝ → ℝ
f]
  (a: ℝ
a : ℝ: Type
ℝ ) : integral: (f : ℝ → ℝ) → [int : Integrable f] → ℝ → ℝ → ℝ
integral f: ℝ → ℝ
f a: ℝ
a a: ℝ
a = 0: ?m.169
0 := by
Goals accomplished! 🐙
    f: ℝ → ℝ

int: Integrable f

a: ℝ

integral f a a = 0unfold integral: (f : ℝ → ℝ) → [int : Integrable f] → ℝ → ℝ → ℝ
integralf: ℝ → ℝ

int: Integrable f

a: ℝ

Integrable.integral f a a = 0
    f: ℝ → ℝ

int: Integrable f

a: ℝ

integral f a a = 0have l: ?m.216
l := int: Integrable f
int.interval_union: ∀ {f : ℝ → ℝ} [self : Integrable f] (a b c : ℝ),
  Integrable.integral f a c = Integrable.integral f a b + Integrable.integral f b c
interval_union a: ℝ
a a: ℝ
a a: ℝ
af: ℝ → ℝ

int: Integrable f

a: ℝ

l: Integrable.integral f a a = Integrable.integral f a a + Integrable.integral f a a

Integrable.integral f a a = 0
    f: ℝ → ℝ

int: Integrable f

a: ℝ

integral f a a = 0simp  at l: ?m.216
lf: ℝ → ℝ

int: Integrable f

a: ℝ

l: Integrable.integral f a a = 0

Integrable.integral f a a = 0
    f: ℝ → ℝ

int: Integrable f

a: ℝ

integral f a a = 0assumption
Goals accomplished! 🐙

/-!
As an exercise, prove that flip ends of an interval gives the negative of the integral.
-/

/-!
## Formal Derivatives

We define so called __one-jets__ as a value and a derivative at a point. A differentiable function has values a one-jet at each point.
-/

/--
A _one-jet_ is a value and a derivative at a point.
-/
structure OneJet: Type
OneJet where
  value: OneJet → ℝ
value : ℝ: Type
ℝ
  derivative: OneJet → ℝ
derivative : ℝ: Type
ℝ

/--
A differentiable function is a function that has a one-jet at each point.
-/
structure SmoothFunction: Type
SmoothFunction where
  jet: SmoothFunction → ℝ → OneJet
jet: ℝ: Type
ℝ → OneJet: Type
OneJet 

/--
Derivative of a smooth function, i.e., the derivative of the one-jet at a point.
-/
def SmoothFunction.derivative: SmoothFunction → ℝ → ℝ
SmoothFunction.derivative (f: SmoothFunction
f: SmoothFunction: Type
SmoothFunction) : ℝ: Type
ℝ → ℝ: Type
ℝ := 
  fun x: ?m.863
x ↦ f: SmoothFunction
f.jet: SmoothFunction → ℝ → OneJet
jet (x: ?m.863
x) |>.derivative: OneJet → ℝ
derivative

/-- 
The value of a smooth function, i.e., the value of the one-jet at a point.
-/
def SmoothFunction.value: SmoothFunction → ℝ → ℝ
SmoothFunction.value (f: SmoothFunction
f: SmoothFunction: Type
SmoothFunction) : ℝ: Type
ℝ → ℝ: Type
ℝ := 
  fun x: ?m.922
x ↦ f: SmoothFunction
f.jet: SmoothFunction → ℝ → OneJet
jet (x: ?m.922
x) |>.value: OneJet → ℝ
value

/--
Integrable functions can be obtained from smooth functions via the fundamental theorem of calculus.
-/
instance fundThm: (f : SmoothFunction) → Integrable (SmoothFunction.derivative f)
fundThm (f: SmoothFunction
f: SmoothFunction: Type
SmoothFunction) :
  Integrable: (ℝ → ℝ) → Type
Integrable (f: SmoothFunction
f.derivative: SmoothFunction → ℝ → ℝ
derivative) where
  integral (a: ?m.980
a b: ?m.983
b) := f: SmoothFunction
f.value: SmoothFunction → ℝ → ℝ
value b: ?m.983
b - f: SmoothFunction
f.value: SmoothFunction → ℝ → ℝ
value a: ?m.980
a
  interval_union (a: ?m.1034
a b: ?m.1037
b c: ?m.1040
c) := by
Goals accomplished! 🐙
    f: SmoothFunction

a, b, c: ℝ

(fun a b => SmoothFunction.value f b - SmoothFunction.value f a) a c =   (fun a b => SmoothFunction.value f b - SmoothFunction.value f a) a b +     (fun a b => SmoothFunction.value f b - SmoothFunction.value f a) b csimp [integral: (f : ℝ → ℝ) → [int : Integrable f] → ℝ → ℝ → ℝ
integral]
Goals accomplished! 🐙

/-!
## Constructions of smooth functions

To use the above we need to construct a few smooth functions
-/

namespace SmoothFunction

/--
Constant functions as smooth functions.
-/
def constant: ℝ → SmoothFunction
constant (c: ℝ
c : ℝ: Type
ℝ) : SmoothFunction: Type
SmoothFunction := 
  ⟨fun _: ?m.1717
_ ↦ ⟨c: ℝ
c, 0: ?m.1722
0⟩⟩

/--
Sum of smooth functions.
-/
def sum: SmoothFunction → SmoothFunction → SmoothFunction
sum (f: SmoothFunction
f g: SmoothFunction
g : SmoothFunction: Type
SmoothFunction) : SmoothFunction: Type
SmoothFunction := 
  ⟨fun x: ?m.1825
x ↦ ⟨f: SmoothFunction
f.value: SmoothFunction → ℝ → ℝ
value x: ?m.1825
x + g: SmoothFunction
g.value: SmoothFunction → ℝ → ℝ
value x: ?m.1825
x, f: SmoothFunction
f.derivative: SmoothFunction → ℝ → ℝ
derivative x: ?m.1825
x + g: SmoothFunction
g.derivative: SmoothFunction → ℝ → ℝ
derivative x: ?m.1825
x⟩⟩

/--
Product of smooth functions using Liebnitz rule.
-/
def prod: SmoothFunction → SmoothFunction → SmoothFunction
prod (f: SmoothFunction
f g: SmoothFunction
g : SmoothFunction: Type
SmoothFunction) : SmoothFunction: Type
SmoothFunction :=
  ⟨fun x: ?m.2030
x ↦ ⟨f: SmoothFunction
f.value: SmoothFunction → ℝ → ℝ
value x: ?m.2030
x * g: SmoothFunction
g.value: SmoothFunction → ℝ → ℝ
value x: ?m.2030
x, f: SmoothFunction
f.derivative: SmoothFunction → ℝ → ℝ
derivative x: ?m.2030
x * g: SmoothFunction
g.value: SmoothFunction → ℝ → ℝ
value x: ?m.2030
x + f: SmoothFunction
f.value: SmoothFunction → ℝ → ℝ
value x: ?m.2030
x * g: SmoothFunction
g.derivative: SmoothFunction → ℝ → ℝ
derivative x: ?m.2030
x⟩⟩

/--
Product of a scalar and a smooth function.
-/
def scalarProd: ℝ → SmoothFunction → SmoothFunction
scalarProd (c: ℝ
c : ℝ: Type
ℝ) (f: SmoothFunction
f : SmoothFunction: Type
SmoothFunction) : SmoothFunction: Type
SmoothFunction :=
  ⟨fun x: ?m.2363
x ↦ ⟨c: ℝ
c * f: SmoothFunction
f.value: SmoothFunction → ℝ → ℝ
value x: ?m.2363
x, c: ℝ
c * f: SmoothFunction
f.derivative: SmoothFunction → ℝ → ℝ
derivative x: ?m.2363
x⟩⟩

/-- Addition operation on smooth functions -/
instance: Add SmoothFunction
instance : Add: Type ?u.2547 → Type ?u.2547
Add SmoothFunction: Type
SmoothFunction := ⟨sum: SmoothFunction → SmoothFunction → SmoothFunction
sum⟩
/-- Multiplication operation on smooth functions -/
instance: Mul SmoothFunction
instance : Mul: Type ?u.2621 → Type ?u.2621
Mul SmoothFunction: Type
SmoothFunction := ⟨prod: SmoothFunction → SmoothFunction → SmoothFunction
prod⟩
/-- Scalar multiplication for smooth functions -/
instance: SMul ℝ SmoothFunction
instance : SMul: Type ?u.2696 → Type ?u.2695 → Type (max?u.2696?u.2695)
SMul ℝ: Type
ℝ SmoothFunction: Type
SmoothFunction := ⟨scalarProd: ℝ → SmoothFunction → SmoothFunction
scalarProd⟩

/-!
This gives polynomial functions as a special case. As an exercise, prove that smooth functions form a Ring (indeed an Algebra over ℝ).

We will define some polynomials as smooth functions as an example.
-/

/-- The coordinate function -/
def x: SmoothFunction
x : SmoothFunction: Type
SmoothFunction := ⟨fun x: ?m.2774
x ↦ ⟨x: ?m.2774
x, 1: ?m.2779
1⟩⟩

/-- The power function for a smooth function (automatic if ring is proved) -/
def pow: SmoothFunction → ℕ → SmoothFunction
pow (f: SmoothFunction
f: SmoothFunction: Type
SmoothFunction): ℕ: Type
ℕ →  SmoothFunction: Type
SmoothFunction
| 0: ℕ
0 => constant: ℝ → SmoothFunction
constant 1: ?m.2881
1
| n: ℕ
n + 1 => f: SmoothFunction
f * (pow: SmoothFunction → ℕ → SmoothFunction
pow f: SmoothFunction
f n: ℕ
n)

instance: HPow SmoothFunction ℕ SmoothFunction
instance : HPow: Type ?u.3296 → Type ?u.3295 → outParam (Type ?u.3294) → Type (max(max?u.3296?u.3295)?u.3294)
HPow SmoothFunction: Type
SmoothFunction ℕ: Type
ℕ SmoothFunction: Type
SmoothFunction  := ⟨pow: SmoothFunction → ℕ → SmoothFunction
pow⟩ 

instance: Coe ℝ SmoothFunction
instance : Coe: Sort ?u.3386 → Sort ?u.3385 → Sort (max(max1?u.3386)?u.3385)
Coe ℝ: Type
ℝ SmoothFunction: Type
SmoothFunction := ⟨constant: ℝ → SmoothFunction
constant⟩

/-- A polynomial. We can have cleaner notation but the goal is to illustrate the construction -/
def poly: ?m.3439
poly := (2: ?m.3457
2 : ℝ: Type
ℝ) •  x: SmoothFunction
x + (3: ?m.3520
3 : ℝ: Type
ℝ) • x: SmoothFunction
x^3: ?m.3539
3 + (7: ?m.4419
7: ℝ: Type
ℝ)


end SmoothFunction