There is a fallacy that if program X requires nonfree software, then program X is nonfree. (I discuss software that is free as in user’s freedom, not software with external costs. X is a placeholder variable, not the name of a concrete program, while there are relevant issues in X graphics drivers that interpret nonfree code from VGA ROMs and communicate with nonfree firmware loaded by their kernel modules.)
As Richard Stallman explained in his Free but Shackled essay, software being free and software being usable in fully free systems are different issues. His argument is that it can be determined if a program in isolation respects its user’s freedom (an assumption that I don’t believe to apply in unusual cases), while knowing if a program is shackled requires checking its changing set of dependencies and their dependencies (some of which are optional, some aren’t). He calls these programs free, so we have proven that they are free by an argument from authority.
Let’s choose a more amusing way of proving that a program requiring nonfree software can be free. A program is just a sequence of bits (while it’s not obvious if every finite sequence of bits is a program for our purposes). There are no intrinsic dependencies between bit sequences, so we need to reword our proposition in other terms, like uses of software. This leads to the following statement: if use Y of program X requires nonfree software, then program X is nonfree.
This new statement is logically unclear, since it doesn’t specify what quantifier we use for Y: do all possible uses of program X need to require nonfree software, or is one use sufficient for X to be nonfree?
What would for all uses Y of program X, program X requires nonfree software imply here? We introduce the emulation argument: for any program X, X can be used without running it with other software or hardware that it interacts with. (Maybe you don’t consider e.g. symbolic interpretation of a program useful, but there might be a user who does; free software is about uses that a user might consider useful, not only what the author or someone else considers useful.) This makes the left side of our implication false: every program can be used without separate nonfree software.
So our statement should be formalized as if there is a use Y of program X such that Y requires nonfree software, then program X is nonfree. But this leads to a much worse conclusion: since for every program there is a use that requires nonfree software, it would mean that every program is nonfree. The symbolic interpretation from the emulation argument can be done via a nonfree software, making it a use that requires a nonfree program (while it’s a different use than symbolic interpretation via a different program that is free). This contradicts the obvious fact that there are free programs. (The program fix f = f (fix f) is obviously free, while it’s too simple and unoriginal to be copyrighted. It serves an important theoretical purpose and has a very elegant implementation in lazy functional languages.)
In conclusion, we need to discuss freedom of a program without involving the freedom of its dependencies. There are other terms and definitions for important and insufficient criteria for whole system freedom (like for operating system distributions or for devices running free software).