We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
A multioutput Kuf function throws an error
<!-- Lines like this are comments and will be invisible -->

# Bug

<!-- A clear and concise description of what the bug is. -->

The multioutput covariance function `Kuf` has several functions corresponding to different combinations of parameters. The function which accepts `FallbackSeparateIndependentInducingVariables` or `FallbackSharedIndependentInducingVariables` along with the `LinearCoregionalization` kernel throws an error.

## To reproduce

**Minimal, reproducible example**
<!-- We need to be able to reproduce the bug by simply copy and pasting your code -->
```python
import numpy as np
import gpflow
import gpflow.inducing_variables.multioutput as mf
import gpflow.kernels.multioutput as mk
from gpflow.covariances.multioutput import kufs as mo_kufs

inducing_variables = mf.FallbackSharedIndependentInducingVariables(
    gpflow.inducing_variables.InducingPoints(np.random.rand(1, 1)))
kernel = mk.LinearCoregionalization(make_kernels(Datum.L), Datum.W)
Kuf = mo_kufs.Kuf(inducing_variables, kernel, Datum.Xnew)
```

**Stack trace, or error message**
```
    @Kuf.register(
        (FallbackSeparateIndependentInducingVariables, FallbackSharedIndependentInducingVariables),
        LinearCoregionalization,
        object,
    )
    def _Kuf(
        inducing_variable: Union[
            SeparateIndependentInducingVariables, SharedIndependentInducingVariables
        ],
        kernel: LinearCoregionalization,
        Xnew: tf.Tensor,
    ):
        kuf_impl = Kuf.dispatch(type(inducing_variable), SeparateIndependent, object)
>       K = tf.transpose(kuf_impl(inducing_variable, kernel, Xnew), [1, 0, 2])  # [M, L, N]
E       TypeError: 'NoneType' object is not callable

../../../gpflow/covariances/multioutput/kufs.py:96: TypeError

```

## Expected behavior

The covariance should be computed.

## System information

* GPflow version: 2.1.4
* GPflow installed from: git commit 405eb97dd30cb43f02501b58b581f2608eb6e43e
* TensorFlow version: 2.3.0
* Python version: 3.7.5
* Operating system: Ubuntu 18.04.5 LTS

## Additional context

<!-- Add any other context about the problem here. -->


--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `gpflow/covariances/multioutput/kufs.py`
Content:
```
1 # Copyright 2017-2020 The GPflow Contributors. All Rights Reserved.
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
6 #
7 # http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14 
15 from typing import Union
16 
17 import tensorflow as tf
18 
19 from ...inducing_variables import (
20     FallbackSeparateIndependentInducingVariables,
21     FallbackSharedIndependentInducingVariables,
22     InducingPoints,
23     SeparateIndependentInducingVariables,
24     SharedIndependentInducingVariables,
25 )
26 from ...kernels import (
27     LinearCoregionalization,
28     MultioutputKernel,
29     SeparateIndependent,
30     SharedIndependent,
31 )
32 from ..dispatch import Kuf
33 
34 
35 @Kuf.register(InducingPoints, MultioutputKernel, object)
36 def _Kuf(inducing_variable: InducingPoints, kernel: MultioutputKernel, Xnew: tf.Tensor):
37     return kernel(inducing_variable.Z, Xnew, full_cov=True, full_output_cov=True)  # [M, P, N, P]
38 
39 
40 @Kuf.register(SharedIndependentInducingVariables, SharedIndependent, object)
41 def _Kuf(
42     inducing_variable: SharedIndependentInducingVariables,
43     kernel: SharedIndependent,
44     Xnew: tf.Tensor,
45 ):
46     return Kuf(inducing_variable.inducing_variable, kernel.kernel, Xnew)  # [M, N]
47 
48 
49 @Kuf.register(SeparateIndependentInducingVariables, SharedIndependent, object)
50 def _Kuf(
51     inducing_variable: SeparateIndependentInducingVariables,
52     kernel: SharedIndependent,
53     Xnew: tf.Tensor,
54 ):
55     return tf.stack(
56         [Kuf(f, kernel.kernel, Xnew) for f in inducing_variable.inducing_variable_list], axis=0
57     )  # [L, M, N]
58 
59 
60 @Kuf.register(SharedIndependentInducingVariables, SeparateIndependent, object)
61 def _Kuf(
62     inducing_variable: SharedIndependentInducingVariables,
63     kernel: SeparateIndependent,
64     Xnew: tf.Tensor,
65 ):
66     return tf.stack(
67         [Kuf(inducing_variable.inducing_variable, k, Xnew) for k in kernel.kernels], axis=0
68     )  # [L, M, N]
69 
70 
71 @Kuf.register(SeparateIndependentInducingVariables, SeparateIndependent, object)
72 def _Kuf(
73     inducing_variable: SeparateIndependentInducingVariables,
74     kernel: SeparateIndependent,
75     Xnew: tf.Tensor,
76 ):
77     Kufs = [
78         Kuf(f, k, Xnew) for f, k in zip(inducing_variable.inducing_variable_list, kernel.kernels)
79     ]
80     return tf.stack(Kufs, axis=0)  # [L, M, N]
81 
82 
83 @Kuf.register(
84     (FallbackSeparateIndependentInducingVariables, FallbackSharedIndependentInducingVariables),
85     LinearCoregionalization,
86     object,
87 )
88 def _Kuf(
89     inducing_variable: Union[
90         SeparateIndependentInducingVariables, SharedIndependentInducingVariables
91     ],
92     kernel: LinearCoregionalization,
93     Xnew: tf.Tensor,
94 ):
95     kuf_impl = Kuf.dispatch(type(inducing_variable), SeparateIndependent, object)
96     K = tf.transpose(kuf_impl(inducing_variable, kernel, Xnew), [1, 0, 2])  # [M, L, N]
97     return K[:, :, :, None] * tf.transpose(kernel.W)[None, :, None, :]  # [M, L, N, P]
98 
99 
100 @Kuf.register(SharedIndependentInducingVariables, LinearCoregionalization, object)
101 def _Kuf(
102     inducing_variable: SharedIndependentInducingVariables,
103     kernel: SeparateIndependent,
104     Xnew: tf.Tensor,
105 ):
106     return tf.stack(
107         [Kuf(inducing_variable.inducing_variable, k, Xnew) for k in kernel.kernels], axis=0
108     )  # [L, M, N]
109 
110 
111 @Kuf.register(SeparateIndependentInducingVariables, LinearCoregionalization, object)
112 def _Kuf(inducing_variable, kernel, Xnew):
113     return tf.stack(
114         [Kuf(f, k, Xnew) for f, k in zip(inducing_variable.inducing_variable_list, kernel.kernels)],
115         axis=0,
116     )  # [L, M, N]
117
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/gpflow/covariances/multioutput/kufs.py b/gpflow/covariances/multioutput/kufs.py
--- a/gpflow/covariances/multioutput/kufs.py
+++ b/gpflow/covariances/multioutput/kufs.py
@@ -80,23 +80,42 @@
     return tf.stack(Kufs, axis=0)  # [L, M, N]
 
 
-@Kuf.register(
-    (FallbackSeparateIndependentInducingVariables, FallbackSharedIndependentInducingVariables),
-    LinearCoregionalization,
-    object,
-)
-def _Kuf(
+def _fallback_Kuf(
+    kuf_impl,
     inducing_variable: Union[
         SeparateIndependentInducingVariables, SharedIndependentInducingVariables
     ],
     kernel: LinearCoregionalization,
     Xnew: tf.Tensor,
 ):
-    kuf_impl = Kuf.dispatch(type(inducing_variable), SeparateIndependent, object)
     K = tf.transpose(kuf_impl(inducing_variable, kernel, Xnew), [1, 0, 2])  # [M, L, N]
     return K[:, :, :, None] * tf.transpose(kernel.W)[None, :, None, :]  # [M, L, N, P]
 
 
+@Kuf.register(
+    FallbackSeparateIndependentInducingVariables, LinearCoregionalization, object,
+)
+def _Kuf(
+    inducing_variable: FallbackSeparateIndependentInducingVariables,
+    kernel: LinearCoregionalization,
+    Xnew: tf.Tensor,
+):
+    kuf_impl = Kuf.dispatch(SeparateIndependentInducingVariables, SeparateIndependent, object)
+    return _fallback_Kuf(kuf_impl, inducing_variable, kernel, Xnew)
+
+
+@Kuf.register(
+    FallbackSharedIndependentInducingVariables, LinearCoregionalization, object,
+)
+def _Kuf(
+    inducing_variable: FallbackSharedIndependentInducingVariables,
+    kernel: LinearCoregionalization,
+    Xnew: tf.Tensor,
+):
+    kuf_impl = Kuf.dispatch(SharedIndependentInducingVariables, SeparateIndependent, object)
+    return _fallback_Kuf(kuf_impl, inducing_variable, kernel, Xnew)
+
+
 @Kuf.register(SharedIndependentInducingVariables, LinearCoregionalization, object)
 def _Kuf(
     inducing_variable: SharedIndependentInducingVariables,

{"golden_diff": "diff --git a/gpflow/covariances/multioutput/kufs.py b/gpflow/covariances/multioutput/kufs.py\n--- a/gpflow/covariances/multioutput/kufs.py\n+++ b/gpflow/covariances/multioutput/kufs.py\n@@ -80,23 +80,42 @@\n     return tf.stack(Kufs, axis=0)  # [L, M, N]\n \n \n-@Kuf.register(\n-    (FallbackSeparateIndependentInducingVariables, FallbackSharedIndependentInducingVariables),\n-    LinearCoregionalization,\n-    object,\n-)\n-def _Kuf(\n+def _fallback_Kuf(\n+    kuf_impl,\n     inducing_variable: Union[\n         SeparateIndependentInducingVariables, SharedIndependentInducingVariables\n     ],\n     kernel: LinearCoregionalization,\n     Xnew: tf.Tensor,\n ):\n-    kuf_impl = Kuf.dispatch(type(inducing_variable), SeparateIndependent, object)\n     K = tf.transpose(kuf_impl(inducing_variable, kernel, Xnew), [1, 0, 2])  # [M, L, N]\n     return K[:, :, :, None] * tf.transpose(kernel.W)[None, :, None, :]  # [M, L, N, P]\n \n \n+@Kuf.register(\n+    FallbackSeparateIndependentInducingVariables, LinearCoregionalization, object,\n+)\n+def _Kuf(\n+    inducing_variable: FallbackSeparateIndependentInducingVariables,\n+    kernel: LinearCoregionalization,\n+    Xnew: tf.Tensor,\n+):\n+    kuf_impl = Kuf.dispatch(SeparateIndependentInducingVariables, SeparateIndependent, object)\n+    return _fallback_Kuf(kuf_impl, inducing_variable, kernel, Xnew)\n+\n+\n+@Kuf.register(\n+    FallbackSharedIndependentInducingVariables, LinearCoregionalization, object,\n+)\n+def _Kuf(\n+    inducing_variable: FallbackSharedIndependentInducingVariables,\n+    kernel: LinearCoregionalization,\n+    Xnew: tf.Tensor,\n+):\n+    kuf_impl = Kuf.dispatch(SharedIndependentInducingVariables, SeparateIndependent, object)\n+    return _fallback_Kuf(kuf_impl, inducing_variable, kernel, Xnew)\n+\n+\n @Kuf.register(SharedIndependentInducingVariables, LinearCoregionalization, object)\n def _Kuf(\n     inducing_variable: SharedIndependentInducingVariables,\n", "issue": "A multioutput Kuf function throws an error\n<!-- Lines like this are comments and will be invisible -->\r\n\r\n# Bug\r\n\r\n<!-- A clear and concise description of what the bug is. -->\r\n\r\nThe multioutput covariance function `Kuf` has several functions corresponding to different combinations of parameters. The function which accepts `FallbackSeparateIndependentInducingVariables` or `FallbackSharedIndependentInducingVariables` along with the `LinearCoregionalization` kernel throws an error.\r\n\r\n## To reproduce\r\n\r\n**Minimal, reproducible example**\r\n<!-- We need to be able to reproduce the bug by simply copy and pasting your code -->\r\n```python\r\nimport numpy as np\r\nimport gpflow\r\nimport gpflow.inducing_variables.multioutput as mf\r\nimport gpflow.kernels.multioutput as mk\r\nfrom gpflow.covariances.multioutput import kufs as mo_kufs\r\n\r\ninducing_variables = mf.FallbackSharedIndependentInducingVariables(\r\n    gpflow.inducing_variables.InducingPoints(np.random.rand(1, 1)))\r\nkernel = mk.LinearCoregionalization(make_kernels(Datum.L), Datum.W)\r\nKuf = mo_kufs.Kuf(inducing_variables, kernel, Datum.Xnew)\r\n```\r\n\r\n**Stack trace, or error message**\r\n```\r\n    @Kuf.register(\r\n        (FallbackSeparateIndependentInducingVariables, FallbackSharedIndependentInducingVariables),\r\n        LinearCoregionalization,\r\n        object,\r\n    )\r\n    def _Kuf(\r\n        inducing_variable: Union[\r\n            SeparateIndependentInducingVariables, SharedIndependentInducingVariables\r\n        ],\r\n        kernel: LinearCoregionalization,\r\n        Xnew: tf.Tensor,\r\n    ):\r\n        kuf_impl = Kuf.dispatch(type(inducing_variable), SeparateIndependent, object)\r\n>       K = tf.transpose(kuf_impl(inducing_variable, kernel, Xnew), [1, 0, 2])  # [M, L, N]\r\nE       TypeError: 'NoneType' object is not callable\r\n\r\n../../../gpflow/covariances/multioutput/kufs.py:96: TypeError\r\n\r\n```\r\n\r\n## Expected behavior\r\n\r\nThe covariance should be computed.\r\n\r\n## System information\r\n\r\n* GPflow version: 2.1.4\r\n* GPflow installed from: git commit 405eb97dd30cb43f02501b58b581f2608eb6e43e\r\n* TensorFlow version: 2.3.0\r\n* Python version: 3.7.5\r\n* Operating system: Ubuntu 18.04.5 LTS\r\n\r\n## Additional context\r\n\r\n<!-- Add any other context about the problem here. -->\r\n\n", "before_files": [{"content": "# Copyright 2017-2020 The GPflow Contributors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Union\n\nimport tensorflow as tf\n\nfrom ...inducing_variables import (\n    FallbackSeparateIndependentInducingVariables,\n    FallbackSharedIndependentInducingVariables,\n    InducingPoints,\n    SeparateIndependentInducingVariables,\n    SharedIndependentInducingVariables,\n)\nfrom ...kernels import (\n    LinearCoregionalization,\n    MultioutputKernel,\n    SeparateIndependent,\n    SharedIndependent,\n)\nfrom ..dispatch import Kuf\n\n\n@Kuf.register(InducingPoints, MultioutputKernel, object)\ndef _Kuf(inducing_variable: InducingPoints, kernel: MultioutputKernel, Xnew: tf.Tensor):\n    return kernel(inducing_variable.Z, Xnew, full_cov=True, full_output_cov=True)  # [M, P, N, P]\n\n\n@Kuf.register(SharedIndependentInducingVariables, SharedIndependent, object)\ndef _Kuf(\n    inducing_variable: SharedIndependentInducingVariables,\n    kernel: SharedIndependent,\n    Xnew: tf.Tensor,\n):\n    return Kuf(inducing_variable.inducing_variable, kernel.kernel, Xnew)  # [M, N]\n\n\n@Kuf.register(SeparateIndependentInducingVariables, SharedIndependent, object)\ndef _Kuf(\n    inducing_variable: SeparateIndependentInducingVariables,\n    kernel: SharedIndependent,\n    Xnew: tf.Tensor,\n):\n    return tf.stack(\n        [Kuf(f, kernel.kernel, Xnew) for f in inducing_variable.inducing_variable_list], axis=0\n    )  # [L, M, N]\n\n\n@Kuf.register(SharedIndependentInducingVariables, SeparateIndependent, object)\ndef _Kuf(\n    inducing_variable: SharedIndependentInducingVariables,\n    kernel: SeparateIndependent,\n    Xnew: tf.Tensor,\n):\n    return tf.stack(\n        [Kuf(inducing_variable.inducing_variable, k, Xnew) for k in kernel.kernels], axis=0\n    )  # [L, M, N]\n\n\n@Kuf.register(SeparateIndependentInducingVariables, SeparateIndependent, object)\ndef _Kuf(\n    inducing_variable: SeparateIndependentInducingVariables,\n    kernel: SeparateIndependent,\n    Xnew: tf.Tensor,\n):\n    Kufs = [\n        Kuf(f, k, Xnew) for f, k in zip(inducing_variable.inducing_variable_list, kernel.kernels)\n    ]\n    return tf.stack(Kufs, axis=0)  # [L, M, N]\n\n\n@Kuf.register(\n    (FallbackSeparateIndependentInducingVariables, FallbackSharedIndependentInducingVariables),\n    LinearCoregionalization,\n    object,\n)\ndef _Kuf(\n    inducing_variable: Union[\n        SeparateIndependentInducingVariables, SharedIndependentInducingVariables\n    ],\n    kernel: LinearCoregionalization,\n    Xnew: tf.Tensor,\n):\n    kuf_impl = Kuf.dispatch(type(inducing_variable), SeparateIndependent, object)\n    K = tf.transpose(kuf_impl(inducing_variable, kernel, Xnew), [1, 0, 2])  # [M, L, N]\n    return K[:, :, :, None] * tf.transpose(kernel.W)[None, :, None, :]  # [M, L, N, P]\n\n\n@Kuf.register(SharedIndependentInducingVariables, LinearCoregionalization, object)\ndef _Kuf(\n    inducing_variable: SharedIndependentInducingVariables,\n    kernel: SeparateIndependent,\n    Xnew: tf.Tensor,\n):\n    return tf.stack(\n        [Kuf(inducing_variable.inducing_variable, k, Xnew) for k in kernel.kernels], axis=0\n    )  # [L, M, N]\n\n\n@Kuf.register(SeparateIndependentInducingVariables, LinearCoregionalization, object)\ndef _Kuf(inducing_variable, kernel, Xnew):\n    return tf.stack(\n        [Kuf(f, k, Xnew) for f, k in zip(inducing_variable.inducing_variable_list, kernel.kernels)],\n        axis=0,\n    )  # [L, M, N]\n", "path": "gpflow/covariances/multioutput/kufs.py"}], "after_files": [{"content": "# Copyright 2017-2020 The GPflow Contributors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Union\n\nimport tensorflow as tf\n\nfrom ...inducing_variables import (\n    FallbackSeparateIndependentInducingVariables,\n    FallbackSharedIndependentInducingVariables,\n    InducingPoints,\n    SeparateIndependentInducingVariables,\n    SharedIndependentInducingVariables,\n)\nfrom ...kernels import (\n    LinearCoregionalization,\n    MultioutputKernel,\n    SeparateIndependent,\n    SharedIndependent,\n)\nfrom ..dispatch import Kuf\n\n\n@Kuf.register(InducingPoints, MultioutputKernel, object)\ndef _Kuf(inducing_variable: InducingPoints, kernel: MultioutputKernel, Xnew: tf.Tensor):\n    return kernel(inducing_variable.Z, Xnew, full_cov=True, full_output_cov=True)  # [M, P, N, P]\n\n\n@Kuf.register(SharedIndependentInducingVariables, SharedIndependent, object)\ndef _Kuf(\n    inducing_variable: SharedIndependentInducingVariables,\n    kernel: SharedIndependent,\n    Xnew: tf.Tensor,\n):\n    return Kuf(inducing_variable.inducing_variable, kernel.kernel, Xnew)  # [M, N]\n\n\n@Kuf.register(SeparateIndependentInducingVariables, SharedIndependent, object)\ndef _Kuf(\n    inducing_variable: SeparateIndependentInducingVariables,\n    kernel: SharedIndependent,\n    Xnew: tf.Tensor,\n):\n    return tf.stack(\n        [Kuf(f, kernel.kernel, Xnew) for f in inducing_variable.inducing_variable_list], axis=0\n    )  # [L, M, N]\n\n\n@Kuf.register(SharedIndependentInducingVariables, SeparateIndependent, object)\ndef _Kuf(\n    inducing_variable: SharedIndependentInducingVariables,\n    kernel: SeparateIndependent,\n    Xnew: tf.Tensor,\n):\n    return tf.stack(\n        [Kuf(inducing_variable.inducing_variable, k, Xnew) for k in kernel.kernels], axis=0\n    )  # [L, M, N]\n\n\n@Kuf.register(SeparateIndependentInducingVariables, SeparateIndependent, object)\ndef _Kuf(\n    inducing_variable: SeparateIndependentInducingVariables,\n    kernel: SeparateIndependent,\n    Xnew: tf.Tensor,\n):\n    Kufs = [\n        Kuf(f, k, Xnew) for f, k in zip(inducing_variable.inducing_variable_list, kernel.kernels)\n    ]\n    return tf.stack(Kufs, axis=0)  # [L, M, N]\n\n\ndef _fallback_Kuf(\n    kuf_impl,\n    inducing_variable: Union[\n        SeparateIndependentInducingVariables, SharedIndependentInducingVariables\n    ],\n    kernel: LinearCoregionalization,\n    Xnew: tf.Tensor,\n):\n    K = tf.transpose(kuf_impl(inducing_variable, kernel, Xnew), [1, 0, 2])  # [M, L, N]\n    return K[:, :, :, None] * tf.transpose(kernel.W)[None, :, None, :]  # [M, L, N, P]\n\n\n@Kuf.register(\n    FallbackSeparateIndependentInducingVariables, LinearCoregionalization, object,\n)\ndef _Kuf(\n    inducing_variable: FallbackSeparateIndependentInducingVariables,\n    kernel: LinearCoregionalization,\n    Xnew: tf.Tensor,\n):\n    kuf_impl = Kuf.dispatch(SeparateIndependentInducingVariables, SeparateIndependent, object)\n    return _fallback_Kuf(kuf_impl, inducing_variable, kernel, Xnew)\n\n\n@Kuf.register(\n    FallbackSharedIndependentInducingVariables, LinearCoregionalization, object,\n)\ndef _Kuf(\n    inducing_variable: FallbackSharedIndependentInducingVariables,\n    kernel: LinearCoregionalization,\n    Xnew: tf.Tensor,\n):\n    kuf_impl = Kuf.dispatch(SharedIndependentInducingVariables, SeparateIndependent, object)\n    return _fallback_Kuf(kuf_impl, inducing_variable, kernel, Xnew)\n\n\n@Kuf.register(SharedIndependentInducingVariables, LinearCoregionalization, object)\ndef _Kuf(\n    inducing_variable: SharedIndependentInducingVariables,\n    kernel: SeparateIndependent,\n    Xnew: tf.Tensor,\n):\n    return tf.stack(\n        [Kuf(inducing_variable.inducing_variable, k, Xnew) for k in kernel.kernels], axis=0\n    )  # [L, M, N]\n\n\n@Kuf.register(SeparateIndependentInducingVariables, LinearCoregionalization, object)\ndef _Kuf(inducing_variable, kernel, Xnew):\n    return tf.stack(\n        [Kuf(f, k, Xnew) for f, k in zip(inducing_variable.inducing_variable_list, kernel.kernels)],\n        axis=0,\n    )  # [L, M, N]\n", "path": "gpflow/covariances/multioutput/kufs.py"}]}