From 529cdeea125a0bccbf80fbe005f424469ab5d017 Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Tue, 7 May 2024 19:06:46 +0000 Subject: [PATCH] build based on 5830a94 --- dev/.documenter-siteinfo.json | 2 +- dev/api.html | 8 ++++---- dev/index.html | 2 +- dev/reading_list.html | 2 +- dev/terminology.pdf | Bin 416554 -> 416554 bytes 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/dev/.documenter-siteinfo.json b/dev/.documenter-siteinfo.json index aaefdd7..2a21113 100644 --- a/dev/.documenter-siteinfo.json +++ b/dev/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.10.3","generation_timestamp":"2024-05-03T12:47:16","documenter_version":"1.1.2"}} \ No newline at end of file +{"documenter":{"julia_version":"1.10.3","generation_timestamp":"2024-05-07T19:06:42","documenter_version":"1.1.2"}} \ No newline at end of file diff --git a/dev/api.html b/dev/api.html index 76d8a62..065c244 100644 --- a/dev/api.html +++ b/dev/api.html @@ -5,9 +5,9 @@ := a + b ∂/∂¹ := a + b ∂₁

These are all definitional equivalences and we will mostly work with the final form. An important thing to keep in mind though is that the subscript on ∂₁ does not refer to a dimension of the underlying base manifold (for which we will rarely pick an explicit basis here), but rather tags the basis of the tangent bundle.

Let us iterate this construction to second order. We have:

T²B = T¹(T¹B) = { (α, β) | α ∈ T¹B, β ∈ T_α T¹B }
               = { ((a, b), (c, d)) | a ∈ B, b ∈ Tₐ B, c ∈ Tₐ B, d ∈ T²ₐ B}

(where in the last equality we used the linearity of the tangent vector).

Following our above notation, we will canonically write such an element as:

  a + b ∂₁ + c ∂₂ + d ∂₂ ∂₁
-= a + b ∂₁ + c ∂₂ + d ∂₁ ∂₂

It is worth noting that there still only is one base point a of the underlying manifold and thus TⁿB is a vector bundle over B for all N.

Further Reading

[1] https://en.wikipedia.org/wiki/Tangent_bundle

source
Diffractor.ExplicitTangent — Type
struct ExplicitTangent{P}

A fully explicit coordinate representation of the tangent space, represented by a vector of 2^N-1 partials.

source
Diffractor.Jet — Type
struct Jet{T, N}

Represents the truncated (N-1)-th order Taylor series

f(a) + (x-a)f'(a) + 1/2(x-a)^2f''(a) + ...

Coefficients are stored in unscaled form. For a jet j, several operations are supported:

  1. Indexing j[i] returns fᵢ
  2. Evaluation j(x) semantically evaluates the truncated taylor series at x. However, evaluation is restricted to be precisely at a - the additional information in the taylor series is only available through derivatives. Mathematically this corresponds to an infinitessimal ball around a.
source
Diffractor.TangentBundle — Type
struct TangentBundle{N, B, P}

Represents a tangent bundle as an explicit primal together with some representation of the tangent space.

source
Diffractor.TaylorTangent — Type
struct TaylorTangent{C}

The taylor bundle construction mods out the full N-th order tangent bundle by the equivalence relation that coefficients of like-order basis elements be equal, i.e. rather than a generic element

a + b ∂₁ + c ∂₂ + d ∂₃ + e ∂₂ ∂₁ + f ∂₃ ∂₁ + g ∂₃ ∂₂ + h ∂₃ ∂₂ ∂₁

we have a tuple (c₀, c₁, c₂, c₃) corresponding to the full element

c₀ + c₁ ∂₁ + c₁ ∂₂ + c₁ ∂₃ + c₂ ∂₂ ∂₁ + c₂ ∂₃ ∂₁ + c₂ ∂₃ ∂₂ + c₃ ∂₃ ∂₂ ∂₁

i.e.

c₀ + c₁ (∂₁ + ∂₂ + ∂₃) + c₂ (∂₂ ∂₁ + ∂₃ ∂₁ + ∂₃ ∂₂) + c₃ ∂₃ ∂₂ ∂₁

This restriction forms a submanifold of the original manifold. The naming is by analogy with the (truncated) Taylor series

c₀ + c₁ x + 1/2 c₂ x² + 1/3! c₃ x³ + O(x⁴)
source
Diffractor.UniformTangent — Type
struct UniformTangent

Represents an N-th order tangent bundle with all unform partials. Particularly useful for representing singleton values.

source
Diffractor.zero_bundle — Type
(::zero_bundle{N})(primal)

Creates a bundle with a zero tangent.

source
Diffractor.∂xⁿ — Type
∂xⁿ{N}(x)

For x in a one dimensional manifold, map x to the trivial, unital, Nth order tangent bundle. It should hold that ∀x ⟨∂ⁿ{1}x(x), dx(x)⟩ = 1

source
Diffractor.∂⃖ — Type
∂⃖{N}

∂⃖{N} is the reverse-mode AD optic functor of order N. A call (::∂⃖{N})(f, args...) corresponds to ∂⃖ⁿ f(args...) in the linear encoding of an N-optic (see the terminology guide for definitions of these terms).

In general (::∂⃖{N})(f, args...) will return a tuple of the original primal value f(args...) (in rare cases primitives may modify the primal value - in general we will ignore this rare complication for the purposes of clear documentation) and an optic continuation λ. The interpretation of this continuation depends on the order of the functor:

For example, ∂⃖{1} computes first derivatives. In particular, for a function f, ∂⃖{1}(f, args...) will return the tuple (f(args...), f⋆) (read "f upper-star").

source
Diffractor.∂☆ — Type
∂☆{N,E}

∂☆{N} is the forward-mode AD functor of order N (An integer). A call (::∂☆{N})(f, args...) evaluating a function f: A -> B is lifted to its pushforward on the N-th order tangent bundle f⋆: Tⁿ A -> Tⁿ B.

!!!advanced "Eras Mode" E (a bool, default false) is for Eras mode. In Eras mode, we are Taylor or bust. Normally if a particular derivative can not be represented as a TaylorBundle we fall back and represent it as a ExplictTangentBundle. However, in Eras mode we error if it can't be represented as a TaylorBundle. In general, this is not wanted since it often will break nested AD. But in the cases it doesn't its really fast, since it means we can rewrite nested AD as Taylor-mode AD (plus its more type stable). To be safe in Eras mode, it is sufficient, but not necessary, to be doing nested AD with respect to the same variable. It also works in other cases where (likely by problem construction) ADing with respect to a second variable happens to result in something that can be represented with a TaylorBundle also. (You need your different partials to happen to be exactly equal).

source
Diffractor.∇ — Type
∇(f, args...)

Computes the gradient ∇f(x, y, z...) (at (x, y, z...)). In particular, the return value will be a tuple of partial derivatives (∂f/∂x, ∂f/∂y, ∂f/∂z...).

Curried version

Alternatively, ∇ may be curried, essentially giving the gradient as a function:

Examples

julia> using Diffractor: ∇
+= a + b ∂₁ + c ∂₂ + d ∂₁ ∂₂

It is worth noting that there still only is one base point a of the underlying manifold and thus TⁿB is a vector bundle over B for all N.

Further Reading

[1] https://en.wikipedia.org/wiki/Tangent_bundle

source
Diffractor.ExplicitTangent — Type
struct ExplicitTangent{P}

A fully explicit coordinate representation of the tangent space, represented by a vector of 2^N-1 partials.

source
Diffractor.Jet — Type
struct Jet{T, N}

Represents the truncated (N-1)-th order Taylor series

f(a) + (x-a)f'(a) + 1/2(x-a)^2f''(a) + ...

Coefficients are stored in unscaled form. For a jet j, several operations are supported:

  1. Indexing j[i] returns fᵢ
  2. Evaluation j(x) semantically evaluates the truncated taylor series at x. However, evaluation is restricted to be precisely at a - the additional information in the taylor series is only available through derivatives. Mathematically this corresponds to an infinitessimal ball around a.
source
Diffractor.TangentBundle — Type
struct TangentBundle{N, B, P}

Represents a tangent bundle as an explicit primal together with some representation of the tangent space.

source
Diffractor.TaylorTangent — Type
struct TaylorTangent{C}

The taylor bundle construction mods out the full N-th order tangent bundle by the equivalence relation that coefficients of like-order basis elements be equal, i.e. rather than a generic element

a + b ∂₁ + c ∂₂ + d ∂₃ + e ∂₂ ∂₁ + f ∂₃ ∂₁ + g ∂₃ ∂₂ + h ∂₃ ∂₂ ∂₁

we have a tuple (c₀, c₁, c₂, c₃) corresponding to the full element

c₀ + c₁ ∂₁ + c₁ ∂₂ + c₁ ∂₃ + c₂ ∂₂ ∂₁ + c₂ ∂₃ ∂₁ + c₂ ∂₃ ∂₂ + c₃ ∂₃ ∂₂ ∂₁

i.e.

c₀ + c₁ (∂₁ + ∂₂ + ∂₃) + c₂ (∂₂ ∂₁ + ∂₃ ∂₁ + ∂₃ ∂₂) + c₃ ∂₃ ∂₂ ∂₁

This restriction forms a submanifold of the original manifold. The naming is by analogy with the (truncated) Taylor series

c₀ + c₁ x + 1/2 c₂ x² + 1/3! c₃ x³ + O(x⁴)
source
Diffractor.UniformTangent — Type
struct UniformTangent

Represents an N-th order tangent bundle with all unform partials. Particularly useful for representing singleton values.

source
Diffractor.zero_bundle — Type
(::zero_bundle{N})(primal)

Creates a bundle with a zero tangent.

source
Diffractor.∂xⁿ — Type
∂xⁿ{N}(x)

For x in a one dimensional manifold, map x to the trivial, unital, Nth order tangent bundle. It should hold that ∀x ⟨∂ⁿ{1}x(x), dx(x)⟩ = 1

source
Diffractor.∂⃖ — Type
∂⃖{N}

∂⃖{N} is the reverse-mode AD optic functor of order N. A call (::∂⃖{N})(f, args...) corresponds to ∂⃖ⁿ f(args...) in the linear encoding of an N-optic (see the terminology guide for definitions of these terms).

In general (::∂⃖{N})(f, args...) will return a tuple of the original primal value f(args...) (in rare cases primitives may modify the primal value - in general we will ignore this rare complication for the purposes of clear documentation) and an optic continuation λ. The interpretation of this continuation depends on the order of the functor:

For example, ∂⃖{1} computes first derivatives. In particular, for a function f, ∂⃖{1}(f, args...) will return the tuple (f(args...), f⋆) (read "f upper-star").

source
Diffractor.∂☆ — Type
∂☆{N,E}

∂☆{N} is the forward-mode AD functor of order N (An integer). A call (::∂☆{N})(f, args...) evaluating a function f: A -> B is lifted to its pushforward on the N-th order tangent bundle f⋆: Tⁿ A -> Tⁿ B.

!!!advanced "Eras Mode" E (a bool, default false) is for Eras mode. In Eras mode, we are Taylor or bust. Normally if a particular derivative can not be represented as a TaylorBundle we fall back and represent it as a ExplictTangentBundle. However, in Eras mode we error if it can't be represented as a TaylorBundle. In general, this is not wanted since it often will break nested AD. But in the cases it doesn't its really fast, since it means we can rewrite nested AD as Taylor-mode AD (plus its more type stable). To be safe in Eras mode, it is sufficient, but not necessary, to be doing nested AD with respect to the same variable. It also works in other cases where (likely by problem construction) ADing with respect to a second variable happens to result in something that can be represented with a TaylorBundle also. (You need your different partials to happen to be exactly equal).

source
Diffractor.∇ — Type
∇(f, args...)

Computes the gradient ∇f(x, y, z...) (at (x, y, z...)). In particular, the return value will be a tuple of partial derivatives (∂f/∂x, ∂f/∂y, ∂f/∂z...).

Curried version

Alternatively, ∇ may be curried, essentially giving the gradient as a function:

Examples

julia> using Diffractor: ∇
 
 julia> map(∇(*), (1,2,3), (4,5,6))
-((4.0, 1.0), (5.0, 2.0), (6.0, 3.0))

The derivative ∂f/∂f

Note that since in Julia, there is no distinction between functions and values, there is in principle a partial derivative with respect to the function itself. However, said partial derivative is dropped by this interface. It is however available using the lower level ∂⃖ if desired. This interaction can also be used to obtain gradients with respect to only some of the arguments by using a closure:

∇((x,z)->f(x,y,z))(x, z) # returns (∂f/∂x, ∂f/∂z)

Though of course the same can be obtained by simply indexing the resulting tuple (in well-inferred code there should not be a performance difference between these two options).

source
Diffractor.:' — Method
f'

This is a convenience syntax for taking the derivative of a function f: ℝ -> ℝ. In particular, for such a function f'(x) will be the first derivative of f at x (and similar for f''(x) and second derivatives and so on.)

Note that the syntax conflicts with the Base definition for the adjoint of a matrix and thus is not enabled by default. To use it, add the following to the top of your module:

using Diffractor: var"'"

It is also available using the @∂ macro:

@∂ f'(x)
source
Diffractor.bundle — Function
bundle(primal, tangent)

Wraps a primal up with a tangent into the appropriate kind of AbstractBundle{1}. This is more or less the Diffractor equivelent of ForwardDiff.jl's Dual type.

source
Diffractor.destructure — Method

for a TaylorTangent{N, <:Tuple} this breaks it up unto 1 TaylorTangent{N} for each element of the primal tuple

source
Diffractor.dx — Method
dx(x)

dx represents the trival differential one-form of a one dimensional Riemannian manifold M. In particular, it is a section of the cotangent bundle of M, meaning it may be evaluted at a point x of M to obtain an element of the cotangent space T*ₓ M to M at x. We impose no restrictions on the representations of either the manifold itself or the cotangent space.

By default, the only implementation provided identifies T*ₓ ℝ ≃ ℝ, keeping watever type is used to represent ℝ. i.e.

dx(x::Real) = one(x)

However, users may provide additional overloads for custom representations of one dimensional Riemannian manifolds.

source
Diffractor.find_end_of_phi_block — Method
find_end_of_phi_block(ir::IRCode, start_search_idx::Int)

Finds the last index within the same basic block, on or after the start_search_idx which is not within a phi block. A phi-block is a run on PhiNodes or nothings that must be the first statements within the basic block.

If start_search_idx is not within a phi block to begin with, then just returns start_search_idx

source
Diffractor.find_taylor_incompatibility — Method

finds the lowerest order derivative that is not taylor compatible, or returns -1 if all compatible

source
Diffractor.forward_diff_no_inf! — Method
forward_diff_no_inf!(ir::IRCode, to_diff::Vector{Pair{SSAValue,Int}}; visit_custom!, transform!)

Internal method which generates the code for forward mode diffentiation

  • ir the IR being differnetation

  • to_diff: collection of all SSA values for which the derivative is to be taken, paired with the order (first deriviative, second derivative etc)

  • visit_custom!(ir::IRCode, ssa, order::Int, recurse::Bool) -> Bool:

	decides if the custom `transform!` should be applied to a `stmt` or not
-	Default: `false` for all statements
  • transform!(ir::IRCode, ssa::SSAValue, order::Int) mutates ir to do a custom tranformation.
  • eras_mode: determines if to error if not all derivatives are taylor
source
Diffractor.jet_taylor_ev — Method
jet_taylor_ev(::Val{}, jet, taylor)

Generates a closed form arithmetic expression for the N-th component of the action of a 1d jet (of order at least N) on a maximally symmetric (i.e. taylor) tangent bundle element. In particular, if we represent both the jet and the taylor tangent bundle element by their associated canonical taylor series:

j = j₀ + j₁ (x - a) + j₂ 1/2 (x - a)^2 + ... + jₙ 1/n! (x - a)^n
-t = t₀ + t₁ (x - t₀) + t₂ 1/2 (x - t₀)^2 + ... + tₙ 1/n! (x - t₀)^n

then the action of evaluating j on t, is some other taylor series

t′ = a + t′₁ (x - a) + t′₂ 1/2 (x - a)^2 + ... + t′ₙ 1/n! (x - a)^n

The t′ᵢ can be found by explicitly plugging in t for every x and expanding out, dropping terms of orders that are higher. This computes closed form expressions for the t′ᵢ that are hopefully easier on the compiler.

source
Diffractor.@∂ — Macro
@∂

Convenice macro for writing partial derivatives. E.g. The expression:

@∂ f(∂x, ∂y)

Will compute the partial derivative ∂^2 f/∂x∂y at (x, y)`. And similarly

@∂ f(∂²x, ∂y)

will compute the derivative ∂^3 f/∂x^2 ∂y at (x,y).

source
+((4.0, 1.0), (5.0, 2.0), (6.0, 3.0))

The derivative ∂f/∂f

Note that since in Julia, there is no distinction between functions and values, there is in principle a partial derivative with respect to the function itself. However, said partial derivative is dropped by this interface. It is however available using the lower level ∂⃖ if desired. This interaction can also be used to obtain gradients with respect to only some of the arguments by using a closure:

∇((x,z)->f(x,y,z))(x, z) # returns (∂f/∂x, ∂f/∂z)

Though of course the same can be obtained by simply indexing the resulting tuple (in well-inferred code there should not be a performance difference between these two options).

source
Diffractor.:' — Method
f'

This is a convenience syntax for taking the derivative of a function f: ℝ -> ℝ. In particular, for such a function f'(x) will be the first derivative of f at x (and similar for f''(x) and second derivatives and so on.)

Note that the syntax conflicts with the Base definition for the adjoint of a matrix and thus is not enabled by default. To use it, add the following to the top of your module:

using Diffractor: var"'"

It is also available using the @∂ macro:

@∂ f'(x)
source
Diffractor.bundle — Function
bundle(primal, tangent)

Wraps a primal up with a tangent into the appropriate kind of AbstractBundle{1}. This is more or less the Diffractor equivelent of ForwardDiff.jl's Dual type.

source
Diffractor.destructure — Method

for a TaylorTangent{N, <:Tuple} this breaks it up unto 1 TaylorTangent{N} for each element of the primal tuple

source
Diffractor.dx — Method
dx(x)

dx represents the trival differential one-form of a one dimensional Riemannian manifold M. In particular, it is a section of the cotangent bundle of M, meaning it may be evaluted at a point x of M to obtain an element of the cotangent space T*ₓ M to M at x. We impose no restrictions on the representations of either the manifold itself or the cotangent space.

By default, the only implementation provided identifies T*ₓ ℝ ≃ ℝ, keeping watever type is used to represent ℝ. i.e.

dx(x::Real) = one(x)

However, users may provide additional overloads for custom representations of one dimensional Riemannian manifolds.

source
Diffractor.find_end_of_phi_block — Method
find_end_of_phi_block(ir::IRCode, start_search_idx::Int)

Finds the last index within the same basic block, on or after the start_search_idx which is not within a phi block. A phi-block is a run on PhiNodes or nothings that must be the first statements within the basic block.

If start_search_idx is not within a phi block to begin with, then just returns start_search_idx

source
Diffractor.find_taylor_incompatibility — Method

finds the lowerest order derivative that is not taylor compatible, or returns -1 if all compatible

source
Diffractor.forward_diff_no_inf! — Method
forward_diff_no_inf!(ir::IRCode, to_diff::Vector{Pair{SSAValue,Int}}; visit_custom!, transform!)

Internal method which generates the code for forward mode diffentiation

  • ir the IR being differnetation

  • to_diff: collection of all SSA values for which the derivative is to be taken, paired with the order (first deriviative, second derivative etc)

  • visit_custom!(ir::IRCode, ssa, order::Int, recurse::Bool) -> Bool:

	decides if the custom `transform!` should be applied to a `stmt` or not
+	Default: `false` for all statements
  • transform!(ir::IRCode, ssa::SSAValue, order::Int) mutates ir to do a custom tranformation.
  • eras_mode: determines if to error if not all derivatives are taylor
source
Diffractor.jet_taylor_ev — Method
jet_taylor_ev(::Val{}, jet, taylor)

Generates a closed form arithmetic expression for the N-th component of the action of a 1d jet (of order at least N) on a maximally symmetric (i.e. taylor) tangent bundle element. In particular, if we represent both the jet and the taylor tangent bundle element by their associated canonical taylor series:

j = j₀ + j₁ (x - a) + j₂ 1/2 (x - a)^2 + ... + jₙ 1/n! (x - a)^n
+t = t₀ + t₁ (x - t₀) + t₂ 1/2 (x - t₀)^2 + ... + tₙ 1/n! (x - t₀)^n

then the action of evaluating j on t, is some other taylor series

t′ = a + t′₁ (x - a) + t′₂ 1/2 (x - a)^2 + ... + t′ₙ 1/n! (x - a)^n

The t′ᵢ can be found by explicitly plugging in t for every x and expanding out, dropping terms of orders that are higher. This computes closed form expressions for the t′ᵢ that are hopefully easier on the compiler.

source
Diffractor.@∂ — Macro
@∂

Convenice macro for writing partial derivatives. E.g. The expression:

@∂ f(∂x, ∂y)

Will compute the partial derivative ∂^2 f/∂x∂y at (x, y)`. And similarly

@∂ f(∂²x, ∂y)

will compute the derivative ∂^3 f/∂x^2 ∂y at (x,y).

source
diff --git a/dev/index.html b/dev/index.html index e82cc13..de25f12 100644 --- a/dev/index.html +++ b/dev/index.html @@ -17,4 +17,4 @@ 3×3 Matrix{Float64}: 1.0 0.0 0.0 0.0 1.0 0.0 - 0.0 0.0 1.0 + 0.0 0.0 1.0 diff --git a/dev/reading_list.html b/dev/reading_list.html index 6c40bb5..9703ee2 100644 --- a/dev/reading_list.html +++ b/dev/reading_list.html @@ -1,2 +1,2 @@ -Reading List · Diffractor
GitHub

This is a list of references I found useful while thinking about Diffractor. If you are new to Julia, AD or Diffractor and are primarily intersted in Diffractor, how it works, how to use it, or even the general Diffractor theory, this is probably not the list for you. As always in the literature, some of these references use terms differently from how they are used in Diffractor (as well as being inconsistent with each other). Additionally, many of these references are quite dense and though I've found small nuggets of insight in each, excavating those took many hours. Also, these are not introductory texts. If you've not taken an introductory differential geometry course, I would recommend looking for that first. Don't feel bad if some of these references read like like nonsense. It often reads that way to me too.

Reading on Optics

  • "Categories of Optics" - Mitchell Riley - https://arxiv.org/abs/1809.00738

The original paper on optics. Good background for understanding the optics terminology.

Readings on First Order Differential Geometry

  • "Introduction to Smooth Manifolds" John M. Lee

Chapter 11 "The Cotangent Bundle" is useful for a reference on the theory of cotangent bundles, which corresponds to the structure of reverse mode AD through the optical equivalence. Also a useful general reference for Differential Geomtry.

  • "Natural Operations in Differential Geometry" - Ivan Kolář

I recommend Chapter IV. "Jets and Natural bundles"

Readings on Higher Order Differential Geometry

  • "Second Order Tangent Vectors in Riemannian Geometry", Fisher and Laquer, J. Korean Math Soc 36 (1999)

This one is quite good. I recommend reading the first half at least and tracing through the definitions. This corresponds fairly closely to notion of iterated tangent spaces as implemented in Diffractor.

  • "The Geometry of Jet Bundles" D. J. Saunders

I recommend reading Chapter 5 "Second order Jet bundles", though of course some earlier chapters may be useful to understand this chapter. I'm not 100% happy with the notation, but it gives good intuition.

+Reading List · Diffractor
GitHub

This is a list of references I found useful while thinking about Diffractor. If you are new to Julia, AD or Diffractor and are primarily intersted in Diffractor, how it works, how to use it, or even the general Diffractor theory, this is probably not the list for you. As always in the literature, some of these references use terms differently from how they are used in Diffractor (as well as being inconsistent with each other). Additionally, many of these references are quite dense and though I've found small nuggets of insight in each, excavating those took many hours. Also, these are not introductory texts. If you've not taken an introductory differential geometry course, I would recommend looking for that first. Don't feel bad if some of these references read like like nonsense. It often reads that way to me too.

Reading on Optics

  • "Categories of Optics" - Mitchell Riley - https://arxiv.org/abs/1809.00738

The original paper on optics. Good background for understanding the optics terminology.

Readings on First Order Differential Geometry

  • "Introduction to Smooth Manifolds" John M. Lee

Chapter 11 "The Cotangent Bundle" is useful for a reference on the theory of cotangent bundles, which corresponds to the structure of reverse mode AD through the optical equivalence. Also a useful general reference for Differential Geomtry.

  • "Natural Operations in Differential Geometry" - Ivan Kolář

I recommend Chapter IV. "Jets and Natural bundles"

Readings on Higher Order Differential Geometry

  • "Second Order Tangent Vectors in Riemannian Geometry", Fisher and Laquer, J. Korean Math Soc 36 (1999)

This one is quite good. I recommend reading the first half at least and tracing through the definitions. This corresponds fairly closely to notion of iterated tangent spaces as implemented in Diffractor.

  • "The Geometry of Jet Bundles" D. J. Saunders

I recommend reading Chapter 5 "Second order Jet bundles", though of course some earlier chapters may be useful to understand this chapter. I'm not 100% happy with the notation, but it gives good intuition.

diff --git a/dev/terminology.pdf b/dev/terminology.pdf index 8c33aa045467515c4f70454d690b7b8dfa9b9565..e24f6518cf93d6803a5cdb527fbb8798c9882b23 100644 GIT binary patch delta 137 zcmZ3rO>)&X$%Yoj7N!>F7M2#)Eo?$TD&~fk1}3J4QJP%(zWFIGi6yBD8ZK5w21X_Z zrUp>S?Pfu2_gS6H3?0o)T}|9f9F5H^jUA0$%q)&X$%Yoj7N!>F7M2#)Eo?$TD#nIJCZ@&)QJP%(zWFIGi6yBD8ZK5w21X_Z zrUp>S?Pfu2_gS4>O)QPf+$_x8oLnu949zW#OpVPAoea#(+zc$;T+QtiYzzq~*&ZIj Hc9{tP;vype