Best How To :

This isn't really an answer (EDIT: Maybe it is now?), but it's a necessary response, and it won't fit into a comment. I have other questions in comments.

I'm still not sure whether I've answered your question in comments. I think there are a few things that need to be done first to clarify what your code is supposed to do. First, I've edited the code in your question to format it in order make it clearer (while trying to preserve your style as much as possible). Second, I added closing brackets on the line after ask bigs and after ask smalls. Most importantly, I think that it would help if you could provide a Minimal Working Example (MWE)--the smallest, simplest version of your program that still contains code that (a) runs, and (b) illustrates the problem you're trying to solve. It takes some work to construct an MWE, because you have to figure out what you can take out (because leaving it in will just confuse readers), and what you have to leave in, because it's essential to creating the problem. (However, sometimes you'll figure out the answer to your question on your own when you try to create an MWE.)

For example, here is an MWE, in the sense that it runs, but you'll have to change it to illustrate your problem.

breed [bigs big]
breed [smalls small]
bigs-own [probability]
smalls-own [probability]
globals [Prob_bigs_bigs_breaking Prob_smalls_smalls_breaking]

to setup
  reset-ticks
  ask n-of 20 patches [sprout-bigs 1 []]
  ask n-of 20 patches [sprout-smalls 1 []]
end

to go  
  ask turtles with [count turtles-on neighbors4 < 4 ][  
     ;; so only turtles will a space in the neighbours 4 can move
     move-turtle
  ]
  tick
end

to-report Probability_Product

  ask bigs with [count turtles-on neighbors4 < 4 ] [ 
    ;; self is each big in turn
    ask bigs-on neighbors4 [set probability Prob_bigs_bigs_breaking] 
  ]

  ask smalls with [count turtles-on neighbors4 < 4 ][
    ;; self is each small, in turn  
    ask smalls-on neighbors4 [set probability Prob_smalls_smalls_breaking]
  ]

  ;; Here self is the turtle that called move-turtle, which called Probability_Product.
  if any? turtles with [count turtles-on neighbors4 < 4 ][
    let prob-list ( sentence ([probability] of turtles-on neighbors4))
    if prob-list != [] 
      [ report reduce  * prob-list ] ;; multiplies all the probabilities together
  ]

  report 0
end

to move-turtle
  if random 1001 <= Probability_Product * 1000 [
    ;.....
  ]
end

Next, I suggest that the ask bigs and ask smalls lines should be done in a separate procedure from the function containing if any? .... Putting this all in one procedure is confusing, because in the ask blocks in Probability_Product, we refer to turtles defined by those asks, but in the if any?, we refer to the turtle defined by the ask two procedures "above", i.e. defined by the ask in go, which then calls move-turtle, which then calls Probability_Product. When we get to the if any?, it was hard to figure out what turtle neighbors4 was relative, because it's defined two procedures above, and because Probability_Product also refers to all bigs and all smalls.

In addition to being confusing, I'm not sure that Probability_Product is doing what you want. For each turtle, this procedure goes and asks all bigs and all smalls to do something. So, if the bigs and smalls are the only turtles, Probability_Product asks all turtles to do something, and then for the next turtle, again asks all turtles to do the same thing, and so on.

EDIT:

It seems to me that what Probability_Product is supposed to do in the MWE can be done more simply with the following function. Maybe I'm misinterpreting your intention, and it may be that in the full program there is more that needs to be done, since the function below doesn't set or use the probability variables at all. Even if this isn't what you want, perhaps this example will help you think through what you need to do.

to-report new-Probability_Product
  let neighbor-count count turtles-on neighbors4
  let big-neighbor-count count bigs-on neighbors4
  let small-neighbor-count count smalls-on neighbors4

  if-else neighbor-count < 4 and neighbor-count > 0
    [ if-else is-big? self  ; self is turtle from ask in go procedure
        [ report (Prob_big_big_breaking ^ big-neighbor-count) *    ; if self is a big
                 (Prob_small_big_breaking ^ small-neighbor-count) ]
        [ report (Prob_small_big_breaking ^ big-neighbor-count) *  ; if self is a small
                 (Prob_small_small_breaking ^ small-neighbor-count) ] ]
    [ report 1]
end

The idea behind this function is that the only thing that the probability variable is doing in Probability_Product is holding the values set in the sliders. Then those values are multiplied. But we can just multiply those values directly.

(A number of my other comments still seem applicable.)