Update README

Author: Linux-cpp-lisp

README.md

@@ -1,15 +1,11 @@
 # opt_einsum_fx
 
-6ptimizng einsums and functions involving them using [`opt_einsum`](https://optimized-einsum.readthedocs.io/en/stable/) and PyTorch [FX](https://pytorch.org/docs/stable/fx.html) compute graphs.
-
-This library currently supports:
- - Fusing multiple einsums into one
- - Optimizing einsums using the [`opt_einsum`](https://optimized-einsum.readthedocs.io/en/stable/) library
- - Fusing multiplication and division with scalar constants, including fusing _through_ operations, like einsum, that commute with scalar multiplication.
- - Placing multiplication by fused scalar constants onto the smallest intermediate in a chain of operations that commute with scalar multiplication. 
+Optimizng einsums and functions involving them using [`opt_einsum`](https://optimized-einsum.readthedocs.io/en/stable/) and PyTorch [FX](https://pytorch.org/docs/stable/fx.html) compute graphs.
 
 Issues, questions, PRs, and any thoughts about further optimizing these kinds of operations are welcome!
 
+For more information please see [the docs](https://opt-einsum-fx.readthedocs.io/en/stable/).
+
 ## Installation
 
 ### PyPI
@@ -37,11 +33,7 @@ You can run the tests with
 $ pytest tests/
 ```
 
-## Usage
-
-`opt_einsum_fx` is based on [`torch.fx`](https://pytorch.org/docs/stable/fx.html), a framework for converting between PyTorch Python code and a programatically manipulable compute graph. To use this package, it must be possible to get your function or model as a `torch.fx.Graph`: the limitations of FX's symbolic tracing are discussed [here](https://pytorch.org/docs/stable/fx.html#limitations-of-symbolic-tracing).
-
-### Minimal example
+## Minimal example
 
 ```python
 import torch
@@ -79,12 +71,6 @@ def forward(self, a, b, vec):
     einsum_2 = torch.functional.einsum('cb,cab->ca', einsum_1, a);  einsum_1 = a = None
     return einsum_2
 ```
-The `optimize_einsums_full` function has four passes:
-
- 1. Scalar accumulation --- use the multilinearity of einsum to fuse all constant coefficients and divisors of operands and outputs
- 2. Fusing einsums --- gives greater flexibility to (3)
- 3. Optimized contraction with ``opt_einsum``
- 4. Moving constant scalar coefficients through operations they commute with in order to place them on the smallest possible intermediate results
 
 We can measure the performance improvement (this is on a CPU):
 ```python
@@ -113,21 +99,6 @@ f(a, b, vec)
 ```
 Depending on your function and dimensions you may see even larger improvements.
 
-### JIT
-
-Currently, pure Python and TorchScript have different call signatures for `torch.tensordot` and `torch.permute`, both of which can appear in optimized einsums:
-```python
-graph_script = torch.jit.script(graph_opt)  # => RuntimeError: Arguments for call are not valid...
-```
-A function is provided to convert `torch.fx.GraphModule`s containing these operations from their Python signatures — the default — to a TorchScript compatible form:
-```python
-graph_script = torch.jit.script(opt_einsum_fx.jitable(graph_opt))
-```
-
-### More information
-
-More information can be found in docstrings in the source; the tests in [`tests/`](./tests) also serve as usage examples.
-
 ## License
 
 `opt_einsum_fx` is distributed under an [MIT license](LICENSE).