What is the proper terminology for these basic concepts in computer science? We have a function $f:D\to \{0,1\}$ where $D$ is a finite set. We're asked to find any element $d \in D$ such that $f(d) = 1$. The function $f$ can be evaluated in polynomial time.
Alice decides to try every value of $d$ until she finds one that satisfies the equation.
Bob instead "works backwards", using specific knowledge of $f$ to yield an analytic solution to the equation.
E.g. $D = \{1,2\},\;\;f(d) \triangleq d-1$. Alice tries $d = 1$ then $d = 2$. Bob reasons that $f(d) = x\implies d = x + 1$ and computes $d = (1) + 1 = 2$.
Not coming from a computer science background, I would call $f$ an "indicator function", Alice's approach to be a "brute force solution", and Bob's approach to be an "analytic solution". I would describe the process of finding a solution as "solving a problem in $NP$".
I suspect there are more formal, specific terms for some or all of these ("indicator function", "brute force solution", "analytic solution"). Furthermore, I'm not certain whether the terminology "solving a problem in $NP$" is accurate here. In particular, $f$ is totally deterministic for any given input $d$, but I'm aware that in computer science, "nondeterministic" is used in the sense of "dependent on an exogenous input unknown a priori" and not in the usual sense of "stochastic".
When writing for an audience with a computer science background, what terms would be the most appropriate here?
 A: Calling something a "brute-force" algorithm (or "brute-force" approach) is a well established technical term in Computer Science and it defines exactly what you describe (try all possible solutions until we get the correct solution). Since we "search" a solution, we often use the term "exaustive search" here as well.
A main research subject in Computer Science is Complexity Theory which tries to assign problems to certain classes according how "hard" it is to compute the correct solution. We usually make a distinction between running time complexity (how long will it take for our algorithm to finish?) and space complexity (how much memory does the algorithm need to find the correct solution?). Most of the time we are interested in the "worst" complexity possible. Taking your provided example, then we might ask: What is the worst possible time Bob could need to find the element for which the provided function returns $1$? Assuming that calculating $f$ for any given value takes constant time, the solution is quite obvious: Bob needs to check each element in the worst case. Assuming that there are $n$ elements in the set $D$, the resulting worst time complexity would be $\mathcal{O}(n)$. The symbol used is defined in the Bachman-Landau-notations. It basically means that the upper bound for the running time complexity is asympotically linear in $n$.
The term "analytic" solution is not associated with Alice's approach in Computer Science at least as far as I am concerned. We usually do not make these distinctions. We are interested in different algorithms and how efficient they operate on given problem instances. Thus, Bob and Alice are using two different algorithms. One is performing better than the other in terms of running time complexity. Most of the time, the brute-force algorithm is the most obvious approach to any given problem, and there are many of them for which no better approach is known (or it is proven that no such algorithm exists). Depending on the problem you are trying to solve, we often call the brute-force algorithm "trivial" or the "trivial approach" but we often start with it. In that sense calling Alice's approach "analytic" or "more sophisticated" wouldn't be a problem when speaking informally.
How you call the function $f$ is completely up to you. In your scenario "indicator function" is a well known term. Though, we often speak of "problem instances" to be a little bit more abstract. Given any instance of type $X$, what is the worst running time complexity of algorithm $ALG$? We do this, because the function $f$ could be just a representative of a larger class of similar problems to which our algorithm might be adapted.
Now, I have mentioned the term "complexity classes" above without given a precise idea on what I mean. We call the class of problems solvable by a polyonmial time algorithm $\mathcal{P}$. Given a problem $X$. If there exists an algorithm $A$ which solves all instances of $X$ in $\mathcal{O}(f(n))$ whereby the function $f$ is some polyonmial, then $X$ is in $\mathcal{P}$. The class $\mathcal{P}$ is particularlly important since it contains all problems which are computationally feasible even for large $n$.
The class $\mathcal{NP}$ is different. Let us assume that we have a problem $Y$ which is not in $\mathcal{P}$ and therefore not solvable in a reasonable amount of time. But let us assume that someone provides us with a solution. If we can check the provided solution in polynomial time, then $Y$ is in $\mathcal{NP}$. To be even more technical here, we introduce a new type of problems which are formulated as questions and whose answers are either "yes" or "no". These type of problems are called "decision problems" and are very important in Computer Science. In that sense, a problem is in $\mathcal{NP}$ if any instance of the problem whose answer is "yes", there is a way of verifying this fact in polynomial time.
It is quite obvious that $\mathcal{P} \subseteq \mathcal{NP}$, because if someone would provide us with a solution of a problem which is in $\mathcal{P}$, then how could we validate it in polynomial time? Well, we could compute it ourselves using the algorithm which has been used in the first place.
I usually like to provide "Soduko" as an example. Solving larger Soduko grids is a hard problem as you might have noticed yourself. But if I provide you with a solution, then how hard is it to verify it?
Saying that we "solve a problem in $\mathcal{NP}$" sounds a bit odd because it sounds a little bit like the algorithms runs in $\mathcal{NP}$ which is not correct. The problem is in $\mathcal{NP}$ and thus we can check a provided solution in polynomial time using some algorithm. But you might want to express something different. Classifying a problem as an $\mathcal{NP}$ problem is usually easy and this doesn't mean that there is no algorithm out there which runs in polynomial time. What is more interesting is the following question: Are all problems in $\mathcal{NP}$ also in $\mathcal{P}$? If the answer is "yes", then the class $\mathcal{NP}$ would instantly collapse. If the answer is "no", then there are problems for which it is easier to check a solution than to compute it. This problem is called the P vs. NP-Problem and is one of the seven Millennimum Prize Problems and is still unsolved.
I have given you a very brief and informal overview over the topics you have mentioned in your question and I hope this helps you a little bit with the terminology.
