Good news: it works, despite the editor showing a syntax error (my version of Mathematica may not like multiple squiggly brackets in a With statement. The interpreter runs it fine. Bad news: totally impractical for actual problems that involve much bigger matrices. I tried it with an 81x81 first matrix, a 27x27 second matrix, and a 3x3 third matrix. It was not done after 4 hours on my mac air laptop.

It's the same problem as another kind person (forgot his name, but in this thread) tried unsuccessfully to solve by making the arguments to the function passed to NMinimize be forced to be numeric. I've done some tests, and the root problem is that the symbolic functions can run much faster when passed to NMinimize (does it form an approximation to the function which it keeps testing against the function? Just curious), but the functions in conjunction with NMinimize can't handle internal conditionals (if statements and such) that test numeric values for the matrix elements. Other conditionals, that have to do with array dimensions for example, are fine. I would call it a bug. You will probably deny it ad infinitum, and I won't keep fighting you about it, if you won't admit it.

I include your suggestions in a file, with a much smaller problem than what I really need, with a Timing statement to show how impractical it is. Thanks for trying.

I emphasize that the error is mathematical. It is not a programming error, nor a question of numerical method. If the function should theoretically be bounded, then I suggest there's an error in its code somewhere. The code defines totaladj[args] to be a linear function, which clearly is unbounded.

OTOH, if you just want it to try see what happens when NMinimize[] runs an numerical algorithm on your function, clear totaladj and use NumericQ with MatrixQ in its definition:

totaladj[{ms___?(MatrixQ[#,NumericQ]&)}]:= …

You should get the following (mathematical!) error, which numerically confirms the error NMinimize detected when NMinimize[] evaluated totaladj[args] with symbolic arguments:

NMinimize::cvdiv: Failed to converge to a solution. The function may be unbounded.

I'm going to try Method->"DifferentialEvolution" or "NelderMead", to see if it speeds things up. Gradient methods will not work here.

Okay. Write out for me the single NMinimize expression that you want to generate. Just pretend that all of your code that preceded the NMinimize worked and show me what you're trying to minimize. Do it by hand. Just forget about totaladj. Just show me the goal. Feel free to explain the semantics of whatever you come up with, or even relate it back to your original code, but do all of that as exposition, not code. The only code I want to see is a complete and valid NMinimize expression that you want to eventually be able to generate from your data and definitions.

Okay, I think I finally understand. So, NMinimize expects an expression that represents a function to be minimized. So you need that first argument to look like a function. Using things like Count will just perform the function, but we need an expression for the function. I'm not sure the best way to do this, but one way would be with UnitStep. So, for a 2x2 matrix and using m as our formal symbol, we want something like this:

NMinimize[
  {UnitStep[-1/4 + m[1, 1]] + UnitStep[-1/4 + m[1, 2]] + UnitStep[-1/4 + m[2, 1]] + UnitStep[-1/4 + m[2, 2]], 
    {-1 <= m[1, 1] <= 1, -1 <= m[1, 2] <= 1, -1 <= m[2, 1] <= 1, -1 <= m[2, 2] <= 1}}, 
  {m[1, 1], m[1, 2], m[2, 1], m[2, 2]}]

which evaluates to

{0., {m[1, 1] -> -0.782122, m[1, 2] -> -0.00737865, m[2, 1] -> -0.0810299, m[2, 2] -> -0.624118}}

We need a way to create this data programmatically, so here's one way. I assume you still want to create each matrix separately.

countLargeFn[matrix_?MatrixQ, thresholdFn_] :=
 With[
  {elems = Flatten[matrix], threshold = thresholdFn[matrix]},
  {vars = Select[elems, Not@*NumericQ]},
  {Total[UnitStep[elems - threshold]], -1 <= # <= 1 & /@ vars, vars}]

Use it this way:

countLargeFn[Array[m, {2, 2}], 1/Times @@ Dimensions[#] &]

which produces:

{UnitStep[-1/4 + m[1, 1]] + UnitStep[-1/4 + m[1, 2]] + UnitStep[-1/4 + m[2, 1]] + UnitStep[-1/4 + m[2, 2]], 
  {-1 <= m[1, 1] <= 1, -1 <= m[1, 2] <= 1, -1 <= m[2, 1] <= 1, -1 <= m[2, 2] <= 1}, 
  {m[1, 1], m[1, 2], m[2, 1], m[2, 2]}}

You'd then need to apply this to several symbolic matrices and then aggregate the bits together. All of the unit step expressions and the constraints go in the first argument to NMinimize and then all the variables go into the second argument.

Unfortunately, I must leave the house now and won't look at this again until I get back. I threw that together quickly, and I know it doesn't finish the job for you in its current form. If you can't figure it out, just ask more questions and I'll be back on line in 8 hours or so.

1. It would be helpful if you could specify what's red or what the error you're seeing is. But if you can't run the code, then that's a bummer.
2. Yes, I understand. You're getting ahead of yourself. There are some things about how Mathematica works that you seem confused about. Trust me, we can figure out how to restructure things as needed. This is a huge strength of Mathematica. But we need to get something working first. I'm doing it this way for a reason, but I didn't have time to explain it all earlier.
3. No, that's not correct. First NMinimize actually does expect the constraints to be included with the function in the first argument. But really, we don't need to worry about that now. Trust me, we can always structure our data as needed once we get to that point.
4. I've only glanced at Michael's solution, and that's not enough for me to understand it, but that leads to some caveats...

I just may have no idea what you're trying to do. I thought I figured it out, but if adding a numeric constraint to totaladj works, then I somehow just missing the entire point of your question. If you pass a numeric matrix to totaladj, then what NMinimize gets won't be a functional expression. It'll be a number, and that just doesn't make sense for NMinimize.

Also, you've said repeatedly something along the lines of "NMinimum passes arguments to totaladj". That's not at all what's happening. I had been trying to nail down the other issues before bringing this up, but since you keep repeating it, and since I keep failing to solve your problem, I think maybe it's time to switch to this. NMinimize is not passing any arguments to totaladj. It just isn't. That's not how WL code works. NMinimize isn't aware of totaladj at all. I don't me the system function, because obviously a system function knows nothing about your custom function. I mean in the expression you are trying to evaluate, NMinimize[...], the stuff that gets actually passed to NMinimize has no knowledge of totaladj, no remnants of totaladj remain when we finally get to NMinimize doing its thing. So, maybe this here is the crux of the issue. Either you are wanting totaladj to do something completely different than what it looks like right now, or you are not understanding how the arguments to NMinimize should look, or I just have absolutely no idea what anything you've said even means.

So, anyway, I'm back online and will try one more time to look through this, but in the meantime, I'm begging you to show me a full NMinimize expression that works for you. Get rid of totaladj, get rid of all of your setup code, and just show me what the `NMinimize should look like if you just wrote it "by hand" without any attempt to write re-usable helper code. I'm begging you to just show me the form of the thing you actually want to minimize.

I think that given your definitions

NMinimize[totaladj[{Adj, Adjfam}], vars]

is a correct form for NMinimize. As you say, in the specific case you provide, the there is no bounded solution.

Still not working. NMinimize doesn't send numeric variables to MatrixBenefit and MatrixCost. I added a Print[m[[1,1]]] line to demonstrate this.

Attachments:

argsexample3.nb

I am trying to do a constrained minimization of a utility function where the variables are matrix elements for different matrices. The utility function I have is more complicated than in the example, but even in the simple example, the matrix elements passed to MatrixCost and MatrixBenefit need to be numerical for those functions to do the right thing (the greater than threshold condition is never satisfied, if the matrix elements are symbolic, for example). For some reason they aren't, as demonstrated by m[[1,1]] being symbolic when printed.

Do you want to know the. big picture of what this minimization is about? I can't see why that is relevant, but I can tell you if you're interested.

See attached even simpler example, where I sent totaladj a list of just 1 2x2 matrix, instead of several matrices. The minimum would occur if all matrix elements were less than 1/4. They are instead set to one by the minimization, the value of totaladj should be 4 (not 0 for those values, as returned by NMinimize), and the print statement prints a symbol instead of a number. See it do the right thing for both the call to MtarixCost and totaladj.

I have to pass the NMimimize a symbolic list of variables, don't I? But it doesn't pass totaladj a numeric list, for some reason.

this is a duplicate reply, because the first time it just quoted Eric's reply. Yes, so how do I pass totaladj a list of numerical matrices instead of symbolic ones? I have to go through NMinimize, because that is what I am trying to do (I'll say it again: Minimize a function of many matrix elements, subject to some constraints, it's really not complicated, I don't know how to make it simpler for you). Why is NMinimize not passing totaladj numbers? I don't know! You would think the N in NMinimize means it would do a numerical minimization instead of an algebraic one.

So How can I tell NMinimize to pass numbers to totaladj?

I used one of the later notebooks you posted, and there are no bounds in it. I did not look at the others, because I thought it would be the representation of your problem that you are currently working on. Sometimes the site does not load all the answers in page (as you've noticed). Perhaps your latest was missing and I used an out-of-date notebook. But I used YOUR NOTEBOOK, and it has NO CONSTRAINTS. Further you can see on this site's page that the error is the following:

NMinimize::ubnd: The problem is unbounded.

Here's your notebook with a couple of things added by me:

I'm mainly focusing on the code. I don't have time to really get into the problem itself. One recurring issue I see is how to tell NMinimize[] the constraints. They should be part of argument 1. The argument should have the form of a list, {objectiveFunction, constraints}. The other principal issue in the one you asked about, which Eric has helped with, namely, how to structure the pattern for the ms argument of totalAdj[]. I showed one way in my previous notebook. Below is another. I chose another way because I thought, since you mentioned MatrixBenefit, I should use a notebook in which it is defined and used. In that notebook, totalAdj[] is called with two arguments instead of just one; consequently, I changed the pattern to match the call. Either way can be used and are similarly efficient. Pick whichever way expresses your ideas best.

I don't understand the NMinimize at the end, because you're not passing arguments of the right shape for that. But I've made my best guess at what totaladj is supposed to do, and I'd recommend something like the following.

First, break the problem into smaller pieces. You eventually want to work and a bunch of matrices at once, but solve the problem for a single matrix first.

MatrixCost[m_?MatrixQ] :=
 With[
  {threshold = 0.1*Times @@ Dimensions[m]},
  Count[Map[GreaterThan[threshold], m, {2}], True, {2}]]

I saw "cost" in your code, so I thought maybe that would be a good name. We can test this:

SeedRandom[25];
testA = RandomReal[{0, 4}, {3, 4}]
(* {{0.0395876, 0.93185, 0.802464, 0.737812}, 
    {1.11064, 0.253445, 2.87187, 3.85676}, 
    {0.764152, 2.42748, 0.915865, 3.21226}} *)

MatrixCost[testA]
(* 4 *)

testB = RandomReal[{0, 4}, {2, 2}]
(* {{0.0495114, 2.80439}, {3.05848, 1.00112}} *)

MatrixCost[testB]
(* 3 *)

Now let's use this for a function that works with several matrices.

MatricesCost[ms___?MatrixQ] := Total[MatrixCost /@ {ms}];

MatricesCost[]
(* 0 *)

MatricesCost[testA]
(* 4 *)

MatricesCost[testA, testB]
(* 7 *)

MatricesCost[testA, testB, testA]
(* 11 *)