Is it possible to implement time delayed differential equation

[JDM-Pfizer]

Hi this is just a general question. I was wondering using deepXDE or PINN in general is it possible to implement time delayed systems of ordinary differential equation. For example, lets say a have a system of equation systems with a time delay tau
dy1/dt=2y1-2y2(t-tau)
dy2/dt=-2y1(t-tau)+2y2

is this time delay something that can be enabled? Thanks

[lululxvi]

DeepXDE doesn't support this directly, but this can be implemented.

[pablowugoths581]

I have the same question as well and I'm curious about how to implement this:

My idea is to add a class and a wrapped function in gradient.py:

class Translate:
"""Transform ys by applying a transformation to xs and evaluating ys with the transformed xs."""

def __init__(self, ys, xs):
    """
    Args:
        ys: Output Tensor of shape (batch_size, dim_y).
        xs: Input Tensor of shape (batch_size, dim_x).
    """
    self.ys = ys
    self.xs = xs

def __call__(self, transform_fn, evaluate_fn):
    """Apply a transformation to xs and return the transformed ys.

    Args:
        transform_fn: A callable to transform xs. Should take xs as input and return transformed xs.
        evaluate_fn: A callable to compute transformed ys, given transformed xs and original ys.

    Returns:
        Transformed ys, based on transformed xs and original ys, of the same type as ys.
    """
    transformed_xs = transform_fn(self.xs)
    return evaluate_fn(self.ys, transformed_xs)

def translate(ys, xs, transform_fn, evaluate_fn):
"""Transform ys by applying a transformation to xs.

Args:
    ys: Output Tensor of shape (batch_size, dim_y).
    xs: Input Tensor of shape (batch_size, dim_x).
    transform_fn: A callable to transform xs. Should take xs as input and return transformed xs.
    evaluate_fn: A callable to compute transformed ys, given transformed xs and original ys.

Returns:
    Transformed ys, based on transformed xs and original ys.
"""
return Translate(ys, xs)(transform_fn, evaluate_fn)

and implement it outside by something like:

def translated_value(y, x, shift):
"""
Evaluate y(x - shift) where shift is a translation applied to x.
"""
# Translate x
x_translated = x - shift

# Use the same function `y` with new translated input
y_translated = dde.grad.translate(y, x, lambda xs: xs - shift, lambda ys, _: ys)

return y_translated

However, the implementation does not work as intended because the input x in the function pde(x, y) does not shift accordingly with the transformations. Is it possible to make this approach work based on my current idea, or would you suggest implementing it in a different way?

Thank you very much for your help!