Implement the D* algorithm for tensor expressions.

**Recommended Skills**: High school/freshman calculus and basic graph theory (optional)

**Expected Results**: A working implementation of the D* algorithm that is capable of performing efficient differentiations on tensor expressions.

**Mentors**: Yingbo Ma

**Duration**: 350 hours

Symbolics.jl have robust ways to convert symbolic expressions into multi-variate polynomials. There is now a robust Groebner basis implementation in (Groebner.jl). Finding roots and varieties of sets of polynomials would be extremely useful in many applications. This project would involve implementing various techniques for solving polynomial systems, and where possible other non-linear equation systems. A good proposal should try to enumerate a number of techniques that are worth implementing, for example:

Analytical solutions for polynomial systems of degree <= 4

Use of HomotopyContinuations.jl for testing for solvability and finding numerical solutions

Newton-raphson methods

Using Groebner basis computations to find varieties

The API for these features should be extremely user-friendly:

A single

`roots`

function should take the sets of equations and result in the right type of roots as output (either varieties or numerical answers)It should automatically find the fastest strategy to solve the set of equations and apply it.

It should fail with descriptive error messages when equations are not solvable, or degenerate in some way.

This should allow implementing symbolic eigenvalue computation when

`eigs`

is called.

**Mentors**: Shashi Gowda, Alexander Demin **Duration**: 350 hours

Implement the heuristic approach to symbolic integration. Then hook into a repository of rules such as RUMI. See also the potential of using symbolic-numeric integration techniques (https://github.com/SciML/SymbolicNumericIntegration.jl)

**Recommended Skills**: High school/Freshman Calculus

**Expected Results**: A working implementation of symbolic integration in the Symbolics.jl library, along with documentation and tutorials demonstrating its use in scientific disciplines.

**Mentors**: Shashi Gowda, Yingbo Ma

**Duration**: 350 hours

Julia functions that take arrays and output arrays or scalars can be traced using Symbolics.jl variables to produce a trace of operations. This output can be optimized to use fused operations or call highly specific NNLib functions. In this project you will trace through Flux.jl neural-network functions and apply optimizations on the resultant symbolic expressions. This can be mostly implemented as rule-based rewriting rules (see https://github.com/JuliaSymbolics/Symbolics.jl/pull/514).

**Recommended Skills**: Knowledge of space and time complexities of array operations, experience in optimizing array code.

**Mentors**: Shashi Gowda

**Duration**: 175 hours

Herbie documents a way to optimize floating point functions so as to reduce instruction count while reorganizing operations such that floating point inaccuracies do not get magnified. It would be a great addition to have this written in Julia and have it work on Symbolics.jl expressions. An ideal implementation would use the e-graph facilities of Metatheory.jl to implement this.

**Mentors**: Shashi Gowda, Alessandro Cheli

**Duration**: 350 hours