v0.4.0

EarthSciASTDiff v0.4.0

Diff since v0.3.0

EarthSciASTDiff v0.4.0

A structure-only mode for jacobian_bands, derived documents that keep
data-fed parameters as inputs, and much faster band computation on large
stencil operators. Every binding now also admits EarthSciAST 0.9. A minor
release: the Rust SysView gains a public field (see Breaking changes), and
the derivative of Pre changes (see Fixed).

Breaking changes

• Rust: SysView has a new public field
  data_sources: Option<&IndexMap<String, DataSource>>. Code that builds a
  SysView with a struct literal must add it (None, or the document's
  data sources); sysview fills it from the document, and
  sysview_flat(&flat)?.with_data_sources(..) sets it for a flattened
  system.
• Pre(a) in a right-hand side is a (spec §3.2). The rule table gave
  Pre the derivative 0, so jacobian_bands dropped a dependence that
  EarthSciAST's right-hand side has. d[Pre(a)] = d[a] now, and the
  inliner lowers Pre(a) to a before differentiation, so no band
  coefficient, evaluation document or product document carries a Pre.
  Bands of a document that reads a state through Pre gain those entries.

New

• Structure-only mode of jacobian_bands (spec §2.1). Regions are
  clipped and sites found as in the full mode, but no derivative is taken
  and no coefficient simplified; bands merge on structure alone. The mode
  refuses exactly what the full mode refuses (an op with no §3 rule, a
  windowed extremum over more than one contracted index).
  • Julia and Python: jacobian_bands(...; coefficients = false) and
    jacobian_pattern(...; coefficients = false); each band.coef is
    nothing / None, and serialize_band / parse_band omit and accept
    a missing coef.
  • Rust: jacobian_structure, jacobian_structure_view,
    StructureEntry / StructureBand and serialize_structure_band.
• Derived documents keep data-fed parameters as inputs (spec §8.1,
  §9.1). The evaluation document and the product documents used to declare
  a parameter fed from a data source by its shape and default only, so
  EarthSciAST built it as a constant. Each data-fed parameter now keeps its
  data rules, and the document carries the data_sources entries they
  name, so EarthSciAST builds the parameter as a forcing slot of
  rhs_program. A flattened system has no data_sources, so pass the
  flattened document's: a data_sources keyword in Julia and Python
  (sysview, evaluation_document, the product documents and Julia's
  jacobian_document), SysView::with_data_sources in Rust. A named source
  that cannot be found is a BandError. An observed that only a kept rule
  reads (an expression unit_conversion, say) is kept.
• Summand groups are clipped on their own axes (spec §2.2). A body that
  is a sum of terms cut along different dimensions (a dimension-split flux
  divergence) used to be clipped into the product of their regions,
  7 × 7 × 7 = 343 bodies for a 3-D PPM transport term. Each group of
  summands that share a cut dimension is now clipped on its own
  (7 + 7 + 7), summands cut along no dimension form a group of their own,
  and a - b is split into [a, -b]. The band set and values are
  unchanged; the band order and grouping of such bodies change (see
  Conformance).
• scripts/bench-jacobian-bands.jl --stages doc1.esm doc2.esm … times load,
  flatten, sysview and jacobian_bands per document.

Fixed

• A faq node's operand list reads nothing (spec §3.5). The site walk
  descended into a faq node's args, the serializer's copy of the arrays
  its body reads, so a whole array named there was refused as a
  "whole-array reference inside a faq body".
• makearray region values in the inliner (Rust and Python). A
  full-rank region value over a pinned region (a 3-D field's boundary face,
  esm-spec §4.3.2) was refused with makearray value rank 3 ≠ region free rank 2. Every binding now reads a region value by position, at
  idx − lo + origin, and takes its rank from the value itself, so a value
  whose range does not start where its region does no longer reads the
  wrong cell, and a full-rank array variable or makearray value no longer
  raises an arity error (or, in Rust, panics).
• Julia: jacobian_document of a flattened system declares the
  data_sources its data-fed parameters name (a data_sources keyword);
  it used to fail data_source_undefined.
• Rust: non-finite literals are keyed by their bits in the structural
  memo, so x * -Inf no longer receives the simplification of x * Inf,
  and bands whose coefficients differ only in such a literal are not
  merged.
• Structure-only bands merge the same in every binding: Python and Rust
  now coalesce a one-hot column that clipping splits into regions, as the
  Julia reference does, and through a recurrence they merge bands by
  (equation, column) rather than (row, column).

Performance

On ReSEACT's lowered advection term (one faq of 4.2e5 nodes),
jacobian_bands took about 1400 s in Julia. All three bindings now keep one
occurrence index and one derivative memo per band computation, shared
across the regions of a body; memoize the coefficient simplifier on
structural id; group bands for merging by structural id instead of
re-serializing each coefficient; and intern every coefficient and guard so
equal subtrees are one object (on that term, retained coefficient memory
drops from 209 MiB to 2.1 MiB in Julia, and from 805,377 to 5,899 distinct
operator nodes in Rust). Julia releases each clipped region's memo entries
when the region is done; Rust keys its memos weakly. Output is byte-identical
apart from the changes listed above.

Dependencies

• Every binding admits EarthSciAST 0.9: Julia 0.6, 0.7, 0.8, 0.9, Rust
  >=0.5, <0.10, Python >=0.4,<0.10. The floors are unchanged.

Conformance

• New fixtures, each with band goldens checked in Julia, Python and Rust:
  pre_operator (with block, evaluation-document, value, product,
  second-order and scatter goldens), faq_operand_list, data_fed_flat,
  split_sum_2d, split_diff_2d and the structure-only onehot_clipped.
• New structure-only goldens <name>.structure.bands.json for every fixture
  with a state band golden (those of the two recurrence fixtures are written
  by the Rust binding).
• Changed goldens: coupled_chem_advection (band order of its x- and
  y-split boundary bands, now group by group; same bands and values) and
  the forcing_bracket derived documents (they now carry its data-fed
  parameters' rules and data sources).

Breaking changes

None marked in the commit messages (type!: or BREAKING CHANGE:); see the changelog below.

Changelog

• chore(release): v0.4.0 (e2d0916)
• chore(deps): admit EarthSciAST 0.9 in every binding (4cf0960)
• style(julia): drop the trailing blank line Runic rejects in hashcons.jl (8bc7a92)
• test(goldens): structure-only goldens for faq_operand_list and pre_operator (2663c87)
• perf(rust): weak structural memo, exact non-finite keys, lazy rebuilds (9870aca)
• fix(bindings): read makearray region values by position, at their own rank (d8e9b24)
• perf(rust): key a bare variable's occurrence set once in OccIndex (81ee446)
• perf(python): memoize the occurrence short-circuit in drule_check (9b1a1ed)
• perf(julia): release each clipped region's index and memo entries when done (b8de171)
• fix(bands): structure-only entries merge on structure alone in every binding (f2b1f91)
• perf(bands): intern every band list in one bottom-up pass (Julia, Rust) (9433a13)
• fix(bands): split a - b summands, give uncut summands their own group (spec §2.2) (d0826e9)
• fix(bindings): declare data sources in the flat jacobian_document and keep observed a carried rule reads (d1875f3)
• fix(rules): lower Pre to its operand before differentiation (spec §3.2) (191f14c)
• style(julia): runic formatting of drule_check (b8ed436)
• fix(bands): structure-only mode refuses what the full mode refuses (f4d2dd0)
• perf(rust): weak-keyed occurrence index, shared second-order memos (18ea36f)
• perf(bands): one object per distinct coefficient subtree (Julia, Rust) (060ff88)
• split_sum_2d fixture: the §2.2 band form, byte-compared in all three bindings (21c6eb1)
• feat(bands): clip each summand group on its own axes (spec §2.2) (03ae8bb)
• structure-only goldens of the recurrence fixtures (written by Rust), api-surface entries, lint (4eed1c3)
• spec §2.1: structure-only entries through a recurrence (716577f)
• feat(bands): structure-only mode of jacobian_bands (spec §2.1) (b8ff340)
• spec §2.1: structure-only entries, and how their pattern relates to the full mode's (6688c7a)
• perf(rust): one occurrence index and derivative memo per band computation (5e6fba1)
• fix(bindings): inline a full-rank faq value over a pinned makearray region (86b11dd)
• bench: --stages mode times load, flatten, sysview and jacobian_bands per document (bb8dfe0)
• feat(bindings): carry data-fed parameters' rules and data sources in derived documents (f04ffc6)
• perf(julia): one occurrence index and derivative memo per band computation (b579cbd)
• fix(rules): Pre is the identity in a right-hand side (spec §3.2) (60366bd)
• fix(bands): a faq node's operand list reads nothing (spec §3.5) (77e5950)

Merged pull requests:

• fix(bands): a faq node's operand list reads nothing (spec §3.5) (#53) (@ctessum-claude)
• fix(rules): Pre is the identity in a right-hand side (spec §3.2) (#54) (@ctessum-claude)
• feat(bindings): carry data-fed parameters' rules and data sources in derived documents (#55) (@ctessum-claude)
• perf(julia): one occurrence index and derivative memo per band computation (#56) (@ctessum-claude)
• fix(bindings): inline a full-rank faq value over a pinned makearray region (#57) (@ctessum-claude)
• perf(rust): one o...

v0.3.0

EarthSciASTDiff v0.3.0

Diff since v0.2.0

EarthSciASTDiff v0.3.0

The evaluation and product documents of a flattened (coupled) system now
load, flatten and build in every EarthSciAST binding, and every derived
document carries its source's time origin. A minor release: the Rust
SysView gains a public field (see Breaking changes).

Breaking changes

• Rust: SysView has a new public field domain: Option<&Domain>.
  Code that builds a SysView with a struct literal must add it (None, or
  the source's domain); sysview and sysview_flat fill it.
• Rust: sysview_flat returns Result<SysView, BandError>, since it
  now refuses a lifted state's shape that disagrees with lifted_shapes
  (below). Add ? or .unwrap() at the call.

Fixed

• The evaluation document of a flattened system (evaluation_document
  of a FlattenedSystem, spec §8.1). It declared every scoped name, such as
  SimpleOzone.O3, in the one model JacobianEval, which EarthSciAST reads
  as a reference into a missing component: Python refused to load it
  (reference 'SimpleOzone.O3' to undefined system 'SimpleOzone'), Rust
  refused to build it (unresolved_scoped_ref), and Julia refused to build
  its right-hand side (E_TREEWALK_UNKNOWN_STATE). The source's variables
  are now declared in the system's component tree: P.v as v in the model
  at component path P (nested subsystems for deeper paths), each equation
  in the model of the variable it is about, every reference still fully
  scoped. The band fields keep their names and order (J_k, in
  JacobianEval, so JacobianEval.J_k once flattened).
• The product documents of a flattened system (jvp_document,
  vjp_document, hvp_document, spec §9.1) are laid out the same way. Their
  inputs and outputs take the column's name with each . made _
  (_v_SimpleOzone_O3, so JvpEval._v_SimpleOzone_O3 once flattened); for
  a source with no scoped names they are unchanged.
• Sources a derived document cannot hold are refused with a BandError
  instead of giving a wrong document: a flattened system mixing scoped and
  unscoped names, a component named like the derived model (JacobianEval,
  JvpEval, …), a scoped name that is both a variable and a component
  (A.B beside A.B.c), and a source variable named like a band field
  (J_k).
• Python: pointwise-lifted states of a flattened system take their grid
  shape in sysview, as in Rust and the Julia reference. Python's flatten
  records the grid only in lifted_shapes, so sysview read every lifted
  state as a scalar and the bands of a lifted system could not be formed.
• A lifted state's index sets are EarthSciAST's (spec §8.1). From
  EarthSciAST 0.8 (EarthSciAST#623), every binding's flatten records a
  pointwise-lifted state's shape as the lift's index sets, named first by
  an operand declared on them and read at the lift's loops
  (esm-libraries-spec §4.7.5). The view (sysview of a flattened system in
  Julia and Python, sysview_flat in Rust), its context, the bands, the
  derived documents and the scatter plans all take that shape as recorded.
  The derivation from the extents alone (the one index set of that size,
  else a synthetic _liftdim<d>_<n>), which names a synthetic index set
  where EarthSciAST names the operand's, now applies only to a flatten
  that records no shape (Rust and Python before EarthSciAST 0.8). Every
  binding now admits EarthSciAST 0.8 (Julia 0.6, 0.7, 0.8, Rust
  >=0.5, <0.9, Python >=0.4,<0.9; the floors are unchanged); use 0.8
  for lifted documents that agree with EarthSciAST's naming in every
  binding.
• A lifted state's recorded shape is checked against lifted_shapes in
  every binding: the same rank, every entry an index set of the flattened
  system of that dimension's extent, or a BandError (Julia:
  ArgumentError). Julia's flatten before EarthSciAST 0.8 names a
  synthetic _liftdim<d>_<n> in the shape without adding it to
  index_sets, so a lift no operand names onto same-size index sets threw a
  KeyError in the view's context; the view now adds that set.
• The fallback follows esm-libraries-spec §4.7.5 rule 3 (Rust and
  Python): a document that declares _liftdim<d>_<n> with another size is
  refused with a dimension-promotion BandError instead of reusing it at
  that size, and only the document's own index sets are matched by size (a
  declared _liftdim* set counts; one added for an earlier lifted state
  does not).

New

• Every derived document carries the source's domain (spec §8.1,
  §9.1): temporal (start, end, reference_time), element_type and
  array_type, built from EarthSciAST's serialization of the domain, so the
  evaluation and product documents have the source's time origin, from which
  a runtime turns timestamps into model time. SysView holds the source's
  domain:
  • Julia: a fourth field domain; the three-argument constructor still
    works (domain = nothing).
  • Python: a domain field defaulting to None.
  • Rust: the public field above.

Unchanged

• The documents of one model of a document (no scoped names) are the same,
  plus domain when the document has one. No existing fixture has a domain,
  so every existing golden is unchanged.

Conformance

• New goldens coupled_chem_advection.evaldoc.json,
  coupled_chem_advection.evaldoc-nocse.json and
  coupled_chem_advection.jvals.json. Every binding byte-compares the
  documents and builds each with its EarthSciAST, with the native compiler
  and the interpreter, to check its band values; the Julia reference checks
  those values against ForwardDiff of the flattened source. Every binding
  also builds the flattened system's JvpEval and VjpEval documents and
  checks J v and Jᵀ λ against that golden; Julia and Python check the
  HvpEval document against a central difference of λᵀ J v.
• New fixture lift_same_size_index_sets.esm (EarthSciAST's pointwise-lift
  conformance case of that name) with goldens
  lift_same_size_index_sets.evaldoc.json and .jvals.json (nothing to
  hoist, so no .evaldoc-nocse.json): two index sets of size 3, and an
  operand that names the lifted state's grid [x, y]. Unlike EarthSciAST's
  copy, the operand differs in every cell, so the values also pin the cell
  layout. Every binding byte-compares the document (with and without
  hoisting) and checks the values; Python and Rust skip them when their
  flatten records no lifted shape (before EarthSciAST 0.8).
• scripts/regenerate-goldens.jl keeps a flattened fixture's
  .evaldoc-nocse.json only where it differs, as for every other fixture.

Breaking changes

None marked in the commit messages (type!: or BREAKING CHANGE:); see the changelog below.

Changelog

• chore(release): v0.3.0 (d07bb22)
• test(python): skip the flattened parameters band golden before earthsci-ast 0.6 (5e89692)
• test(bindings): pin the flattened coupled document's bands in every binding (58fa823)
• ci(docs): patch cargo to the EarthSciAST checkout for the Rust extract (312e498)
• fix(bindings): address PR #50 review of the recorded lift shape (cbbeff8)
• feat: take a lifted state's index sets from flatten (696f4a6)
• fix: lay product documents out as the component tree; address PR #49 review (f37d1b8)
• feat: carry the source's domain into the evaluation document (7215009)
• fix: lay a flattened system's evaluation document out as its component tree (0774d1f)

Merged pull requests:

• fix: lay a flattened system's evaluation document out as its component tree (#49) (@ctessum-claude)
• feat: take a lifted state's index sets from flatten (#50) (@ctessum-claude)
• test(bindings): pin the flattened coupled document's bands in every binding (#51) (@ctessum-claude)
• chore(release): v0.3.0 (#52) (@ctessum-claude)

Closed issues:

• python: jacobian_bands on a flattened coupled document fails with 'no derivative rule for op faq' (#36)

Installation

using Pkg; Pkg.add("EarthSciASTDiff")   # Julia
pip install earthsci-astdiff             # Python

v0.2.0

EarthSciASTDiff v0.2.0

Diff since v0.1.0

EarthSciASTDiff v0.2.0

The Jacobian is now delivered as ESM documents that EarthSciAST evaluates,
and the bindings no longer evaluate anything themselves. Every product a
solver needs (Jv, Jᵀλ and the second-order contraction) is a derived
document that an unmodified EarthSciAST evaluator runs in one right-hand-side
call. The band calculus also covers more of the language: forcing buffers,
array parameters, second-order bands, filters, max/min/* reductions and
causal recurrences.

Breaking changes

• The evaluators are removed from all three packages. Build the
  evaluation document (evaluation_document) or a product document
  (jvp_document, vjp_document, hvp_document) and evaluate it with
  EarthSciAST. Applying a scatter plan to the evaluated band fields is up to
  the consumer.

  • Julia: prepare_jacobian / JacobianEvaluator / jac!,
    assemble_jacobian, jac_into!, vjp!, vjp_forcing! and
    prepare_hvp / HVPEvaluator / hvp! are removed. The SciMLBase
    extension (ode_components, odefunction, odeproblem) is removed too.
  • Rust: numeric.rs and program.rs are removed: assemble_jacobian,
    prepare_jacobian / JacobianEvaluator, vjp, vjp_forcing,
    band_fields, prepare_hvp / HvpEvaluator / hvp, JacobianProgram
    and HvpProgram. BoundScatter is now plain data (field_lens,
    pairs), with no scatter method.
  • Python: numeric.py and its exports are removed.

• Rust: SysView::variables is now a Cow<'a, IndexMap<…>>.
  .iter(), .get(), .keys() and indexing work as before, but
  for x in sv.variables needs .iter(). parse_jacobian_blocks now returns
  Vec<ParsedBlock>, and jacobian_blocks takes Into<BlockWrt>, so
  existing &[Wrt::…] calls still compile.

• Python 3.11 or newer is required (was 3.9), because EarthSciAST 0.7
  requires it.

• Supported EarthSciAST releases:

  Package	v0.1.0	v0.2.0
  Julia	0.4, 0.5, 0.6	0.6, 0.7
  Rust	0.6	>=0.5, <0.8
  Python	unbounded	>=0.4, <0.8

  EarthSciAST.jl 0.4 and 0.5 no longer precompile, so the Julia package now
  starts at 0.6. CI tests each package against both the oldest and the newest
  release in its range.

• Array parameters are now columns on the parameters axis. Before,
  their cells were silently dropped. On the parameters and forcing axes,
  a column outside its variable's extent, or one that isn't fixed at build
  time, is now an error.

New

• Product documents (spec §9) in Julia, Rust and Python: jvp_document,
  vjp_document and hvp_document (form = :contract or :symmetric).
  Each returns the input and output names the caller fills and reads.
• Scatter plans in Python (scatter_plan, serialize_scatter_plan,
  bind_plan), matching Julia and Rust.
• Forcing and array-parameter columns (wrt = "forcing", RFC U7). The
  forcing set is inferred from array parameters with a data update, or can
  be passed in.
• Second-order bands (spec §4.4, RFC U8): "wrt": [a1, a2] blocks for
  Rosenbrock discrete adjoints.
• More operators (RFC U9). Filtered faq nodes, max/min/*
  reductions and the max_product semiring, which used to be refused, are now
  differentiated. So are value-indexed reads, such as a level search
  x[κ(u)]. Index-only filters the band box can't express become an
  optional where on the entry. column_block structure and factorization
  plans are new too, including per-line diag_plus_rank1.
• Causal recurrences (spec §4.5), Rust and Python only. An observed
  that reads itself at an earlier cell is differentiated through a transfer
  recurrence, which is carried in the block's new auxiliary field. Product
  documents never form that recurrence explicitly. The Julia package doesn't
  differentiate recurrences yet; that waits on EarthSciAST.jl executing them.
• Rust: sysview_flat and jacobian_bands_view differentiate a
  flattened system; plan_factorization and serialize_plan are now
  exported.

Fixes

• A unary - around a whole array expression lost its sign, in all three
  packages.
• A site whose subscripts contain a faq node no longer fails
  canonicalization.

Breaking changes

• feat(bindings)!: retire the Rust and Python evaluators (c56daa2)
• feat(julia)!: evaluate nothing; drop the numeric evaluators (b4c9c1b)
• fix(rust)!: lifted shapes in sysview_flat, a checked plan_factorization (473e1cc)
• feat(rust)!: view a flattened system; plan_factorization and serialize_plan (72b646b)

Changelog

• chore(release): v0.2.0 (5dc5c10)
• style(python): lint for Python 3.11, the requires-python floor (534095d)
• chore(python): require Python 3.11 (e11bc74)
• chore(deps): admit EarthSciAST 0.7 in every binding (2f9bc67)
• ci: take the upstream EarthSciAST ref from the dispatch, not a workflow_call input (206872c)
• ci: run Python 3.9 on ubuntu-24.04; no caches when testing an EarthSciAST ref (bb1cb91)
• ci: address PR #44 review of the registry-gated conformance (213984d)
• fix(bindings): address PR #42 review of recurrence differentiation (e81b178)
• ci: gate releases on published EarthSciAST releases, at both ends of each range (cd510fb)
• feat(bindings): differentiate through causal recurrences (spec §4.5, §9.7) (7e1cff4)
• fix(bindings): port #39's structural build-time extent decisions to Rust and Python (e92b395)
• fix(bindings): address PR #41 review of product documents and test helpers (f8e66e7)
• test(bindings): take every value from the emitted documents; retire the oracles (0399a3e)
• feat(python): port the scatter plans (spec §8) (5ea46d8)
• feat(bindings): emit the evaluation and product documents in Rust and Python (e719bc9)
• fix(julia): review fixes for product documents (1e85adf)
• feat(bindings)!: retire the Rust and Python evaluators (c56daa2)
• feat(julia)!: evaluate nothing; drop the numeric evaluators (b4c9c1b)
• feat(julia): emit Jv, Jᵀλ and hvp as product documents (spec §9) (68fe059)
• spec: tighten §9 product documents after review (dc7c778)
• spec: propose product documents (Jv, Jᵀλ, hvp) evaluated by EarthSciAST (d3e03e9)
• fix(tests): keep dx = 1 m / 16 in minmod_adv and regenerate its evaldoc goldens (f812958)
• fix(julia,python): plan_factorization refuses unknown classes and rectangular band lists (5703fd7)
• fix(rust)!: lifted shapes in sysview_flat, a checked plan_factorization (473e1cc)
• fix: address PR #35 review findings across all three bindings (726fd73)
• docs: column_lines and the column_block plan in the API surface (e03770b)
• feat(rust): filtered faq, max/min/* reductions and value-indexed reads (spec §3.5) (00a0a08)
• feat(python): filtered faq, max/min/* reductions and value-indexed reads (spec §3.5) (e18b169)
• feat(julia): filtered faq, max/min/* reductions and value-indexed reads (spec §3.5) (bab51e4)
• feat(rust)!: view a flattened system; plan_factorization and serialize_plan (72b646b)
• fix(rust): runtime array parameters in JacobianProgram, shared block code (4e109c1)
• fix(python): refuse a bare tuple wrt, share first-order passes and block code (cdb603c)
• fix(julia): refuse a bare Tuple wrt, share first-order passes and block code (813816d)
• feat(rust): compiled second-order contraction (HvpProgram) (3f72d10)
• feat(rust): second-order bands and hvp (spec §4.4) (7375315)
• feat(python): second-order bands and hvp (spec §4.4) (432d8d3)
• feat(julia): second-order bands and the hvp! contraction (spec §4.4) (17ce4d7)
• fix(rust): array defaults, prepared evaluator, required wrt (281a238)
• fix(python): prepared evaluator, strict λ, parameter ghost reads (3809087)
• fix(julia): parameter ghost reads, zero-derivative forcing, String axes (66b2a90)
• feat(rust): forcing axis and array-parameter columns (spec §4.3) (25dc479)
• feat(python): forcing axis and array-parameter columns (spec §4.3) (86ec1e1)
• fix(julia): write array defaults row-major in the evaluation document (457ff2c)
• feat(julia): forcing-buffer and array-parameter columns (spec §4.3) (113f262)
• ci: add the shared lint workflow (28d6915)
• fix: clear clippy and ruff findings for the shared lint gate (93a3e8a)
• style: apply rustfmt, ruff format and Runic (e0c9447)
• chore(deps): bump the github-actions group with 7 updates (0edb85d)
• chore(deps): bump the julia group (07a8e08)
• ci: add Dependabot version updates and dependency review (5e70eb1)

Merged pull requests:

• refactor(units): give bare literals their units (esm-spec §4.8.6) (#26) (@ctessum-claude)
• feat: second-order bands for Rosenbrock discrete adjoints (U8) (#29) (@ctessum-claude)
• feat(rust)!: view a flattened system; plan_factorization and serialize_plan (#34) (@ctessum-claude)
• feat: derivatives through filtered faq, max/min/* reductions and value-indexed reads (U9 part 1) (#35) (@ctessum-claude)
• spec: propose product documents (Jv, Jᵀλ, hvp) evaluated by EarthSciAST (#38) (@ctessum-claude)
• feat(julia): product documents (spec §9), and the Julia package evaluates nothing (#39) (@ctessum-claude)
• feat(bindings)!: retire the Rust and Python evaluators (#40) (@ctessum-claude)
• feat(bindings): product documents and scatter plans in Rust and Python; retire the test oracles (#41) (@ctessum-claude)
• feat(bindings): differentiate through causal recurrences (U9 part 2) (#42) (@ctessum-claude)
• feat(bindings)!: land #40 and #41 on main (retire the binding evaluators; product documents in Rust and Python) (#43) (@ctessum-claude)
• ci: gate releases on published EarthSciAST releases, at both ends of each range (#44) (@ctessum-claude)
• chore(deps): admit EarthSciAST 0.7 in every binding; require Python 3.11 (#46) (@ctessum-claude)
• style(python): lint for Python 3.11, the requires-python floor (#47) (@ctessum-claude)
• chore(release): v0.2....

v0.1.0

EarthSciASTDiff v0.1.0

EarthSciASTDiff v0.1.0

First registered release. EarthSciASTDiff differentiates .esm expression ASTs
symbolically and emits the Jacobian as structured bands, with a Julia reference
implementation (this package) and Python and Rust bindings that are gated
against the same goldens.

This is a new package, so nothing here breaks an earlier release; the
"Breaking changes" entry below is a commit from before the first tag (the port
to EarthSciAST 0.1.x / esm 1.0.0), not a change for users.

Breaking changes

• port!: EarthSciAST 0.1.x / esm 1.0.0 (f4d98fc)

Changelog

• fix(julia): add LICENSE to the package folder, hand-written v0.1.0 notes (3c56c2a)
• docs.yml: publish whole-docs versions on release tags (1a7ba94)
• docs: patch earthsci-ast to the sibling checkout in the Rust examples (1530567)
• fix(julia): accept EarthSciAST 0.6 and SciMLBase 3 (c681580)
• docs: point the Julia example env at the sibling EarthSciAST checkout (fa70e52)
• docs.yml: mint the site dispatch token from the docs GitHub App (555124f)
• TagBot: pass secrets through so the org TagBot App is used (77ea576)
• docs.yml: publish API docs per release tag (versioned API reference) (f8ca3f5)
• docs: publish to earthsci.dev with a cross-language API reference (9484166)
• Release through the shared EarthSciML release workflows; publish the Rust crate (d0da4e6)
• fix: time-band review fixes (#13) (3be52ac)
• fix(julia): accept EarthSciAST 0.5 (930100e)
• spec: specify and golden-gate time-derivative bands (#11) (b532371)
• fix(rust): production assembly review fixes (#12) (19a5b82)
• fix(test): drop the binary32 precision from coupled_chem_advection (18205b7)
• Update EarthSciAST compatibility to version 0.4 (c396a16)
• feat(rust): production-rate Jacobian assembly — compiled band program, plans, matrix-free products (#4 W2, W4, W5) (4898812)
• fix(evaldoc): drop unread observed, refuse element derivatives, cse=false goldens (18b9661)
• fix(scatter): decode plans at bind, refuse contracted lane bands, Rust bind step (edb8389)
• feat(rust): port scatter plans; band_fields for the plan value check (fb88fc3)
• feat(julia): scatter plans for lane blocks, sparse lane blocks, column bands and CSR (4a0da6e)
• test: evaldoc golden for the contracting_observed fixture (e8f2e3d)
• feat(rust): port the evaluation document and hoist_observed (08c36d3)
• feat(julia): trim the source RHS out of the evaluation document; evaldoc goldens (22b8f72)
• fix: capture-avoiding inlining and position-aware nested sums (22fd5bc)
• fix: keep the sum when inlining a contracting observed (99e3074)
• fix: credit arrayed and flattened observed; dedupe observed scans (f99c6fa)
• fix(compat): require EarthSciAST 0.3 (0.1/0.2 predate the faq tag) (f0c6e0f)
• fix(julia): declare LinearAlgebra in the test target (1f94391)
• ci: run all three bindings against EarthSciAST main on PRs and weekly (ee372bd)
• chore(compat): allow EarthSciAST 0.3 (the sibling is 0.3.1; Pkg.test could not resolve) (1cd13a8)
• fix(python): catch up with EarthSciAST main — faq tag, esm 1.0.0 variable model, pruning (4425cf5)
• fix(rust): catch up with EarthSciAST main — faq tag, esm 1.0.0 variable model, pruning (98e3269)
• fix(diff): match the faq node tag, with aggregate as the deprecated alias (33d2b7c)
• Clarify commit message guidelines for Claude (924bb54)
• chore(compat): allow EarthSciAST 0.2 (the sibling has been 0.2.0; Pkg.test could not resolve) (0bd517f)
• feat(assemble): prepare_jacobian(; source_layout) skips the redundant source-model rebuild (7f83c11)
• refactor(rust): follow EarthSciAST's H-3 encapsulation (295c728)
• chore: follow EarthSciAST's load split (985d4c0)
• refactor: follow EarthSciAST's parse_expression -> expression_from_json rename (9cb2864)
• port!: EarthSciAST 0.1.x / esm 1.0.0 (f4d98fc)
• docs(julia): say what was measured, not what was assumed (cbcf141)
• fix(bench): --metaparameters are integers, as the loader's keyword requires (f5301c9)
• perf(julia): filter structural equality by hash before interning (d8025f1)
• perf(julia): make the band calculus linear in the flattened RHS (0c8208f)
• fix(julia): evaluate an :oop derived model, and inline full-rank makearray values (20ee542)
• feat(julia): do not inline observed the differentiation target cannot move (15c7ecc)
• fix(julia): expand templates on the FlattenedSystem sysview path too (91cdefa)
• feat(rust): earthsci-astdiff binding — all three golden gates on first run (5cb0375)
• feat(python): factorization plans — full block byte-parity (4506eb4)
• feat(python): block emission with template CSE, byte-gated block goldens (51d6765)
• feat(python): numeric assembly, gated by cross-runtime value goldens (5026a23)
• chore(python): untrack pycache, add package .gitignore (f89caf8)
• feat(python): earthsci-astdiff band calculus, golden-gated against the reference (a5ee70c)
• feat(julia): contracted-index bands, interp.bilinear derivative, tgrad (f89c559)
• feat(julia): evaluation-model CSE — hoisted observed buffers for band coefficients (fc55626)
• feat(julia): static region clipping — exact patterns without membership guards (a101d76)
• feat(julia): coefficient-size control — template CSE at emission + branch-aware simplification (a9a9b22)
• feat(julia): ODE-solve wiring on the analytical sparse Jacobian (52a5a54)
• feat: analytical sparse Jacobians for .esm models — spec draft + Julia reference (6e79107)
• Initial commit (9b1f212)

Closed issues:

• RFC: Production-rate Jacobian assembly in Rust (#4)
• Inlining a contracting observed drops its sum: the contracted index is captured by the reading faq, giving silently wrong Jacobian bands (#6)
• RFC: Time-derivative bands: specify and golden-gate wrt = time (#11)
• Julia: accept EarthSciAST 0.6 and SciMLBase 3 (#17)

Installation

using Pkg; Pkg.add("EarthSciASTDiff")   # Julia
pip install earthsci-astdiff             # Python