Proposal

[asmeurer]

Here is the proposal we used in 2020. It was accepted, but was later cancelled when the conference changed to online-only. I also have the review comments but I don't know if those can be shared publicly, so I will email them to the folks who are planning to co-present.

The deadline to submit the proposal this year is Feb 22. https://www.scipy2023.scipy.org/present

Abstract:

SymPy is a Python library for symbolic mathematics. This tutorial will introduce SymPy to a beginner audience. It will cover an introduction to symbolic computing, basic symbolic operations, simplification, calculus, matrices, advanced expression manipulation, code generation, and select advanced topics. The tutorial does not have any prerequisites beyond knowledge of Python and basic freshman level mathematics. It will be presented with Jupyter notebooks with regular exercises for the attendees. After attending this tutorial, attendees will be able to start using SymPy to solve their own problems.

Tutorial Description

SymPy is a pure Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python.

SymPy can be used in a wide array of applications. This includes basic usage as an interactive calculator, symbolically modeling problems in physics and engineering, generating fast numeric code, and use in a Python library representing custom symbolic objects. Anyone interested learning how to get started using SymPy for any such applications should attend this tutorial.

This tutorial is a beginner level tutorial and only requires knowledge of how to use Python. Knowledge of mathematics up to basic calculus is recommended. More advanced mathematical topics will be explained as part of the tutorial. Knowledge of other Python libraries such as NumPy is NOT required.

This tutorial will cover the basics of how to use SymPy, and will also touch on some advanced topics. We will start by discussing the basics of how to build mathematical expressions with SymPy and manipulate them. We will look at how to avoid some of the more common pitfalls and gotchas when using the SymPy. We will then move onto the most common functions in SymPy such as simplification functions, solvers, functions for doing operations from calculus such as differentiation and integration, and matrices. Finally, as time permits, we will look into more advanced topics, such as code generation, extending SymPy, interfacing with other libraries such as NumPy, and additional SymPy submodules.

After attending this tutorial, attendees will be able to start using SymPy to solve their own problems. They will also be armed with the knowledge of how to discover additional more specific functionality in SymPy that may be required for their particular use-case.

Tutorial Outline

We will expect tutorial attendees to have the tutorial materials installed on their computers prior to the tutorial. This way we will not waste time in the beginning getting things installed. The tutorial will also be available as a Binder for those that do not wish to install things locally.

All tutorial materials will be Jupyter notebooks. For each topic discussed below (except for the presentation), we will demonstrate the feature, then the attendees will complete short exercises in the accompanying notebook. We will aim for each individual exercise to be completable quickly, so that we can have a fast turnaround time. We will encourage attendees to work with each other and to ask questions to the instructors as they work. Some topics will also include optional advanced exercises for the students that finish the easier exercises more quickly.

Introduction to SymPy (presentation) (10 min.)

This will be a short presentation introducing the tutorial presenters, SymPy, and the SymPy community. This presentation will also give an opportunity for helpers to assist anyone who has had difficulty installing SymPy or loading the tutorial materials on their computer.

Introduction to Symbolic Computation (20 min.)

We will introduce the basics of symbolic computation with SymPy. Topics will include: how to create expressions, avoiding common gotchas and pitfalls, using SymPy in the Jupyter notebook, and pretty printing SymPy expressions.

Basic operations (20 min.)

More basic operations for expression manipulation. Topics will include substitution, numeric evaluation, and parsing strings into SymPy expressions.

Break (10 min.)

Simplification (25 min.)

This section will go over the most important ways to simplify expressions in SymPy. Topics will include simplification functions for polynomials, rational functions, powers, trigonometric functions, exponentials and logarithms, special functions, and advanced simplification techniques.

Calculus (25 min.)

This section will go over how to use SymPy to solve the most basic operations in calculus. Topics will include equation solving, derivatives, integrals, limits, series expansions, and differential equations.

Break (10 min.)

Matrices (25 min.)

This section will cover the basics of using matrices in SymPy. Topics will include, basic matrix operations, determinants, eigenvalues and eigenvectors, and matrix expressions.

Advanced expression manipulation (25 min.)

This section will go into more details about how to do advanced expression manipulation. This section will teach how SymPy expression trees work, and teach the basic expression manipulation building blocks for writing arbitrary algorithms that manipulates SymPy expressions.

Break (10 min.)

Code Generation (30 min.)

This section will go over the basics of how to use SymPy to generate fast code. Topics will include interfacing SymPy with NumPy via lambdify and generating code for C, Fortran, and other languages. We have given a whole tutorial on this topic in the past (SciPy 2017, see https://www.sympy.org/scipy-2017-codegen-tutorial/). As this section is only 30 minutes, this will be a very condensed version covering only the basic topics, with pointers to resources if attendees are interested in learning more.

Advanced Topics (30 min.)

At this point, if the tutorial attendees have any additional topics in SymPy that they would like to learn about, the presenters can demonstrate them live. SymPy has dozens of submodules and this tutorial only covers the very surface of what is possible. We have done a similar thing in past introductory tutorials and have had good experience with it. If there are no requests from the attendees, the presenters will choose some of their favorite parts of SymPy to demonstrate.

Additional Tutorial Information

Tutorial materials will be at https://github.com/sympy/scipy-2020-tutorial

Certain materials may be based on materials from the 2016 tutorial. https://github.com/sympy/scipy-2016-tutorial However, we anticipate that many materials will be largely rewritten, as we are using a slightly different tutorial outline this year. We will also use the student feedback from previous years in guiding which parts should be presented differently.

Some parts of the section on code generation may be based on the materials from the SciPy 2017 SymPy code generation tutorial. https://github.com/sympy/scipy-2017-codegen-tutorial As noted above, this section of tutorial will only be able cover the very basic topics.

Tutorial Prerequisites

This tutorial is a beginner level tutorial and only requires knowledge of how to use Python. Knowledge of mathematics up to basic calculus is recommended. More advanced mathematical topics will be explained as part of the tutorial. Knowledge of other Python libraries such as NumPy is NOT required. Basic knowledge of how to execute code in the Jupyter notebook is required for the tutorial exercises.

Please indicate the appropriate level of the attendees' Python knowledge

Beginner

Instructor Bio(s)

Aaron Meurer: Aaron is the lead developer of SymPy and has been contributing to it since 2009. He is a Scientific Software Engineer at Quansight. He has co-taught tutorials at past SciPy conferences (videos for these tutorials can be found on the Enthought YouTube page):

SciPy 2011: “SymPy tutorial” https://conference.scipy.org/scipy2011/tutorials.php#mateusz
SciPy 2013: “SymPy tutorial” https://conference.scipy.org/scipy2013/tutorial_detail.php?id=101
SciPy 2014: “SymPy tutorial” https://conference.scipy.org/scipy2014/schedule/presentation/1661/
SciPy 2016: “SymPy tutorial” https://scipy2016.scipy.org/ehome/146062/332960/
SciPy 2017: "SymPy Code Generation" http://www.sympy.org/scipy-2017-codegen-tutorial
SciPy 2019: "RAPIDS: Open GPU Data Science" https://github.com/Quansight/scipy-2019-rapids-tutorial

Oscar Benjamin: Oscar's background is in Theoretical Physics and Computational Neuroscience. He currently works at the University of Bristol, UK as a Lecturer in Engineering Mathematics. As part of this role he has extensive experience teaching both Undergraduates and Postgraduates. Examples of his units include Introductory and Intermediate Python along with Scientific Computing, in which he uses NumPy, SciPy and SymPy for mathematical modeling and numerical analysis.

S.Y. Lee: He is a developer of SymPy and has been contributing to it since 2018, and had been one of the most active participants for the recent years. He is currently studying Electronic Engineering in Sogang University. He had mostly been maintaining the matrices module and helped establishing the documentation standards, resolving issues with the development workflow for the community.

It looks like the questions for this year are basically the same.

[asmeurer]

CC @sylee957 @anutosh491.

[sylee957]

I would want to update the bio

[asmeurer]

Thanks. You should add that to the bio on your profile at https://cfp.scipy.org/2023/me/, but I think we should also include the bios in the "additional information" section as there isn't any other section that asks about who will present (which is obviously an important thing for the reviewers to know).

[asmeurer]

The submission deadline is coming up in a couple of weeks, so let's make sure we have something ready to go.

I've moved the submission into a Google Doc to make it easier to edit. @sylee957 and @anutosh491 please feel free to edit the document directly https://docs.google.com/document/d/1qyCEOBGQzLkoZnJTNRW7wZB6czsvoLymRV2nA8DBWWQ/edit?usp=sharing. I've only given access to you two so if anyone else wants to review please let me know and I can give you access.

For now I've just copied over the text from the 2020 proposal, but we should read through it and modify things.

[asmeurer]

@sylee957 @anutosh491 let me know if you're able to take a look at this. The submission deadline is in a week. I plan to take a look today or tomorrow. If you'd like to have a meeting to discuss it let me know.

[sylee957]

I think that the tutorial proposal is fine. We could discuss about the future to write down the materials assuming the tutorial is accepted. 2023-02-16, 목 06:48, Aaron Meurer ***@***.***>님이 작성:

@sylee957 <https://github.com/sylee957> @anutosh491 <https://github.com/anutosh491> let me know if you're able to take a look at this. The submission deadline is in a week. I plan to take a look today or tomorrow. If you'd like to have a meeting to discuss it let me know. — Reply to this email directly, view it on GitHub <#1 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AIKTPTPFI5HF6FANCRXGPT3WXVFJLANCNFSM6AAAAAATXFADVE> . You are receiving this because you were mentioned.Message ID: ***@***.***>

-- S.Y. Lee

[asmeurer]

FYI the proposal deadline was extended to March 1.

[asmeurer]

I have edited the draft a bit, and submitted it. We can still edit it up to the deadline, so if you want to make any modifications, please let me know so I can update the submission.

In particular I added the following to the notes section, since there is no other place in the submission to indicate who the co-presenters are:

A tutorial proposal similar to this one was accepted to SciPy 2020, but due to changes to the conference resulting from the global pandemic, it was canceled.

The tutorial will be taught by Aaron Meurer, S.Y. Lee, and Anutosh Bhat. All three are core developers of the SymPy library, and bring a combined nearly two decades of SymPy experience. Aaron Meurer has taught multiple tutorials at previous SciPys (note some of the old conference site links are broken, but videos of these tutorials can be found by Googling):

• SciPy 2011: “SymPy tutorial” https://conference.scipy.org/scipy2011/tutorials.php#mateusz
• SciPy 2013: “SymPy tutorial” https://conference.scipy.org/scipy2013/tutorial_detail.php?id=101
• SciPy 2014: “SymPy tutorial” https://conference.scipy.org/scipy2014/schedule/presentation/1661
• SciPy 2016: “SymPy tutorial” https://scipy2016.scipy.org/ehome/146062/332960
• SciPy 2017: "SymPy Code Generation" https://www.sympy.org/scipy-2017-codegen-tutorial
• SciPy 2019: "RAPIDS: Open GPU Data Science" https://github.com/Quansight/scipy-2019-rapids-tutorial

@sylee957 @anutosh491 if you want to add something there about yourself, especially about your SymPy expertise, and any prior teaching experience you may have, please do (but again, if you edit the Google doc please ping me either here or in the doc so I know to update the submission).

[anutosh491]

Hello Aaron , I read the proposal throughly a couple days back and it looked good to me . I would go through it once again by today and see if there any necessary edits to be made .