diff --git a/README.md b/README.md
index 7fdc4424..4cbbf576 100644
--- a/README.md
+++ b/README.md
@@ -18,11 +18,11 @@ The following table lists mathematical operations for a bijector and the corresp
 
 | Operation                          | Method          | Automatic |
 |:------------------------------------:|:-----------------:|:-----------:|
-| `b ↦ b⁻¹`                                      | `inv(b)`                | ✓         |
+| `b ↦ b⁻¹`                                      | `inverse(b)`                | ✓         |
 | `(b₁, b₂) ↦ (b₁ ∘ b₂)`                         | `b₁ ∘ b₂`               | ✓         |
 | `(b₁, b₂) ↦ [b₁, b₂]`                          | `stack(b₁, b₂)`         | ✓         |
 | `x ↦ b(x)`                                     | `b(x)`                  | ×         |
-| `y ↦ b⁻¹(y)`                                   | `inv(b)(y)`             | ×         |
+| `y ↦ b⁻¹(y)`                                   | `inverse(b)(y)`             | ×         |
 | `x ↦ log｜det J(b, x)｜`                       | `logabsdetjac(b, x)`    | AD        |
 | `x ↦ b(x), log｜det J(b, x)｜`                 | `with_logabsdet_jacobian(b, x)`         | ✓         |
 | `p ↦ q := b_* p`                                | `q = transformed(p, b)` | ✓         |
@@ -123,7 +123,7 @@ true
 What about `invlink`?
 
 ```julia
-julia> b⁻¹ = inv(b)
+julia> b⁻¹ = inverse(b)
 Inverse{Logit{Float64},0}(Logit{Float64}(0.0, 1.0))
 
 julia> b⁻¹(y)
@@ -133,7 +133,7 @@ julia> b⁻¹(y) ≈ invlink(dist, y)
 true
 ```
 
-Pretty neat, huh? `Inverse{Logit}` is also a `Bijector` where we've defined `(ib::Inverse{<:Logit})(y)` as the inverse transformation of `(b::Logit)(x)`. Note that it's not always the case that `inv(b) isa Inverse`, e.g. the inverse of `Exp` is simply `Log` so `inv(Exp()) isa Log` is true.
+Pretty neat, huh? `Inverse{Logit}` is also a `Bijector` where we've defined `(ib::Inverse{<:Logit})(y)` as the inverse transformation of `(b::Logit)(x)`. Note that it's not always the case that `inverse(b) isa Inverse`, e.g. the inverse of `Exp` is simply `Log` so `inverse(Exp()) isa Log` is true.
 
 #### Dimensionality
 One more thing. See the `0` in `Inverse{Logit{Float64}, 0}`? It represents the *dimensionality* of the bijector, in the same sense as for an `AbstractArray` with the exception of `0` which means it expects 0-dim input and output, i.e. `<:Real`. This can also be accessed through `dimension(b)`:
@@ -162,7 +162,7 @@ true
 And since `Composed isa Bijector`:
 
 ```julia
-julia> id_x = inv(id_y)
+julia> id_x = inverse(id_y)
 Composed{Tuple{Inverse{Logit{Float64},0},Logit{Float64}},0}((Inverse{Logit{Float64},0}(Logit{Float64}(0.0, 1.0)), Logit{Float64}(0.0, 1.0)))
 
 julia> id_x(x) ≈ x
@@ -201,7 +201,7 @@ julia> logpdf_forward(td, x)
 
 #### `logabsdetjac` and `forward`
 
-In the computation of both `logpdf` and `logpdf_forward` we need to compute `log(abs(det(jacobian(inv(b), y))))` and `log(abs(det(jacobian(b, x))))`, respectively. This computation is available using the `logabsdetjac` method
+In the computation of both `logpdf` and `logpdf_forward` we need to compute `log(abs(det(jacobian(inverse(b), y))))` and `log(abs(det(jacobian(b, x))))`, respectively. This computation is available using the `logabsdetjac` method
 
 ```julia
 julia> logabsdetjac(b⁻¹, y)
@@ -228,7 +228,7 @@ julia> with_logabsdet_jacobian(b, x)
 Similarily
 
 ```julia
-julia> forward(inv(b), y)
+julia> forward(inverse(b), y)
 (0.3688868996596376, -1.4575353795716655)
 ```
 
@@ -241,7 +241,7 @@ At this point we've only shown that we can replicate the existing functionality.
 julia> y = rand(td)              # ∈ ℝ
 0.999166054552483
 
-julia> x = inv(td.transform)(y)  # transform back to interval [0, 1]
+julia> x = inverse(td.transform)(y)  # transform back to interval [0, 1]
 0.7308945834125756
 ```
 
@@ -261,7 +261,7 @@ Beta{Float64}(α=2.0, β=2.0)
 julia> b = bijector(dist)              # (0, 1) → ℝ
 Logit{Float64}(0.0, 1.0)
 
-julia> b⁻¹ = inv(b)                    # ℝ → (0, 1)
+julia> b⁻¹ = inverse(b)                    # ℝ → (0, 1)
 Inverse{Logit{Float64},0}(Logit{Float64}(0.0, 1.0))
 
 julia> td = transformed(Normal(), b⁻¹) # x ∼ 𝓝(0, 1) then b(x) ∈ (0, 1)
@@ -280,7 +280,7 @@ It's worth noting that `support(Beta)` is the _closed_ interval `[0, 1]`, while
 ```julia
 td = transformed(Beta())
 
-inv(td.transform)(rand(td))
+inverse(td.transform)(rand(td))
 ```
 
 will never result in `0` or `1` though any sample arbitrarily close to either `0` or `1` is possible. _Disclaimer: numerical accuracy is limited, so you might still see `0` and `1` if you're lucky._
@@ -335,7 +335,7 @@ julia> # Construct the transform
        bs = bijector.(dists)     # constrained-to-unconstrained bijectors for dists
 (Logit{Float64}(0.0, 1.0), Log{0}(), SimplexBijector{true}())
 
-julia> ibs = inv.(bs)            # invert, so we get unconstrained-to-constrained
+julia> ibs = inverse.(bs)            # invert, so we get unconstrained-to-constrained
 (Inverse{Logit{Float64},0}(Logit{Float64}(0.0, 1.0)), Exp{0}(), Inverse{SimplexBijector{true},1}(SimplexBijector{true}()))
 
 julia> sb = Stacked(ibs, ranges) # => Stacked <: Bijector
@@ -411,7 +411,7 @@ Similarily to the multivariate ADVI example, we could use `Stacked` to get a _bo
 ```julia
 julia> d = MvNormal(zeros(2), ones(2));
 
-julia> ibs = inv.(bijector.((InverseGamma(2, 3), Beta())));
+julia> ibs = inverse.(bijector.((InverseGamma(2, 3), Beta())));
 
 julia> sb = stack(ibs...) # == Stacked(ibs) == Stacked(ibs, [i:i for i = 1:length(ibs)]
 Stacked{Tuple{Exp{0},Inverse{Logit{Float64},0}},2}((Exp{0}(), Inverse{Logit{Float64},0}(Logit{Float64}(0.0, 1.0))), (1:1, 2:2))
@@ -542,7 +542,7 @@ Logit{Float64}(0.0, 1.0)
 julia> b(0.6)
 0.4054651081081642
 
-julia> inv(b)(y)
+julia> inverse(b)(y)
 Tracked 2-element Array{Float64,1}:
  0.3078149833748082
  0.72380041667891  
@@ -550,7 +550,7 @@ Tracked 2-element Array{Float64,1}:
 julia> logabsdetjac(b, 0.6)
 1.4271163556401458
 
-julia> logabsdetjac(inv(b), y) # defaults to `- logabsdetjac(b, inv(b)(x))`
+julia> logabsdetjac(inverse(b), y) # defaults to `- logabsdetjac(b, inverse(b)(x))`
 Tracked 2-element Array{Float64,1}:
  -1.546158373866469 
  -1.6098711387913573
@@ -614,10 +614,10 @@ julia> logabsdetjac(b_ad, 0.6)
 julia> y = b_ad(0.6)
 0.4054651081081642
 
-julia> inv(b_ad)(y)
+julia> inverse(b_ad)(y)
 0.6
 
-julia> logabsdetjac(inv(b_ad), y)
+julia> logabsdetjac(inverse(b_ad), y)
 -1.4271163556401458
 ```
 
@@ -666,7 +666,7 @@ help?> Bijectors.Composed
 
   A Bijector representing composition of bijectors. composel and composer results in a Composed for which application occurs from left-to-right and right-to-left, respectively.
 
-  Note that all the alternative ways of constructing a Composed returns a Tuple of bijectors. This ensures type-stability of implementations of all relating methdos, e.g. inv.
+  Note that all the alternative ways of constructing a Composed returns a Tuple of bijectors. This ensures type-stability of implementations of all relating methods, e.g. inverse.
 
   If you want to use an Array as the container instead you can do
 
@@ -714,7 +714,7 @@ The distribution interface consists of:
 #### Methods
 The following methods are implemented by all subtypes of `Bijector`, this also includes bijectors such as `Composed`.
 - `(b::Bijector)(x)`: implements the transform of the `Bijector`
-- `inv(b::Bijector)`: returns the inverse of `b`, i.e. `ib::Bijector` s.t. `(ib ∘ b)(x) ≈ x`. In most cases this is `Inverse{<:Bijector}`.
+- `inverse(b::Bijector)`: returns the inverse of `b`, i.e. `ib::Bijector` s.t. `(ib ∘ b)(x) ≈ x`. In most cases this is `Inverse{<:Bijector}`.
 - `logabsdetjac(b::Bijector, x)`: computes log(abs(det(jacobian(b, x)))).
 - `with_logabsdet_jacobian(b::Bijector, x)`: returns named tuple `(b(x), logabsdetjac(b, x))` in the most efficient manner.
 - `∘`, `composel`, `composer`: convenient and type-safe constructors for `Composed`. `composel(bs...)` composes s.t. the resulting composition is evaluated left-to-right, while `composer(bs...)` is evaluated right-to-left. `∘` is right-to-left, as excepted from standard mathematical notation.
@@ -726,7 +726,7 @@ For `TransformedDistribution`, together with default implementations for `Distri
 - `bijector(d::Distribution)`: returns the default constrained-to-unconstrained bijector for `d`
 - `transformed(d::Distribution)`, `transformed(d::Distribution, b::Bijector)`: constructs a `TransformedDistribution` from `d` and `b`.
 - `logpdf_forward(d::Distribution, x)`, `logpdf_forward(d::Distribution, x, logjac)`: computes the `logpdf(td, td.transform(x))` using the forward pass, which is potentially faster depending on the transform at hand.
-- `forward(d::Distribution)`: returns `(x = rand(dist), y = b(x), logabsdetjac = logabsdetjac(b, x), logpdf = logpdf_forward(td, x))` where `b = td.transform`. This combines sampling from base distribution and transforming into one function. The intention is that this entire process should be performed in the most efficient manner, e.g. the `logabsdetjac(b, x)` call might instead be implemented as `- logabsdetjac(inv(b), b(x))` depending on which is most efficient.
+- `forward(d::Distribution)`: returns `(x = rand(dist), y = b(x), logabsdetjac = logabsdetjac(b, x), logpdf = logpdf_forward(td, x))` where `b = td.transform`. This combines sampling from base distribution and transforming into one function. The intention is that this entire process should be performed in the most efficient manner, e.g. the `logabsdetjac(b, x)` call might instead be implemented as `- logabsdetjac(inverse(b), b(x))` depending on which is most efficient.
 
 # Bibliography
 1. Rezende, D. J., & Mohamed, S. (2015). Variational Inference With Normalizing Flows. [arXiv:1505.05770](https://arxiv.org/abs/1505.05770v6).
diff --git a/src/Bijectors.jl b/src/Bijectors.jl
index 2393283d..a540f435 100644
--- a/src/Bijectors.jl
+++ b/src/Bijectors.jl
@@ -36,10 +36,10 @@ using Base.Iterators: drop
 using LinearAlgebra: AbstractTriangular
 
 import ChangesOfVariables: with_logabsdet_jacobian
+import InverseFunctions: inverse
 
 import ChainRulesCore
 import Functors
-import InverseFunctions
 import IrrationalConstants
 import LogExpFunctions
 import Roots
@@ -124,7 +124,7 @@ end
 # Distributions
 
 link(d::Distribution, x) = bijector(d)(x)
-invlink(d::Distribution, y) = inv(bijector(d))(y)
+invlink(d::Distribution, y) = inverse(bijector(d))(y)
 function logpdf_with_trans(d::Distribution, x, transform::Bool)
     if ispd(d)
         return pd_logpdf_with_trans(d, x, transform)
@@ -191,14 +191,14 @@ function invlink(
     y::AbstractVecOrMat{<:Real},
     ::Val{proj}=Val(true),
 ) where {proj}
-    return inv(SimplexBijector{proj}())(y)
+    return inverse(SimplexBijector{proj}())(y)
 end
 function invlink_jacobian(
     d::Dirichlet,
     y::AbstractVector{<:Real},
     ::Val{proj}=Val(true),
 ) where {proj}
-    return jacobian(inv(SimplexBijector{proj}()), y)
+    return jacobian(inverse(SimplexBijector{proj}()), y)
 end
 
 ## Matrix
@@ -254,6 +254,9 @@ include("chainrules.jl")
 
 Base.@deprecate forward(b::AbstractBijector, x) with_logabsdet_jacobian(b, x)
 
+import Base.inv
+Base.@deprecate inv(b::AbstractBijector) inverse(b)
+
 # Broadcasting here breaks Tracker for some reason
 maporbroadcast(f, x::AbstractArray{<:Any, N}...) where {N} = map(f, x...)
 maporbroadcast(f, x::AbstractArray...) = f.(x...)
diff --git a/src/bijectors/composed.jl b/src/bijectors/composed.jl
index 6a02432e..482a2760 100644
--- a/src/bijectors/composed.jl
+++ b/src/bijectors/composed.jl
@@ -17,7 +17,7 @@ A `Bijector` representing composition of bijectors. `composel` and `composer` re
 `Composed` for which application occurs from left-to-right and right-to-left, respectively.
 
 Note that all the alternative ways of constructing a `Composed` returns a `Tuple` of bijectors.
-This ensures type-stability of implementations of all relating methdos, e.g. `inv`.
+This ensures type-stability of implementations of all relating methdos, e.g. `inverse`.
 
 If you want to use an `Array` as the container instead you can do
 
@@ -41,7 +41,7 @@ Composed{Tuple{Exp{0},Exp{0}},0}((Exp{0}(), Exp{0}()))
 julia> (b ∘ b)(1.0) == exp(exp(1.0))    # evaluation
 true
 
-julia> inv(b ∘ b)(exp(exp(1.0))) == 1.0 # inversion
+julia> inverse(b ∘ b)(exp(exp(1.0))) == 1.0 # inversion
 true
 
 julia> logabsdetjac(b ∘ b, 1.0)         # determinant of jacobian
@@ -153,7 +153,7 @@ end
 ∘(::Identity{N}, b::Bijector{N}) where {N} = b
 ∘(b::Bijector{N}, ::Identity{N}) where {N} = b
 
-inv(ct::Composed) = Composed(reverse(map(inv, ct.ts)))
+inverse(ct::Composed) = Composed(reverse(map(inv, ct.ts)))
 
 # # TODO: should arrays also be using recursive implementation instead?
 function (cb::Composed{<:AbstractArray{<:Bijector}})(x)
diff --git a/src/bijectors/corr.jl b/src/bijectors/corr.jl
index 18363db1..5ec999db 100644
--- a/src/bijectors/corr.jl
+++ b/src/bijectors/corr.jl
@@ -100,7 +100,7 @@ function logabsdetjac(b::CorrBijector, X::AbstractMatrix{<:Real})
     `logabsdetjac(::Inverse{CorrBijector}, y::AbstractMatrix{<:Real})`
     if possible.
     =#
-    return -logabsdetjac(inv(b), (b(X))) 
+    return -logabsdetjac(inverse(b), (b(X))) 
 end
 function logabsdetjac(b::CorrBijector, X::AbstractArray{<:AbstractMatrix{<:Real}})
     return mapvcat(X) do x
diff --git a/src/bijectors/coupling.jl b/src/bijectors/coupling.jl
index 088caf2a..03b00ba5 100644
--- a/src/bijectors/coupling.jl
+++ b/src/bijectors/coupling.jl
@@ -151,7 +151,7 @@ julia> cl(x)
  2.0
  3.0
 
-julia> inv(cl)(cl(x))
+julia> inverse(cl)(cl(x))
 3-element Array{Float64,1}:
  1.0
  2.0
@@ -214,7 +214,7 @@ function (icl::Inverse{<:Coupling})(y::AbstractVector)
     y_1, y_2, y_3 = partition(cl.mask, y)
 
     b = cl.θ(y_2)
-    ib = inv(b)
+    ib = inverse(b)
 
     return combine(cl.mask, ib(y_1), y_2, y_3)
 end
diff --git a/src/bijectors/exp_log.jl b/src/bijectors/exp_log.jl
index 0e2da142..0f5f4683 100644
--- a/src/bijectors/exp_log.jl
+++ b/src/bijectors/exp_log.jl
@@ -27,8 +27,8 @@ Log() = Log{0}()
 (b::Exp{2})(y::AbstractArray{<:AbstractMatrix{<:Real}}) = map(b, y)
 (b::Log{2})(x::AbstractArray{<:AbstractMatrix{<:Real}}) = map(b, x)
 
-inv(b::Exp{N}) where {N} = Log{N}()
-inv(b::Log{N}) where {N} = Exp{N}()
+inverse(b::Exp{N}) where {N} = Log{N}()
+inverse(b::Log{N}) where {N} = Exp{N}()
 
 logabsdetjac(b::Exp{0}, x::Real) = x
 logabsdetjac(b::Exp{0}, x::AbstractVector) = x
diff --git a/src/bijectors/leaky_relu.jl b/src/bijectors/leaky_relu.jl
index 62413316..b7e933ed 100644
--- a/src/bijectors/leaky_relu.jl
+++ b/src/bijectors/leaky_relu.jl
@@ -31,8 +31,8 @@ function (b::LeakyReLU{<:Any, 0})(x::Real)
 end
 (b::LeakyReLU{<:Any, 0})(x::AbstractVector{<:Real}) = map(b, x)
 
-function Base.inv(b::LeakyReLU{<:Any,N}) where N
-    invα = inv.(b.α)
+function inverse(b::LeakyReLU{<:Any,N}) where N
+    invα = inverse.(b.α)
     return LeakyReLU{typeof(invα),N}(invα)
 end
 
diff --git a/src/bijectors/named_bijector.jl b/src/bijectors/named_bijector.jl
index 0543f91a..8f90464e 100644
--- a/src/bijectors/named_bijector.jl
+++ b/src/bijectors/named_bijector.jl
@@ -55,8 +55,8 @@ names_to_bijectors(b::NamedBijector) = b.bs
     return :($(exprs...), )
 end
 
-@generated function Base.inv(b::NamedBijector{names}) where {names}
-    return :(NamedBijector(($([:($n = inv(b.bs.$n)) for n in names]...), )))
+@generated function inverse(b::NamedBijector{names}) where {names}
+    return :(NamedBijector(($([:($n = inverse(b.bs.$n)) for n in names]...), )))
 end
 
 @generated function logabsdetjac(b::NamedBijector{names}, x::NamedTuple) where {names}
@@ -78,10 +78,10 @@ See also: [`Inverse`](@ref)
 struct NamedInverse{B<:AbstractNamedBijector} <: AbstractNamedBijector
     orig::B
 end
-Base.inv(nb::AbstractNamedBijector) = NamedInverse(nb)
-Base.inv(ni::NamedInverse) = ni.orig
+inverse(nb::AbstractNamedBijector) = NamedInverse(nb)
+inverse(ni::NamedInverse) = ni.orig
 
-logabsdetjac(ni::NamedInverse, y::NamedTuple) = -logabsdetjac(inv(ni), ni(y))
+logabsdetjac(ni::NamedInverse, y::NamedTuple) = -logabsdetjac(inverse(ni), ni(y))
 
 ##########################
 ### `NamedComposition` ###
@@ -107,7 +107,7 @@ composel(bs::AbstractNamedBijector...) = NamedComposition(bs)
 composer(bs::AbstractNamedBijector...) = NamedComposition(reverse(bs))
 ∘(b1::AbstractNamedBijector, b2::AbstractNamedBijector) = composel(b2, b1)
 
-inv(ct::NamedComposition) = NamedComposition(reverse(map(inv, ct.bs)))
+inverse(ct::NamedComposition) = NamedComposition(reverse(map(inv, ct.bs)))
 
 function (cb::NamedComposition{<:AbstractArray{<:AbstractNamedBijector}})(x)
     @assert length(cb.bs) > 0
@@ -232,7 +232,7 @@ end
 ) where {target, deps, F}
     return quote
         b = ni.orig.f($([:(x.$d) for d in deps]...))
-        return merge(x, ($target = inv(b)(x.$target), ))
+        return merge(x, ($target = inverse(b)(x.$target), ))
     end
 end
 
diff --git a/src/bijectors/normalise.jl b/src/bijectors/normalise.jl
index defb447e..43972eeb 100644
--- a/src/bijectors/normalise.jl
+++ b/src/bijectors/normalise.jl
@@ -87,7 +87,7 @@ function forward(invbn::Inverse{<:InvertibleBatchNorm}, y)
     @assert !istraining() "`forward(::Inverse{InvertibleBatchNorm})` is only available in test mode."
     dims = ndims(y)
     as = ntuple(i -> i == ndims(y) - 1 ? size(y, i) : 1, dims)
-    bn = inv(invbn)
+    bn = inverse(invbn)
     s = reshape(exp.(bn.logs), as...)
     b = reshape(bn.b, as...)
     m = reshape(bn.m, as...)
diff --git a/src/bijectors/permute.jl b/src/bijectors/permute.jl
index d4fdef7b..5ba9e5cf 100644
--- a/src/bijectors/permute.jl
+++ b/src/bijectors/permute.jl
@@ -71,10 +71,10 @@ julia> b4([1., 2., 3.])
  1.0
  3.0
 
-julia> inv(b1)
+julia> inverse(b1)
 Permute{LinearAlgebra.Transpose{Int64,Array{Int64,2}}}([0 1 0; 1 0 0; 0 0 1])
 
-julia> inv(b1)(b1([1., 2., 3.]))
+julia> inverse(b1)(b1([1., 2., 3.]))
 3-element Array{Float64,1}:
  1.0
  2.0
@@ -151,7 +151,7 @@ end
 
 
 @inline (b::Permute)(x::AbstractVecOrMat) = b.A * x
-@inline inv(b::Permute) = Permute(transpose(b.A))
+@inline inverse(b::Permute) = Permute(transpose(b.A))
 
 logabsdetjac(b::Permute, x::AbstractVector) = zero(eltype(x))
 logabsdetjac(b::Permute, x::AbstractMatrix) = zero(eltype(x), size(x, 2))
diff --git a/src/bijectors/scale.jl b/src/bijectors/scale.jl
index e19b33f5..c76acfda 100644
--- a/src/bijectors/scale.jl
+++ b/src/bijectors/scale.jl
@@ -21,8 +21,8 @@ up1(b::Scale{T, N}) where {N, T} = Scale{T, N + 1}(a)
 (b::Scale)(x) = b.a .* x
 (b::Scale{<:AbstractMatrix, 1})(x::AbstractVecOrMat) = b.a * x
 (b::Scale{<:AbstractMatrix, 2})(x::AbstractMatrix) = b.a * x
-(ib::Inverse{<:Scale})(y) = Scale(inv(ib.orig.a))(y)
-(ib::Inverse{<:Scale{<:AbstractVector}})(y) = Scale(inv.(ib.orig.a))(y)
+(ib::Inverse{<:Scale})(y) = Scale(inverse(ib.orig.a))(y)
+(ib::Inverse{<:Scale{<:AbstractVector}})(y) = Scale(inverse.(ib.orig.a))(y)
 (ib::Inverse{<:Scale{<:AbstractMatrix, 1}})(y::AbstractVecOrMat) = ib.orig.a \ y
 (ib::Inverse{<:Scale{<:AbstractMatrix, 2}})(y::AbstractMatrix) = ib.orig.a \ y
 
diff --git a/src/bijectors/shift.jl b/src/bijectors/shift.jl
index f6c39f82..e4e9960c 100644
--- a/src/bijectors/shift.jl
+++ b/src/bijectors/shift.jl
@@ -24,7 +24,7 @@ up1(b::Shift{T, N}) where {T, N} = Shift{T, N + 1}(b.a)
 (b::Shift)(x) = b.a .+ x
 (b::Shift{<:Any, 2})(x::AbstractArray{<:AbstractMatrix}) = map(b, x)
 
-inv(b::Shift{T, N}) where {T, N} = Shift{T, N}(-b.a)
+inverse(b::Shift{T, N}) where {T, N} = Shift{T, N}(-b.a)
 
 # FIXME: implement custom adjoint to ensure we don't get tracking
 logabsdetjac(b::Shift{T, N}, x) where {T, N} = _logabsdetjac_shift(b.a, x, Val(N))
diff --git a/src/bijectors/simplex.jl b/src/bijectors/simplex.jl
index 48d19b73..10ba4db3 100644
--- a/src/bijectors/simplex.jl
+++ b/src/bijectors/simplex.jl
@@ -127,10 +127,10 @@ function (ib::Inverse{<:SimplexBijector{1}})(
     _simplex_inv_bijector!(X, Y, ib.orig)
 end
 function (ib::Inverse{<:SimplexBijector{2, proj}})(Y::AbstractMatrix) where {proj}
-    inv(SimplexBijector{1, proj}())(Y)
+    inverse(SimplexBijector{1, proj}())(Y)
 end
 function (ib::Inverse{<:SimplexBijector{2, proj}})(X::AbstractMatrix, Y::AbstractMatrix) where {proj}
-    inv(SimplexBijector{1, proj}())(X, Y)
+    inverse(SimplexBijector{1, proj}())(X, Y)
 end
 (ib::Inverse{<:SimplexBijector{2}})(Y::AbstractArray{<:AbstractMatrix}) = map(ib, Y)
 function _simplex_inv_bijector(Y::AbstractMatrix, b::SimplexBijector{1})
diff --git a/src/bijectors/stacked.jl b/src/bijectors/stacked.jl
index 144c7817..9a49c34d 100644
--- a/src/bijectors/stacked.jl
+++ b/src/bijectors/stacked.jl
@@ -50,14 +50,14 @@ isclosedform(b::Stacked) = all(isclosedform, b.bs)
 
 stack(bs::Bijector{0}...) = Stacked(bs)
 
-# For some reason `inv.(sb.bs)` was unstable... This works though.
-inv(sb::Stacked) = Stacked(map(inv, sb.bs), sb.ranges)
+# For some reason `inverse.(sb.bs)` was unstable... This works though.
+inverse(sb::Stacked) = Stacked(map(inverse, sb.bs), sb.ranges)
 # map is not type stable for many stacked bijectors as a large tuple
 # hence the generated function
-@generated function inv(sb::Stacked{A}) where {A <: Tuple}
+@generated function inverse(sb::Stacked{A}) where {A <: Tuple}
     exprs = []
     for i = 1:length(A.parameters)
-        push!(exprs, :(inv(sb.bs[$i])))
+        push!(exprs, :(inverse(sb.bs[$i])))
     end
     :(Stacked(($(exprs...), ), sb.ranges))
 end
diff --git a/src/compat/distributionsad.jl b/src/compat/distributionsad.jl
index a2fea928..85ef72ad 100644
--- a/src/compat/distributionsad.jl
+++ b/src/compat/distributionsad.jl
@@ -57,14 +57,14 @@ function invlink(
     y::AbstractVecOrMat{<:Real},
     ::Val{proj}=Val(true),
 ) where {proj}
-    return inv(SimplexBijector{proj}())(y)
+    return inverse(SimplexBijector{proj}())(y)
 end
 function invlink_jacobian(
     d::TuringDirichlet,
     y::AbstractVector{<:Real},
     ::Val{proj}=Val(true),
 ) where {proj}
-    return jacobian(inv(SimplexBijector{proj}()), y)
+    return jacobian(inverse(SimplexBijector{proj}()), y)
 end
 
 ispd(::TuringWishart) = true
diff --git a/src/compat/reversediff.jl b/src/compat/reversediff.jl
index 116d8531..5c11a4db 100644
--- a/src/compat/reversediff.jl
+++ b/src/compat/reversediff.jl
@@ -60,7 +60,7 @@ function _logabsdetjac_scale(a::TrackedReal, x::Real, ::Val{0})
     return track(_logabsdetjac_scale, a, value(x), Val(0))
 end
 @grad function _logabsdetjac_scale(a::Real, x::Real, v::Val{0})
-    return _logabsdetjac_scale(value(a), value(x), Val(0)), Δ -> (inv(value(a)) .* Δ, nothing, nothing)
+    return _logabsdetjac_scale(value(a), value(x), Val(0)), Δ -> (inverse(value(a)) .* Δ, nothing, nothing)
 end
 # Need to treat `AbstractVector` and `AbstractMatrix` separately due to ambiguity errors
 function _logabsdetjac_scale(a::TrackedReal, x::AbstractVector, ::Val{0})
@@ -68,7 +68,7 @@ function _logabsdetjac_scale(a::TrackedReal, x::AbstractVector, ::Val{0})
 end
 @grad function _logabsdetjac_scale(a::Real, x::AbstractVector, v::Val{0})
     da = value(a)
-    J = fill(inv.(da), length(x))
+    J = fill(inverse.(da), length(x))
     return _logabsdetjac_scale(da, value(x), Val(0)), Δ -> (transpose(J) * Δ, nothing, nothing)
 end
 function _logabsdetjac_scale(a::TrackedReal, x::AbstractMatrix, ::Val{0})
diff --git a/src/interface.jl b/src/interface.jl
index d2e8be7b..3782dee6 100644
--- a/src/interface.jl
+++ b/src/interface.jl
@@ -1,4 +1,4 @@
-import Base: inv, ∘
+import Base: ∘
 
 import Random: AbstractRNG
 import Distributions: logpdf, rand, rand!, _rand!, _logpdf
@@ -56,7 +56,7 @@ requires an iterative procedure to evaluate.
 isclosedform(b::Bijector) = true
 
 """
-    inv(b::Bijector)
+inverse(b::Bijector)
     Inverse(b::Bijector)
 
 A `Bijector` representing the inverse transform of `b`.
@@ -72,8 +72,8 @@ Functors.@functor Inverse
 
 up1(b::Inverse) = Inverse(up1(b.orig))
 
-inv(b::Bijector) = Inverse(b)
-inv(ib::Inverse{<:Bijector}) = ib.orig
+inverse(b::Bijector) = Inverse(b)
+inverse(ib::Inverse{<:Bijector}) = ib.orig
 Base.:(==)(b1::Inverse{<:Bijector}, b2::Inverse{<:Bijector}) = b1.orig == b2.orig
 
 """
@@ -104,9 +104,9 @@ with_logabsdet_jacobian(b::Bijector, x) = (b(x), logabsdetjac(b, x))
 """
     logabsdetjacinv(b::Bijector, y)
 
-Just an alias for `logabsdetjac(inv(b), y)`.
+Just an alias for `logabsdetjac(inverse(b), y)`.
 """
-logabsdetjacinv(b::Bijector, y) = logabsdetjac(inv(b), y)
+logabsdetjacinv(b::Bijector, y) = logabsdetjac(inverse(b), y)
 
 ##############################
 # Example bijector: Identity #
@@ -114,7 +114,7 @@ logabsdetjacinv(b::Bijector, y) = logabsdetjac(inv(b), y)
 
 struct Identity{N} <: Bijector{N} end
 (::Identity)(x) = copy(x)
-inv(b::Identity) = b
+inverse(b::Identity) = b
 up1(::Identity{N}) where {N} = Identity{N + 1}()
 
 logabsdetjac(::Identity{0}, x::Real) = zero(eltype(x))
diff --git a/src/transformed_distribution.jl b/src/transformed_distribution.jl
index 48afd2ff..d7d40114 100644
--- a/src/transformed_distribution.jl
+++ b/src/transformed_distribution.jl
@@ -35,7 +35,7 @@ transformed(d) = transformed(d, bijector(d))
 
 Returns the constrained-to-unconstrained bijector for distribution `d`.
 """
-bijector(td::TransformedDistribution) = bijector(td.dist) ∘ inv(td.transform)
+bijector(td::TransformedDistribution) = bijector(td.dist) ∘ inverse(td.transform)
 bijector(d::DiscreteUnivariateDistribution) = Identity{0}()
 bijector(d::DiscreteMultivariateDistribution) = Identity{1}()
 bijector(d::ContinuousUnivariateDistribution) = TruncatedBijector(minimum(d), maximum(d))
@@ -85,14 +85,14 @@ Base.length(td::Transformed) = length(td.dist)
 Base.size(td::Transformed) = size(td.dist)
 
 function logpdf(td::UnivariateTransformed, y::Real)
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return logpdf(td.dist, res[1]) + res[2]
 end
 
 # TODO: implement more efficiently for flows in the case of `Matrix`
 function logpdf(td::MvTransformed, y::AbstractMatrix{<:Real})
     # batch-implementation for multivariate
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return logpdf(td.dist, res[1]) + res[2]
 end
 
@@ -100,12 +100,12 @@ function logpdf(td::MvTransformed{<:Dirichlet}, y::AbstractMatrix{<:Real})
     T = eltype(y)
     ϵ = _eps(T)
 
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return logpdf(td.dist, mappedarray(x->x+ϵ, res[1])) + res[2]
 end
 
 function _logpdf(td::MvTransformed, y::AbstractVector{<:Real})
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return logpdf(td.dist, res[1]) + res[2]
 end
 
@@ -113,15 +113,15 @@ function _logpdf(td::MvTransformed{<:Dirichlet}, y::AbstractVector{<:Real})
     T = eltype(y)
     ϵ = _eps(T)
 
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return logpdf(td.dist, mappedarray(x->x+ϵ, res[1])) + res[2]
 end
 
 # TODO: should eventually drop using `logpdf_with_trans` and replace with
-# res = forward(inv(td.transform), y)
+# res = forward(inverse(td.transform), y)
 # logpdf(td.dist, res[1]) .- res[2]
 function _logpdf(td::MatrixTransformed, y::AbstractMatrix{<:Real})
-    return logpdf_with_trans(td.dist, inv(td.transform)(y), true)
+    return logpdf_with_trans(td.dist, inverse(td.transform)(y), true)
 end
 
 # rand
@@ -163,18 +163,18 @@ Makes use of the `forward` method to potentially re-use computation
 and returns a tuple `(logpdf, logabsdetjac)`.
 """
 function logpdf_with_jac(td::UnivariateTransformed, y::Real)
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return (logpdf(td.dist, res[1]) + res[2], res[2])
 end
 
 # TODO: implement more efficiently for flows in the case of `Matrix`
 function logpdf_with_jac(td::MvTransformed, y::AbstractVector{<:Real})
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return (logpdf(td.dist, res[1]) + res[2], res[2])
 end
 
 function logpdf_with_jac(td::MvTransformed, y::AbstractMatrix{<:Real})
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return (logpdf(td.dist, res[1]) + res[2], res[2])
 end
 
@@ -182,14 +182,14 @@ function logpdf_with_jac(td::MvTransformed{<:Dirichlet}, y::AbstractVector{<:Rea
     T = eltype(y)
     ϵ = _eps(T)
 
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     lp = logpdf(td.dist, mappedarray(x->x+ϵ, res[1])) + res[2]
     return (lp, res[2])
 end
 
 # TODO: should eventually drop using `logpdf_with_trans`
 function logpdf_with_jac(td::MatrixTransformed, y::AbstractMatrix{<:Real})
-    res = forward(inv(td.transform), y)
+    res = forward(inverse(td.transform), y)
     return (logpdf_with_trans(td.dist, res[1], true), res[2])
 end
 
@@ -293,7 +293,7 @@ logabsdetjacinv(d::MultivariateDistribution, x::AbstractVector{T}) where {T<:Rea
 Computes the `logabsdetjac` of the _inverse_ transformation, since `rand(td)` returns
 the _transformed_ random variable.
 """
-logabsdetjacinv(td::UnivariateTransformed, y::Real) = logabsdetjac(inv(td.transform), y)
+logabsdetjacinv(td::UnivariateTransformed, y::Real) = logabsdetjac(inverse(td.transform), y)
 function logabsdetjacinv(td::MvTransformed, y::AbstractVector{<:Real})
-    return logabsdetjac(inv(td.transform), y)
+    return logabsdetjac(inverse(td.transform), y)
 end
diff --git a/test/ad/flows.jl b/test/ad/flows.jl
index 351fa987..335f6333 100644
--- a/test/ad/flows.jl
+++ b/test/ad/flows.jl
@@ -14,12 +14,12 @@
     # logpdf of a flow with the inverse of a planar layer and two-dimensional inputs
     test_ad(randn(7)) do θ
         layer = PlanarLayer(θ[1:2], θ[3:4], θ[5:5])
-        flow = transformed(MvNormal(zeros(2), I), inv(layer))
+        flow = transformed(MvNormal(zeros(2), I), inverse(layer))
         return logpdf_forward(flow, θ[6:7])
     end
     test_ad(randn(11)) do θ
         layer = PlanarLayer(θ[1:2], θ[3:4], θ[5:5])
-        flow = transformed(MvNormal(zeros(2), I), inv(layer))
+        flow = transformed(MvNormal(zeros(2), I), inverse(layer))
         return sum(logpdf_forward(flow, reshape(θ[6:end], 2, :)))
     end
 end
diff --git a/test/bijectors/coupling.jl b/test/bijectors/coupling.jl
index ead12bdb..298eab47 100644
--- a/test/bijectors/coupling.jl
+++ b/test/bijectors/coupling.jl
@@ -34,9 +34,9 @@ using Bijectors:
         @test cl2(x) == cl1(x)
 
         # inversion
-        icl1 = inv(cl1)
+        icl1 = inverse(cl1)
         @test icl1(cl1(x)) == x
-        @test inv(cl2)(cl2(x)) == x
+        @test inverse(cl2)(cl2(x)) == x
 
         # This `cl2` should result in
         b = Shift(x[2:2])
diff --git a/test/bijectors/leaky_relu.jl b/test/bijectors/leaky_relu.jl
index 5a98f5d9..d06a112a 100644
--- a/test/bijectors/leaky_relu.jl
+++ b/test/bijectors/leaky_relu.jl
@@ -14,8 +14,8 @@ true_logabsdetjac(b::Bijector{1}, xs::AbstractMatrix) = mapreduce(z -> true_loga
 @testset "0-dim parameter, 0-dim input" begin
     b = LeakyReLU(0.1; dim=Val(0))
     x = 1.
-    @test inv(b)(b(x)) == x
-    @test inv(b)(b(-x)) == -x
+    @test inverse(b)(b(x)) == x
+    @test inverse(b)(b(-x)) == -x
 
     # Mixing of types
     # 1. Changes in input-type
@@ -54,8 +54,8 @@ end
 
     b = LeakyReLU(0.1; dim=Val(1))
     x = ones(d)
-    @test inv(b)(b(x)) == x
-    @test inv(b)(b(-x)) == -x
+    @test inverse(b)(b(x)) == x
+    @test inverse(b)(b(-x)) == -x
 
     # Batch
     xs = randn(d, 10)
diff --git a/test/bijectors/named_bijector.jl b/test/bijectors/named_bijector.jl
index 015e0a7f..a7248fae 100644
--- a/test/bijectors/named_bijector.jl
+++ b/test/bijectors/named_bijector.jl
@@ -18,7 +18,7 @@ end
     nc2 = b ∘ b
     @test nc1 == nc2
 
-    inc2 = inv(nc2)
+    inc2 = inverse(nc2)
     @test (inc2 ∘ nc2)(x) == x
     @test logabsdetjac((inc2 ∘ nc2), x) ≈ 0.0
 end
@@ -37,18 +37,18 @@ end
 
     x = (a = 1.0, b = 0.5, c = 99999.)
     @test Bijectors.coupling(nc)(x.a) isa Logit
-    @test inv(nc)(nc(x)) == x
+    @test inverse(nc)(nc(x)) == x
 
     @test logabsdetjac(nc, x) == logabsdetjac(Logit(0., 1.), x.b)
-    @test logabsdetjac(inv(nc), nc(x)) == -logabsdetjac(nc, x)
+    @test logabsdetjac(inverse(nc), nc(x)) == -logabsdetjac(nc, x)
 
     x = (a = 0.0, b = 2.0, c = 1.0)
     nc = NamedCoupling(:c, (:a, :b), (a, b) -> Logit(a, b))
     @test nc(x).c == 0.0
-    @test inv(nc)(nc(x)) == x
+    @test inverse(nc)(nc(x)) == x
 
     x = (a = 0.0, b = 2.0, c = 1.0)
     nc = NamedCoupling(:c, (:b, ), b -> Shift(b))
     @test nc(x).c == 3.0
-    @test inv(nc)(nc(x)) == x
+    @test inverse(nc)(nc(x)) == x
 end
diff --git a/test/bijectors/permute.jl b/test/bijectors/permute.jl
index db9f20ac..6602bb03 100644
--- a/test/bijectors/permute.jl
+++ b/test/bijectors/permute.jl
@@ -21,10 +21,10 @@ using Bijectors: Permute
     @test b1.A == b2.A == b3.A == b4.A
 
     x = [1., 2.]
-    @test (inv(b1) ∘ b1)(x) == x
-    @test (inv(b2) ∘ b2)(x) == x
-    @test (inv(b3) ∘ b3)(x) == x
-    @test (inv(b4) ∘ b4)(x) == x
+    @test (inverse(b1) ∘ b1)(x) == x
+    @test (inverse(b2) ∘ b2)(x) == x
+    @test (inverse(b3) ∘ b3)(x) == x
+    @test (inverse(b4) ∘ b4)(x) == x
 
     # Slightly more complex case; one entry is not permuted
     b1 = Permute([
@@ -39,10 +39,10 @@ using Bijectors: Permute
     @test b1.A == b2.A == b3.A == b4.A
     
     x = [1., 2., 3.]
-    @test (inv(b1) ∘ b1)(x) == x
-    @test (inv(b2) ∘ b2)(x) == x
-    @test (inv(b3) ∘ b3)(x) == x
-    @test (inv(b4) ∘ b4)(x) == x
+    @test (inverse(b1) ∘ b1)(x) == x
+    @test (inverse(b2) ∘ b2)(x) == x
+    @test (inverse(b3) ∘ b3)(x) == x
+    @test (inverse(b4) ∘ b4)(x) == x
 
     # logabsdetjac
     @test logabsdetjac(b1, x) == 0.0
diff --git a/test/bijectors/utils.jl b/test/bijectors/utils.jl
index 98919af9..ce2d03c3 100644
--- a/test/bijectors/utils.jl
+++ b/test/bijectors/utils.jl
@@ -6,7 +6,7 @@ function test_bijector_reals(
     isequal = true,
     tol = 1e-6
 )
-    ib = @inferred inv(b)
+    ib = @inferred inverse(b)
     y = @inferred b(x_true)
     logjac = @inferred logabsdetjac(b, x_true)
     ilogjac = @inferred logabsdetjac(ib, y_true)
@@ -14,7 +14,7 @@ function test_bijector_reals(
 
     # If `isequal` is false, then we use the computed `y`,
     # but if it's true, we use the true `y`.
-    ires = isequal ? @inferred(forward(inv(b), y_true)) : @inferred(forward(inv(b), y))
+    ires = isequal ? @inferred(forward(inverse(b), y_true)) : @inferred(forward(inverse(b), y))
 
     # Always want the following to hold
     @test ires[1] ≈ x_true atol=tol
@@ -43,13 +43,13 @@ function test_bijector_arrays(
     isequal = true,
     tol = 1e-6
 )
-    ib = @inferred inv(b)
+    ib = @inferred inverse(b)
     ys = @inferred b(xs_true)
     logjacs = @inferred logabsdetjac(b, xs_true)
     res = @inferred forward(b, xs_true)
     # If `isequal` is false, then we use the computed `y`,
     # but if it's true, we use the true `y`.
-    ires = isequal ? @inferred(forward(inv(b), ys_true)) : @inferred(forward(inv(b), ys))
+    ires = isequal ? @inferred(forward(inverse(b), ys_true)) : @inferred(forward(inverse(b), ys))
 
     # always want the following to hold
     @test ys isa typeof(ys_true)
@@ -118,7 +118,7 @@ function test_bijector(
     logjacs_true::AbstractVector{<:Real};
     kwargs...
 )
-    ib = inv(b)
+    ib = inverse(b)
 
     # Batch
     test_bijector_arrays(b, xs_true, ys_true, logjacs_true; kwargs...)
@@ -148,7 +148,7 @@ function test_bijector(
     logjacs_true::AbstractVector{<:Real};
     kwargs...
 )
-    ib = inv(b)
+    ib = inverse(b)
 
     # Batch
     test_bijector_arrays(b, xs_true, ys_true, logjacs_true; kwargs...)
diff --git a/test/interface.jl b/test/interface.jl
index d79f5acf..f310bc92 100644
--- a/test/interface.jl
+++ b/test/interface.jl
@@ -18,7 +18,7 @@ MyADBijector(d::Distribution) = MyADBijector{Bijectors.ADBackend()}(d)
 MyADBijector{AD}(d::Distribution) where {AD} = MyADBijector{AD}(bijector(d))
 MyADBijector{AD}(b::B) where {AD, N, B <: Bijector{N}} = MyADBijector{AD, N, B}(b)
 (b::MyADBijector)(x) = b.b(x)
-(b::Inverse{<:MyADBijector})(x) = inv(b.orig.b)(x)
+(b::Inverse{<:MyADBijector})(x) = inverse(b.orig.b)(x)
 
 struct NonInvertibleBijector{AD} <: ADBijector{AD, 1} end
 
@@ -73,7 +73,7 @@ end
 
             # single sample
             y = @inferred rand(td)
-            x = @inferred inv(td.transform)(y)
+            x = @inferred inverse(td.transform)(y)
             @test y ≈ @inferred td.transform(x)
             @test @inferred(logpdf(td, y)) ≈ @inferred(logpdf_with_trans(dist, x, true))
 
@@ -84,7 +84,7 @@ end
 
             # multi-sample
             y = @inferred rand(td, 10)
-            x = inv(td.transform).(y)
+            x = inverse(td.transform).(y)
             @test logpdf.(td, y) ≈ logpdf_with_trans.(dist, x, true)
 
             # logpdf corresponds to logpdf_with_trans
@@ -92,12 +92,12 @@ end
             b = @inferred bijector(d)
             x = rand(d)
             y = @inferred b(x)
-            @test logpdf(d, inv(b)(y)) + logabsdetjacinv(b, y) ≈ logpdf_with_trans(d, x, true)
+            @test logpdf(d, inverse(b)(y)) + logabsdetjacinv(b, y) ≈ logpdf_with_trans(d, x, true)
             @test logpdf(d, x) - logabsdetjac(b, x) ≈ logpdf_with_trans(d, x, true)
 
             # forward
             f = @inferred forward(td)
-            @test f.x ≈ inv(td.transform)(f.y)
+            @test f.x ≈ inverse(td.transform)(f.y)
             @test f.y ≈ td.transform(f.x)
             @test f[2] ≈ logabsdetjac(td.transform, f.x)
             @test f.logpdf ≈ logpdf_with_trans(td.dist, f.x, true)
@@ -111,7 +111,7 @@ end
             # `ForwardDiff.derivative` can lead to some numerical inaccuracy,
             # so we use a slightly higher `atol` than default.
             @test log(abs(ForwardDiff.derivative(b, x))) ≈ logabsdetjac(b, x) atol=1e-6
-            @test log(abs(ForwardDiff.derivative(inv(b), y))) ≈ logabsdetjac(inv(b), y) atol=1e-6
+            @test log(abs(ForwardDiff.derivative(inverse(b), y))) ≈ logabsdetjac(inverse(b), y) atol=1e-6
         end
 
         @testset "$dist: ForwardDiff AD" begin
@@ -122,7 +122,7 @@ end
             @test logabsdetjac(b, x) ≠ Inf
 
             y = b(x)
-            b⁻¹ = inv(b)
+            b⁻¹ = inverse(b)
             @test abs(det(Bijectors.jacobian(b⁻¹, y))) > 0
             @test logabsdetjac(b⁻¹, y) ≠ Inf
         end
@@ -135,7 +135,7 @@ end
             @test logabsdetjac(b, x) ≠ Inf
 
             y = b(x)
-            b⁻¹ = inv(b)
+            b⁻¹ = inverse(b)
             @test abs(det(Bijectors.jacobian(b⁻¹, y))) > 0
             @test logabsdetjac(b⁻¹, y) ≠ Inf
         end
@@ -153,7 +153,7 @@ end
         (Exp{0}(), randn(3)),
         (Exp{1}(), randn(2, 3)),
         (Log{1}() ∘ Exp{1}(), randn(2, 3)),
-        (inv(Logit(-1.0, 1.0)), randn(3)),
+        (inverse(Logit(-1.0, 1.0)), randn(3)),
         (Identity{0}(), randn(3)),
         (Identity{1}(), randn(2, 3)),
         (PlanarLayer(2), randn(2, 3)),
@@ -173,7 +173,7 @@ end
     for (b, xs) in bs_xs
         @testset "$b" begin
             D = @inferred Bijectors.dimension(b)
-            ib = @inferred inv(b)
+            ib = @inferred inverse(b)
 
             @test Bijectors.dimension(ib) == D
 
@@ -285,9 +285,9 @@ end
         @test logabsdetjac(cb1, 1.) isa Real
         @test logabsdetjac(cb1, 1.) == 1.
 
-        @test inv(cb1) isa Composed{<:Tuple}
-        @test inv(cb2) isa Composed{<:Tuple}
-        @test inv(cb3) isa Composed{<:Tuple}
+        @test inverse(cb1) isa Composed{<:Tuple}
+        @test inverse(cb2) isa Composed{<:Tuple}
+        @test inverse(cb3) isa Composed{<:Tuple}
 
         # Check that type-unstable composition stays type-unstable
         cb1 = Composed([Exp(), Log()]) ∘ Exp()
@@ -300,9 +300,9 @@ end
         @test logabsdetjac(cb1, 1.) isa Real
         @test logabsdetjac(cb1, 1.) == 1.
 
-        @test inv(cb1) isa Composed{<:AbstractArray}
-        @test inv(cb2) isa Composed{<:AbstractArray}
-        @test inv(cb3) isa Composed{<:AbstractArray}
+        @test inverse(cb1) isa Composed{<:AbstractArray}
+        @test inverse(cb2) isa Composed{<:AbstractArray}
+        @test inverse(cb3) isa Composed{<:AbstractArray}
 
         # combining the two
         @test_throws ErrorException (Log() ∘ Exp()) ∘ cb1
@@ -376,7 +376,7 @@ end
     x = rand(d)
     y = b(x)
     @test y ≈ link(d, x)
-    @test inv(b)(y) ≈ x
+    @test inverse(b)(y) ≈ x
     @test logabsdetjac(b, x) ≈ logpdf_with_trans(d, x, false) - logpdf_with_trans(d, x, true)
 
     d = truncated(Normal(), -Inf, 1)
@@ -384,7 +384,7 @@ end
     x = rand(d)
     y = b(x)
     @test y ≈ link(d, x)
-    @test inv(b)(y) ≈ x
+    @test inverse(b)(y) ≈ x
     @test logabsdetjac(b, x) ≈ logpdf_with_trans(d, x, false) - logpdf_with_trans(d, x, true)
 
     d = truncated(Normal(), 1, Inf)
@@ -392,7 +392,7 @@ end
     x = rand(d)
     y = b(x)
     @test y ≈ link(d, x)
-    @test inv(b)(y) ≈ x
+    @test inverse(b)(y) ≈ x
     @test logabsdetjac(b, x) ≈ logpdf_with_trans(d, x, false) - logpdf_with_trans(d, x, true)
 end
 
@@ -415,8 +415,8 @@ end
 
             # single sample
             y = rand(td)
-            x = inv(td.transform)(y)
-            @test inv(td.transform)(param(y)) isa TrackedArray
+            x = inverse(td.transform)(y)
+            @test inverse(td.transform)(param(y)) isa TrackedArray
             @test y ≈ td.transform(x)
             @test td.transform(param(x)) isa TrackedArray
             @test logpdf(td, y) ≈ logpdf_with_trans(dist, x, true)
@@ -428,13 +428,13 @@ end
 
             # multi-sample
             y = rand(td, 10)
-            x = inv(td.transform)(y)
-            @test inv(td.transform)(param(y)) isa TrackedArray
+            x = inverse(td.transform)(y)
+            @test inverse(td.transform)(param(y)) isa TrackedArray
             @test logpdf(td, y) ≈ logpdf_with_trans(dist, x, true)
 
             # forward
             f = forward(td)
-            @test f.x ≈ inv(td.transform)(f.y)
+            @test f.x ≈ inverse(td.transform)(f.y)
             @test f.y ≈ td.transform(f.x)
             @test f[2] ≈ logabsdetjac(td.transform, f.x)
             @test f.logpdf ≈ logpdf_with_trans(td.dist, f.x, true)
@@ -447,7 +447,7 @@ end
                 y = b(x)
                 @test b(param(x)) isa TrackedArray
                 @test log(abs(det(ForwardDiff.jacobian(b, x)))) ≈ logabsdetjac(b, x)
-                @test log(abs(det(ForwardDiff.jacobian(inv(b), y)))) ≈ logabsdetjac(inv(b), y)
+                @test log(abs(det(ForwardDiff.jacobian(inverse(b), y)))) ≈ logabsdetjac(inverse(b), y)
             else
                 b = bijector(dist)
                 x = rand(dist)
@@ -456,7 +456,7 @@ end
                 # so we use a slightly higher `atol` than default.
                 @test b(param(x)) isa TrackedArray
                 @test log(abs(det(ForwardDiff.jacobian(b, x)))) ≈ logabsdetjac(b, x) atol=1e-6
-                @test log(abs(det(ForwardDiff.jacobian(inv(b), y)))) ≈ logabsdetjac(inv(b), y) atol=1e-6
+                @test log(abs(det(ForwardDiff.jacobian(inverse(b), y)))) ≈ logabsdetjac(inverse(b), y) atol=1e-6
             end
         end
     end
@@ -481,8 +481,8 @@ end
 
             # single sample
             y = rand(td)
-            x = inv(td.transform)(y)
-            @test inv(td.transform)(param(y)) isa TrackedArray
+            x = inverse(td.transform)(y)
+            @test inverse(td.transform)(param(y)) isa TrackedArray
             @test logpdf(td, y) ≈ logpdf_with_trans(dist, x, true)
 
             # TODO: implement `logabsdetjac` for these
@@ -493,8 +493,8 @@ end
 
             # multi-sample
             y = rand(td, 10)
-            x = inv(td.transform)(y)
-            @test inv(td.transform)(param.(y)) isa Vector{<:TrackedArray}
+            x = inverse(td.transform)(y)
+            @test inverse(td.transform)(param.(y)) isa Vector{<:TrackedArray}
             @test logpdf(td, y) ≈ logpdf_with_trans(dist, x, true)
         end
     end
@@ -508,10 +508,10 @@ end
     y = td.transform(x)
 
     b = @inferred Bijectors.composel(td.transform, Bijectors.Identity{0}())
-    ib = @inferred inv(b)
+    ib = @inferred inverse(b)
 
     @test forward(b, x) == forward(td.transform, x)
-    @test forward(ib, y) == forward(inv(td.transform), y)
+    @test forward(ib, y) == forward(inverse(td.transform), y)
 
     @test forward(b, x) == forward(Bijectors.composer(b.ts...), x)
 
@@ -524,26 +524,26 @@ end
 
     # ensures that the `logabsdetjac` is correct
     x = rand(d)
-    b = inv(bijector(d))
+    b = inverse(bijector(d))
     @test logabsdetjac(b ∘ b, x) ≈ logabsdetjac(b, b(x)) + logabsdetjac(b, x)
 
     # order of composed evaluation
     b1 = MyADBijector(d)
     b2 = MyADBijector(Gamma())
 
-    cb = inv(b1) ∘ b2
-    @test cb(x) ≈ inv(b1)(b2(x))
+    cb = inverse(b1) ∘ b2
+    @test cb(x) ≈ inverse(b1)(b2(x))
 
     # contrived example
     b = bijector(d)
-    cb = @inferred inv(b) ∘ b
+    cb = @inferred inverse(b) ∘ b
     cb = @inferred cb ∘ cb
     @test @inferred(cb ∘ cb ∘ cb ∘ cb ∘ cb)(x) ≈ x
 
     # forward for tuple and array
     d = Beta()
-    b = @inferred inv(bijector(d))
-    b⁻¹ = @inferred inv(b)
+    b = @inferred inverse(bijector(d))
+    b⁻¹ = @inferred inverse(b)
     x = rand(d)
 
     cb_t = b⁻¹ ∘ b⁻¹
@@ -571,7 +571,7 @@ end
     x = rand(d)
     y = b(x)
 
-    sb1 = @inferred stack(b, b, inv(b), inv(b))             # <= Tuple
+    sb1 = @inferred stack(b, b, inverse(b), inverse(b))             # <= Tuple
     res1 = forward(sb1, [x, x, y, y])
     @test sb1(param([x, x, y, y])) isa TrackedArray
 
@@ -579,7 +579,7 @@ end
     @test logabsdetjac(sb1, [x, x, y, y]) ≈ 0 atol=1e-6
     @test res1[2] ≈ 0 atol=1e-6
 
-    sb2 = Stacked([b, b, inv(b), inv(b)])        # <= Array
+    sb2 = Stacked([b, b, inverse(b), inverse(b)])        # <= Array
     res2 = forward(sb2, [x, x, y, y])
     @test sb2(param([x, x, y, y])) isa TrackedArray
 
@@ -591,7 +591,7 @@ end
     b = MyADBijector(d)
     y = b(x)
     
-    sb1 = stack(b, b, inv(b), inv(b))             # <= Tuple
+    sb1 = stack(b, b, inverse(b), inverse(b))             # <= Tuple
     res1 = forward(sb1, [x, x, y, y])
     @test sb1(param([x, x, y, y])) isa TrackedArray
 
@@ -599,7 +599,7 @@ end
     @test logabsdetjac(sb1, [x, x, y, y]) ≈ 0 atol=1e-12
     @test res1[2] ≈ 0.0 atol=1e-12
 
-    sb2 = Stacked([b, b, inv(b), inv(b)])        # <= Array
+    sb2 = Stacked([b, b, inverse(b), inverse(b)])        # <= Array
     res2 = forward(sb2, [x, x, y, y])
     @test sb2(param([x, x, y, y])) isa TrackedArray
 
@@ -719,9 +719,9 @@ end
 
         # Stacked{<:Tuple}
         bs = bijector.(tuple(dists...))
-        ibs = inv.(bs)
+        ibs = inverse.(bs)
         sb = @inferred Stacked(ibs, ranges)
-        isb = @inferred inv(sb)
+        isb = @inferred inverse(sb)
         @test sb isa Stacked{<:Tuple}
 
         # inverse
@@ -756,7 +756,7 @@ end
     # Usage in ADVI
     d = Beta()
     b = bijector(d)                # [0, 1] → ℝ
-    ib = inv(b)                    # ℝ → [0, 1]
+    ib = inverse(b)                    # ℝ → [0, 1]
     td = transformed(Normal(), ib) # x ∼ 𝓝(0, 1) then f(x) ∈ [0, 1]
     x = rand(td)                   # ∈ [0, 1]
     @test 0 ≤ x ≤ 1
@@ -764,7 +764,7 @@ end
 
 @testset "Jacobians of SimplexBijector" begin
     b = SimplexBijector()
-    ib = inv(b)
+    ib = inverse(b)
 
     x = ib(randn(10))
     y = b(x)
@@ -847,7 +847,7 @@ end
     for i in 1:length(bs), j in 1:length(bs)
         if i == j
             @test bs[i] == deepcopy(bs[j])
-            @test inv(bs[i]) == inv(deepcopy(bs[j]))
+            @test inverse(bs[i]) == inverse(deepcopy(bs[j]))
         else
             @test bs[i] != bs[j]
         end
diff --git a/test/norm_flows.jl b/test/norm_flows.jl
index 9fadf573..38ea7e5f 100644
--- a/test/norm_flows.jl
+++ b/test/norm_flows.jl
@@ -8,15 +8,15 @@ seed!(1)
     x = randn(2, 20)
     bn = InvertibleBatchNorm(2)
 
-    @test inv(inv(bn)) == bn
-    @test inv(bn)(bn(x)) ≈ x
-    @test (inv(bn) ∘ bn)(x) ≈ x
+    @test inverse(inverse(bn)) == bn
+    @test inverse(bn)(bn(x)) ≈ x
+    @test (inverse(bn) ∘ bn)(x) ≈ x
     @test_throws ErrorException forward(bn, randn(10,2))
-    @test logabsdetjac(inv(bn), bn(x)) ≈ - logabsdetjac(bn, x)
+    @test logabsdetjac(inverse(bn), bn(x)) ≈ - logabsdetjac(bn, x)
 
     y, ladj = forward(bn, x)
     @test log(abs(det(ForwardDiff.jacobian(bn, x)))) ≈ sum(ladj)
-    @test log(abs(det(ForwardDiff.jacobian(inv(bn), y)))) ≈ sum(logabsdetjac(inv(bn), y))
+    @test log(abs(det(ForwardDiff.jacobian(inverse(bn), y)))) ≈ sum(logabsdetjac(inverse(bn), y))
 
     test_functor(bn, (b = bn.b, logs = bn.logs))
 end
@@ -29,8 +29,8 @@ end
         our_method = sum(forward(flow, z)[2])
 
         @test our_method ≈ forward_diff
-        @test inv(flow)(flow(z)) ≈ z
-        @test (inv(flow) ∘ flow)(z) ≈ z
+        @test inverse(flow)(flow(z)) ≈ z
+        @test (inverse(flow) ∘ flow)(z) ≈ z
     end
 
     w = ones(10)
@@ -38,10 +38,10 @@ end
     b = 1.0
     flow = PlanarLayer(w, u, b)
     z = ones(10, 100)
-    @test inv(flow)(flow(z)) ≈ z
+    @test inverse(flow)(flow(z)) ≈ z
 
     test_functor(flow, (w = w, u = u, b = b))
-    test_functor(inv(flow), (orig = flow,))
+    test_functor(inverse(flow), (orig = flow,))
 
     @testset "find_alpha" begin
         for wt_y in (-20.3, -3, -3//2, 0.0, 5, 29//4, 12.3)
@@ -77,8 +77,8 @@ end
         our_method = sum(forward(flow, z)[2])
 
         @test our_method ≈ forward_diff
-        @test inv(flow)(flow(z)) ≈ z rtol=0.2
-        @test (inv(flow) ∘ flow)(z) ≈ z rtol=0.2
+        @test inverse(flow)(flow(z)) ≈ z rtol=0.2
+        @test (inverse(flow) ∘ flow)(z) ≈ z rtol=0.2
     end
 
     α_ = 1.0
@@ -86,10 +86,10 @@ end
     z_0 = zeros(10)
     z = ones(10, 100)
     flow = RadialLayer(α_, β, z_0)
-    @test inv(flow)(flow(z)) ≈ z
+    @test inverse(flow)(flow(z)) ≈ z
 
     test_functor(flow, (α_ = α_, β = β, z_0 = z_0))
-    test_functor(inv(flow), (orig = flow,))
+    test_functor(inverse(flow), (orig = flow,))
 end
 
 @testset "Flows" begin
@@ -110,9 +110,9 @@ end
 
     # flow with unconstrained-to-constrained
     d1 = Beta()
-    b1 = inv(bijector(d1))
+    b1 = inverse(bijector(d1))
     d2 = InverseGamma()
-    b2 = inv(bijector(d2))
+    b2 = inverse(bijector(d2))
 
     x = rand(d) .+ 10
     y = b(x)