Minor changes on the documentation.

tensordiffeq/tensordiffeq/bib.md

@@ -1,5 +1,5 @@
-# Bibleography
-
+# Bibliography
 ```{bibliography} references.bib
+nocite: '@*'
 :style: unsrt
-```
+```

tensordiffeq/tensordiffeq/domain/index.md

@@ -31,7 +31,7 @@ Args:
 - `token` - A `str` by which the variable will be referenced, usually a dimension of the problem such as
 `"x"` or `"y"`
 - `vals` - a `list` of inputs corresponding to `[min, max]` of the target domain
-- `fidel` - An `int` defining the level of fidelity of the evenly spaced samples along this simensions boundary points
+- `fidel` - An `int` defining the level of fidelity of the evenly spaced samples along this dimension boundary points
 
 ```{note}
 TensorDiffEq uses *meshless* solvers, i.e. the domain is not solved using evenly spaced meshs across the domain, as in FEA.
@@ -58,7 +58,7 @@ generate_collocation_points(N_f)
 ```
 
 Args:
-- `N_f` is an `int` describing the numbe of collocation points desired within the domain defined in your `DomainND` object
+- `N_f` is an `int` describing the number of collocation points desired within the domain defined in your `DomainND` object
 
 Example:
 ```{code-block} python
@@ -72,4 +72,4 @@ Domain.generate_collocation_points(50000)
 The collocation points generated are not returned, they reside in the `DomainND` object. Therefore, one does not need to allocate
 the output of `generate_collocation_points` to a variable. Once the `DomainND` object is passed into the solver the collocation points
 will be found automatically and used for generating a solution.
-```
+```

tensordiffeq/tensordiffeq/ic-bc/bc/index.md

@@ -1,12 +1,12 @@
 # Boundary Conditions
 
-Currently, TensorDiffEq contains built-in support for Dirichlet and Periodic BCs, with expanded support coming in the near future
+Currently, TensorDiffEq contains built-in support for Dirichlet and Periodic BCs, with expanded support coming in the near future.
 
 The boundary conditions described generate additional terms in the loss function to allow for enforcement of those boundaries in the final
 solution. Therefore, one simple needs to describe all the boundaries in your problem, put them into a `list` so that TensorDiffEqs solvers can iterate
 through them, and allow the solution to train.
 
-Boundary conditions have similar structure, and dont return anything once initialized. Once fed into the solver, however,
+Boundary conditions have similar structure, and don't return anything once initialized. Once fed into the solver, however,
 the boundary conditions described by the user are enforced in the solution.
 
 ### Dirichlet BCs
@@ -112,4 +112,3 @@ Args:
 - `domain` - a `domain` object containing the variables in the domain
 - `val` - a `float` containing the value to be enforced at the boundary
 - `var` - a `str` indicating which variable should be enforced by the value in `val`
-- `target` - a `str` indicating whether the value listed in `val` will be targeting the `upper` or `lower` boundary on `var`

tensordiffeq/tensordiffeq/model/compiling/index.md

@@ -66,7 +66,7 @@ Args:
 - `layer_sizes` - a `list` of `ints` describing the size of the input, hidden, and output layers of the FC MLP network
 - `f_model` - a `func` describing the physics of the problem. More info is provided in [this section](../../physics/index.ipynb)
 - `domain` - a `domain` object containing the collocation points, defined further [here](../../domain/index.ipynb)
-- `bcs` - a `list` of BCs describing the problem
+- `bcs` - a `list` of [IC](../../ic-bc/ic/index.ipynb) and [BCs](../../ic-bc/bc/index.ipynb) describing the problem
 - `isAdaptive` - a `bool` describing whether the problem is solved adaptively using the [SA-PINN](https://arxiv.org/pdf/2009.04544.pdf)
 - `col_weights` - a `tf.Variable` object containing the vector of collocation weights used in self-adaptive training, if enabled via `isAdaptive`
 - `u_weights` - a `tf.Variable` object containing the vector of initial boundary weights used in self-adaptive training, if enabled via `isAdaptive`

tensordiffeq/tensordiffeq/model/sa-compiling-example/index.md

@@ -59,8 +59,8 @@ model.fit(tf_iter=10000, newton_iter=10000)
 
 ```
 
-Lets break this script up and discuss it a bit. First we define the `domain` and everything associated in it, in this case
-we have a problems that is only dependent on `x` and `t`.
+Lets break this script up and discuss it a bit. First we define the `domain` and everything associated to it, in this case
+we have a problem that is only dependent on `x` and `t`.
 
 ```{code} python
 Domain = DomainND(["x", "t"], time_var='t')
@@ -72,8 +72,7 @@ N_f = 50000
 Domain.generate_collocation_points(N_f)
 ```
 
-Notice how this problem we take more collocation points than the [last example](../compiling-example/index.ipynb) with its simpler
-example.
+Notice how in this problem we take more collocation points than the [last example](../compiling-example/index.ipynb).
 
 Next up lets take a look at defining the [initial condition](../../ic-bc/ic/index.ipynb) and the
 [periodic BC derivative model](../../ic-bc/bc/index.html#derivative-models). Then we drop those conditions into a list to drop them
@@ -129,4 +128,4 @@ model.compile(layer_sizes, f_model, Domain, BCs, isAdaptive=True,
 model.fit(tf_iter=10000, newton_iter=10000)
 ```
 
-This will train a solution $u(x,t)$ for the Allen-Cahn PDE using [self-adaptive training](https://arxiv.org/pdf/2009.04544.pdf)
+This will train a solution $u(x,t)$ for the Allen-Cahn PDE using [self-adaptive training](https://arxiv.org/pdf/2009.04544.pdf)