You are given four numbers. The first three are $a$, $b$, and $c$ respectively, for the sequence:

$$T_n=an^2+bn+c$$

You may take input of these four numbers in any way. The output should be one of two distinct outputs mentioned in your answer, one means that the fourth number is a term in the sequence (the above equation has at least one solution for $n$ which is an integer when $a$, $b$, $c$ and $T_n$ are substituted for the given values), the other means the opposite.

This is code golf, so the shortest answer in bytes wins. Your program should work for any input of $a, b, c, T_n$ where the numbers are negative or positive (or 0), decimal or integer. To avoid problems but keep some complexity, non-integers will always just end in $.5$. Standard loop-holes disallowed.

Test cases

a   |b   |c   |T_n |Y/N

------------------------

1   |1   |1   |1   |Y     #n=0

2   |3   |5   |2   |N

0.5 |1   |-2  |-0.5|Y     #n=1

0.5 |1   |-2  |15.5|Y     #n=5

0.5 |1   |-2  |3   |N     

-3.5|2   |-6  |-934|Y     #n=-16

0   |1   |4   |7   |Y     #n=3

0   |3   |-1  |7   |N

0   |0   |0   |1   |N

0   |0   |6   |6   |Y     #n=<anything>

4   |8   |5   |2   |N

JavaScript (ES7), 70 bytes

Returns a Boolean value.

(a,b,c,t)=>(t-=c,(a*=2)?(x=(b*b+2*a*t)**.5-b)%a&&(x+b+b)%a:b?t%b:t)==0

Try it online!

How?

For the sake of clarity, we define $d = T_n-c$. (The same variable $t$ is re-used to store this result in the JS code.)

Case $aneq0$

The equation really is quadratic:

$$T_n=an^2+bn+c\
an^2+bn-d=0$$

With $a'=2a$, the discriminant is:

$$Delta=b^2+2a'd$$

and the roots are:

$$n_0=frac{-b-sqrt{Delta}}{a'}\
n_1=frac{-b+sqrt{Delta}}{a'}$$

The equation admits an integer root if $sqrt{Delta}$ is an integer and either:

$$begin{align}&-b-sqrt{Delta}equiv 0pmod{a'}\ text{ or }&-b+sqrt{Delta}equiv 0pmod{a'}end{align}$$

Case $a=0, bneq0$

The equation is linear:

$$T_n=bn+c\
bn=d\
n=frac{d}{b}$$

It admits an integer root if $dequiv0pmod b$.

Case $a=0, b=0$

The equation is not depending on $n$ anymore:

$$T_n=c\
d=0$$

Jelly,  11  10 bytes

_/Ær1Ẹ?%1Ạ

A monadic Link which accepts a list of lists* [[c, b, a], [T_n]] and yields 0 if T_n is a valid solution or 1 if not.

* admittedly taking a little liberty with "You may take input of these four numbers in any way".

Try it online! Or see a test-suite.

How?

_/Ær1Ẹ?%1Ạ - Link: list of lists of integers, [[c, b, a], [T_n]]

 /         - reduce by:

_          -   subtraction                    [c-T_n, b, a]

      ?    - if...

     Ẹ     - ...condition: any?

  Ær       - ...then: roots of polynomial     i.e. roots of a²x+bx+(c-T_n)=0

    1      - ...else: literal 1

       %1  - modulo 1 (vectorises)            i.e. for each: keep any fractional part

           -                                       note: (a+bi)%1 yields nan which is truthy

         Ạ - all?                             i.e. all had fractional parts?

           -                                       note: all() yields 1

If we could yield non-distinct results then _/Ær1Ẹ?ḞƑƇ would also work for 10 (it yields 1 when all values are solutions, otherwise a list of the distinct solutions and hence always an empty list when no solutions - this would also meet the standard Truthy vs Falsey definition)

05AB1E, 35 bytes

Æ©²Āi²4P³n+tÐdi(‚³-IJ·Ä%P}뮳Āi³%]_

Port of @Arnauld's JavaScript answer, so make sure to upvote him!

Takes the input in the format $[t,c], a, b$.

Try it online

Explanation:

Æ                         # Reduce the (implicit) input-list by subtraction (`t-c`)

 ©                        # Store this value in the register (without popping)

  ²Āi                     # If the second input `a` is not 0:

     ²4P                  #  Calculate `(t-c)*a*4`

        ³n+               #  Add the third input `b` squared to it: `(t-c)*a*4+b*b`

           t              #  Take the square-root of that

                          #  (NOTE: 05AB1E and JS behave differently for square-roots of

                          #   negative integers; JS produces NaN, whereas 05AB1E leaves the

                          #   integer unchanged, which is why we have the `di...}` here)

            Ð             #  Triplicate this square

             di           #  If the square is non-negative (>= 0):

               (‚         #   Pair it with its negative

                 ³-       #   Subtract the third input `b` from each

                   Ä      #   Take the absolute value of both

                    ²·Ä%  #   Modulo the absolute value of `a` doubled

                          #   (NOTE: 05AB1E and JS behave differently for negative modulos,

                          #    which is why we have the two `Ä` here)

                        P #   Then multiply both by taking the product

              }           #  And close the inner if-statement

    ë                     # Else (`a` is 0):

     ®                    #  Push the `t-c` from the register

      ³Āi                 #  If the third input `b` is not 0:

         ³%               #   Take modulo `b`

    ]                     # Close both if-else statements

     _                    # And check if the result is 0

                          # (which is output implicitly)

Wolfram Language (Mathematica), 38 bytes

Solve[n^2#+n#2+#3==#4,n,Integers]!={}&

Try it online!

Jelly, 15 bytes

_3¦UÆr=Ḟ$;3ị=ɗẸ

Try it online!

Built-in helps here but doesn’t handle a=b=0 so this is handled specially.