{'fraction_non_alphanumeric': 0.04273237679351216, 'fraction_numerical': 0.004951653150343106, 'mean_word_length': 4.231286967162961, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Uncertainty of value and structure

In this paper we argue that ‘uncertainty of information’ traditionally focuses more on ‘uncertainty’ leaving ‘information’ mostly as unravelled. We also aim to explain why that is so, and we then provide suggestions on how to overcome the situation, as related to applications involving information structures.


Fuzzy then, now and in the future
Since early days of fuzzy systems, two branches separated and thereafter basically never communicated. One, the larger one, started from fuzzy sets α : X → [0, 1] remaining over the unit interval of uncertainty values, and the other, the smaller one, started from α : X → L over a lattice structure mostly seen as embracing truth values. In the unit interval, arithmetic and analysis is used, and applications involve engineering. With lattices, lattice operations were seen as logical operations, so that theoretical subtleties were enabled by imposing various structures on that lattice.
These two branches basically never seriously communicated. Those comfortable with analysis on the unit interval were mostly never seeking additional value from the side of algebra. Some theory development on this side emerged quickly within rather trivial generalizations in topology. Those being more fond of algebra and logic, became more and more theoretical, almost as developing antipathy against applications, and at the same time criticizing the simplicity of the unit interval.
Today, these two branches still basically do not collaborate. They almost contra-laborate.
What they both do not see clearly, is how they both hide information. They both involve that X, but they care less about the structure of it.
Those supporting the unit interval, and the calculus in it, usually also knew methods like neural networks quite well. Neural networks is basically about weighted sums, with quite simple mathematics. Fuzzy control based on the 'compositional rule of inference', a fancy name for relational composition, was a big success story within the fuzzy community, and it was all about the unit interval. As far as elements x in X where concerned, there was nothing behind x, except the value itself, and the interesting thing from fuzzy point of view was its uncertainty value α(x) in the unit interval. "Tall(John) = 0.7" was fascinatingly simple, and very appealing, but serious and real world application development based on such simple notation soon turned out not to be all that simple.
The fuzzy community created the hype that complicated problems could all be solved by simple solutions.
The algebraic and logical side is mostly introvert. It often starts out saying α is an element in L X , and then L X as a lattice structure does not have more structure compared to L. Ignoring X and its content was easy and natural, since 'pointless' was appealing. This way of hiding information among algebraists probably stems from refusing to recognize the practical difference between points and sets, since algebra is more comfortable dealing with sets and powersets. A set A as a subset of X means A is an element of the powerset PX, A ∈ PX. Now, an algebraist quickly says e.g. that PX is a boolean algebra, and, of course, it is. There is algebraic structure on PX. Denote it as B, and A pointlessly as x, so that x ∈ B is the new player in the algebraic structure. This hides information, and disables it forever from becoming unravelled. What an algebraist basically says is that α : X → [0, 1] is not only all too simple mathematics, and the least we should do is to deal with α : X → L, where the algebraic structure is as algebraically appealing as possible. Once this has been done, the jump from L X to L, ignoring X, is just a natural step to take, and in fact a "pointless necessity", and thereby universal algebra also falls outside the scope of algebra.
Note how the powerset functor can be quite devastating in hiding information. The "trick" to recover points in powersets is easy. A point x is simply identified with its singleton set {x}, and thereafter algebra over the powerset proceeds as if points actually exist. Someone may say we can actually do things like {2} + {3} = {2 + 3}, but everyone in the fuzzy community knows how things evolve in very different ways if we generalize from that. Also, if x has a property in A, given f : X → A, we cannot say that {x} has a property that can be identified with the property of x. Indeed, even if we have the extension mapping Pf : PX → PA, and we have Pf ({x}) ∈ PA maybe as the {f (x)}, we are no longer in shallow waters if we would start to speak about singleton attributes.
On powersets we also come to relations between points, like a ρ ⊆ X × X. This also, in its initial setting, invites to start by ignoring information that x ∈ X represents, and having x 1 ρx 2 as the informative part. With ρ assuming to have properties, this then turns to analyzing what we can do given those properties. An equivalence relation identifies points in respective equivalence classes so that it is natural to go up one level and identifies equivalence classes as new points to work with in an application setting. Clearly, attributes residing in points do not easily and naturally carry over to their equivalence classes, unless in very trivial cases. Viewing such a relation ρ in its equivalent form as a mapping f ρ : X → PX, invites to different types of generalizations and unravelling as compared to viewing ρ as ρ ⊆ X × X. For instance, in the case of fuzzy relations as σ : X × X → [0, 1], or something L instead of [0, 1], they are similarly and equivalently describable as f σ : X → LX. This paper warmly recommends and invites to more and broad collaboration, in particular on application development, between these the two branches. The generalized recommendation is not necessarily to compare the analysis preference to the algebraic one, and certainly not to see them as competing. Indeed, this paper warmly recommends to look deeper into X, and even deeper into x, rather than continuing to ignore, as both sides do, the content and context of X and x, and, even worse, to blur the distinction between X and PX. Unravelling, i.e., making X into something more elaborate will invite to making P if in some applications we prefer or need to work with structured sets and populations rather than just points and individuals or individual items.

Sets and points
We can use a number of examples and practical situations to work with. We could choose from the public or private sectors, including industrial production, marketing, health care, education, and so on. Later in this section we select just one such example, and by no means since it is more typical than any other choice, but simply because it supports our presentation, and may also be quite familiar to many readers. The example is also related to our particular application developments in some presently ongoing projects whose funding we gratefully acknowledge, and builds upon some of some previous work, e.g., in [8,7].
For an x ∈ X, and in an application, we are often tempted to say that such an x may represent more than it denotes. If we do so without adding any structure to x, even if we change notation to x T hisAndT hat , it is still just a point, and X is now just the set of all those representing This and That.
It's common to try to overcome such oversimplifications by adding attributes using mappings like f : We then have the pair (f, x), as more like a syntactic expression, which explicitly gives us three different things. There is f , the operator. We have x, the operand. And we have (f, x), the syntactic expression for the result of the operation. We mostly prefer to write f (x) instead of (f, x), like 2 + 3 or +(2, 3) instead of (+, 2, 3), but then we overemphasize the result of the operation, and we turn intuition quickly to the semantic value of that operation and its result.
This increases the risk of hiding information, and this makes the distinction between syntactic expression and semantic value less apparent. In fact, it invites to viewing them as one and the same thing. Thereby information structure is lost in the translation of syntactic operation to its semantic value.
We now have (f, x), or f (x) if we wish, as an expression that contains f and x and from which we can 'compute' the value f (x) of the operation. If we then decide to denote f (x) with a, i.e., we provide a semantic interpretation where we assign according to a = f (x), and continue to work with a in A, forgetting where a comes from, then we obviously hide both x and f . If we look closer at the example 2 + 3, or +(2, 3), we are invited to say it's 5, but if we work with 5 only in a subsequent expression 5 + 7, we decline to recognize that this particular 5 comes from 2 + 3, which combines 2 and 3 using +. Note already at this point that if 2 + 3 is only 'approximately 5', it may not be so only because either or both of 2 and 3 are approximations, but + could also be 'approximately +', i.e., the operation itself is uncertain. So, the expression 2 + 3 is fully informative. It even includes 5, since we can compute 5 from 2 + 3, but if we only see 5 and forget where it comes from, and later wonder where it actually came from. We can then only guess, and say it could have come 1 + 4, 5 + 0, and so on, but we cannot be sure it came from 2 + 3 unless we say something explicit like '5, as the result of 2 + 3'.
At this point it is now convenient to speak of the distinction between syntax and semantics. The attribution function f : X → A is logically a semantic description of some operator ω : s 1 → s 2 , if we look at this situation from a universal algebra point of view. We may have a syntactic expression t of type s 1 , so that ω(t) forms another expression, of type s 2 . The syntactic ω may then connect with the semantic f , where s 1 assigns to X and s 2 assigns to A. Here we could say that s 1 represents the type of points under consideration, whereas s 2 represents a type of attributes, semantically explained by elements in A. If t assigns to an x so that ω(t) assigns to f (x), we see how ω(t) remains in its expression form without necessarily evaluating it, so that ω(t) is fully informative and not hiding anything. This is now within the realm of terms over a signature Σ = (S, Ω), where S is the structure of sorts, or types, and Ω is the structure of operators. The set of all possible expressions is then initially enriched to a set of terms T Ω X, where X is a set of variables, and T Ω is a term functor over some monoidal closed category. As a concrete example of an expression, an element actuator as a point in a set without structure is symbolically meaningless, whereas actuator(ω(x 1 ), . . . , ω(x n )), as a term, builds upon actuator and ω as an operator, with x 1 , . . . , x n as variables. Similarly, a temperature control could be a term EAT C(g(y, z)). A many-valued interaction between the actuator and the temperature control is given as ρ(actuator(f (x 1 ), . . . , f (x n )), EAT C(g(y, z))), where ρ : T Ω X × T Ω X → {no, weak, strong} is a threevalued relation over T Ω X. This unravels hidden information as compared to modelling using only names of elements in X. This notation is based on category theory, where T Ω : Set → Set is a term functor [3] that can be extended to a monad. The monad properties allow substitutions of expressions within a term to be composable, so that the substitutions x := g(y, z) and z := 22 as composed and applied to EAT C(x) leads to the term EAT C (g(y, 22)). This is obvious when we use relations over T Ω X. When we need structured sets of terms, we need monad compositions [3].
In Section 3 we present detail on the formal term functor construction, and also how uncertainty can be attached to expressions given that also operators are attached with values of uncertainty. There also clarifies the important distinction between 'fuzzy logic' and 'logic of fuzzy'.

The term functor
In order to make this paper a bit more self-contained, in the following we briefly and in a general overview fashion describe the construction of terms over and underlying signature. For more detail, and for the purely categorical constructions of the corresponding term monads, the reader is referred to [3].
The many-sorted term monad T Σ over Set S , the many-sorted category of sets and functions, where Σ = (S, Ω) is a signature, can briefly be described as follows. For a type s ∈ S, we have type specific functors T Σ,s : Set S → Set, so that The important recursive step in the term construction is and then with we finally arrive at the term functor Note here how our (f, x) in Section 2 is in the form of a pair, where f is in Ω s1×···×sm→s ) Set S and x is in arg s1×···×sm .
The term functor construction can be extended so that T Σ : C → C operates more generally over monoidal biclosed categories C. If C is Set, we have the construction above, and with the Goguen category Set(Q), where Q is a quantale, we have a multivalent and typed situation enabled by the signature acting over the selected underlying category. The algebraic foundations of many-valuedness, including techniques related to the use of quantales and other algebraic structures, is found in [5].
We now have more interesting fuzzy sets α : T Σ X → Q as objects of Set(Q), where t ∈ T Σ X potentially carries lots of information, as compared to having only α : X → Q, where x ∈ X without further attachments to x is basically just a variable that can carry unexplained data. In the case of the term actuator(ω(x 1 ), . . . , ω(x n )), and with T Σ over Set(Q), actuator and ω become annotated with uncertainty values in Q. Similarly, in the case of the expression 2 + 3, the uncertainty of 2 and 3 are both qualified by values in Q, and so is the operation +.
Monad compositions further enable to arrive at generalized sets of terms, where the typical example is composing the term functor T Σ with the powerset functor P in order to obtain the monad P • T Σ . More elaborate generalized set functors Φ can be applied in order to make use of the composition Φ • T Σ .
Here we can formally explain the danger of pursuing the 'singleton attributes' possibility, discussed in Section reflookingmoredeeply. The monad multiplication reduces from PTPT to PT, which requires a certain swapper from TP to PT so that we get a jump from PTPT to PPTT. From there we have the respective multiplications from PP to P, as a 'flattening', and from TT to T, as an idempotency, which reduces PPTT to PT. The key to this is indeed that swapper. It is a generalized distributive law. However, we do not have a swapper from PT to TP, and thereby we cannot establish TP as a monad. This we can have ω({t 1 , t 2 }) reducing to {ω(t 1 ), ω(t 2 )}, but we cannot have {ω 1 (t), ω 2 (t)}) reducing to something like {ω 1 , ω 2 }(t), which makes less sense, since we do not have anything enabling us to go from (S, Ω) to (S, PΩ). Similarly, we do not have anything like (PS, Ω). However, we do have 'powertypes', as an example of a type constructor, as shown in Section 4.
Here we also see more clearly what it means to hide information by focusing only on the algebra structure L X , ignoring the information residing in X and its elements. Looking at T Σ X and focusing only on the algebraic properties of L TΣX effectively ignores and hides everything enabled by the information structure enabled by Σ and residing in T Σ X. This is a strong message conveyed in this paper.

The three-level signature
In the three-level arrangement of signatures [6], the middle level enables to use various kind of type constructors, where the first and third level clearly distinguishes terms from λ-terms.
Section 3 presents a functorial term construction. The three-level signature enables to provide a functorial λterm construction. The conventional non-functiorial (in fact, natural language based language based) definition of λ-terms is informal and non-constructive, as it creates undesired terms and demands renaming.
Church's view about λ was that it is just an informal symbol [1]. The three-level signature shows clearly that λ is not to be seen as a general abstractor, but rather so that any operator possesses its own capacity to abstract itself. In any expression λx.f , λ is unique to f , and should be clearly viewed as "f owns its λ".
In λ-calculus, the main type constructor is the one producing function types. In traditional views of λterms, this function type is given from the 'outside', i.e., it is not seen as part of any underlying signature.
In order to see this more precisely, let s 1 and s 2 be two types in S. The function type involving s 1 and s 2 can be denoted s 1 s 2 . Even if we want to view s 1 s 2 as a (constructed) type, it is not part of S. This creates an awkward meta-level of constructors, and the formalism for treating these constructors is rather lose, or even non-existing. Thus, the traditional so called 'set' of λ-terms is not well-defined, even if it is 'well understood'.
The three-level arrangement of signatures starts from the basic signature Σ on level one, targeting a resulting Σ on level three, using type constructors on level two. On level two we have the (Σ-)superseding type signature as a one-sorted (one type only) signature If Q does not contain any other type constructors, apart from those given by (i) and (ii), we say that S Σ is a (Σ-)superseding simple type signature. Then T SΣ X, where X is the tuple of objects representing (type) variables, contains all terms which we call type terms. We may write s t for the type term (s, t).
The signature Σ = (S , Ω ) on level three then is based on S = T SΣ ∅, i.e., the types on level three are those from level one together with the constructed types, on level two appearing as terms (the type terms), added to those basic types coming from level one.
Church's type constructor is in effect our , so that (β α) is Church's (βα). An interpretation of Church's ι corresponds to our type and for Church's o there is no corresponding structure.
In summary, the three signature levels underlying the production of λ-terms are then following. Here (i 1 , . . . , i n ) is a permutation of (1, . . . , n). Note also that level one operators are always transformed to constants on level three. In traditional notation in λ-calculus, substituting x by succ(y) in λy.succ(x) requires a renaming of the bound variable y, e.g., λz.succ(succ(y)).
In our approach we avoid the need for renaming. On level one, and in the case of NAT, we have the substitution (Kleisli morphism) σ nat : X nat → T NAT,nat (X t ) t∈{nat} , where σ nat (x) = succ(y), x being a variable on level one, and the extension of σ nat is µ Xnat • T NAT,nat (σ t ) t∈{nat} : On level three we have σ nat : X nat → T NAT ,nat (X t ) t∈S , with σ nat (x) = app nat ,nat (λ succ 1 , x), x being a variable on level three, and requiring no renaming in µ nat • T NAT ,nat σ nat (app nat ,nat (λ succ 1 , x)).
On β-reduction we obviously have the following transition from the traditional form to using the three-level signature. Let [x := t] be a substitution, i.e., we have some σ(x) = t, and choose a ω : s 1 × s 2 → s. Then β-reduction λx.λy.ω(x, y) t These construction over the Goguen category, a monoidal closed category, defines a truly fuzzy λcalculus. The λ-term monad may also be considered to be over other monoidal biclosed categories [3].
Various 'syntactic set functors' can be further introduced, including the 'powerset' type constructor P : type → type on level two, intuitively thinking that the 'algebra' of P is the powerset functor, with the underlying monoidal closed category being the category of sets and functions.
The operator ω : s → Pt can be seen as the underlying syntactic support for enabling typed generalized relations.
In the case of description logic, we can transform it into our categorical framework [2]. This provides a truly fuzzy description logic, which in fact becomes a fuzzy λ-calculus.
Formal concept analysis has also been shown to enable the use of the powertype [4].

Conclusions with respect to applications
'Application' is a very broad concept, in particular in real world applications. Our general view on theory for real world applications is that simple solutions for simple problems is less interesting, as it mostly involves shallow scientific methodology.
Simple problems are many, and simple solutions mostly suffice. A simple problem that requires a complicated solution is only apparently simple, but in reality complicated. Complicated problems require complicated solutions. In some cases, a complicated problem may have a simple solution, but in that case the problem was apparently not that complicated. So we have simple problems with simple solutions and complicated problems with complicated solutions. Our focus is on the latter.
The challenge in understanding applications and their underlying problems is understanding the problem domain. Theoreticians usually do not spend sufficient amount of time to understand a problem before trying to solve it. This leads only to simplifying and fitting the problem to an existing theoretical solutions. Such an approach is seldom successful. Successful application development seeks a solution to a problem. We should not first fix the solution, and then seek to fit the problem to the solution. This, in general, dilutes the application to unreal.
Simplifying may be advisable. We may have an information structure where we roll up into lesser detail or at a certain step being content with a helicopter view of the problem. But the underlying information must not be forgotten or ignored, and certainly not hidden so that it can never be recovered. In actuator(ω 1 (t 1 ), . . . , ω n (t n )), with further specific information residing in expressions t 1 , . . . , t n , we may at some point of application development only need to work with aggregated information related with actuator, but later on need to deal specifically with all ω 1 (t 1 ), . . . , ω n (t n ).
How deep then do we really need to drill down? This is up to what we want to achieve in a particular application. Take hypertension as an example, and suppose we deal with essential hypertension, i.e., high blood pressure not diagnosed as a consequence of any underlying disease. In a shallow view of treatment, it's about selecting drug and dose so that pressure goes down, i.e., higher dose means lower pressure. But it's not that simple. There are different types of drugs, targeting the body in different ways. Then we must understand how they target. Some drugs are antagonists or blockers, like the angiotensin receptor and calcium channel blockers (ARB, CCB). What the par-ticular active ingredients do is to affect cells in the arterial wall, thus relaxing and widening the blood vessel. Then one might wonder how this blocking in cells actually happens in the case of ARBs and CCBs, and the acting molecules find their way through the intestines and then liver into the blood stream, and thereby to the cells in question. Experts in this area will have quite precise answers to this question (even if the authors of this paper don't), and that answer is certainly interesting, but is it relevant in that particular application dealing with hypertension treatment? In this example we see how we must choose the level of detail, i.e., how far we must drill down (expand the underlying signature!) in order to explain the problem in sufficient detail, without unnecessarily over-explaining it. So, blood pressure alone is too shallow, but intracellular molecular interaction may be too much.
Industrial applications related to system-of-systems (SoS) [7,9] are similar. Such an SoS may be a car with the structure of the car in focus, or the SoS may be a car in traffic, so the traffic system is the main SoS, where the car is just a subsystem of it. In the latter case, actuator may be a sufficient level, where in the former case we need actuator(ω 1 (t 1 ), . . . , ω n (t n )) even drilling down from ω 1 (t 1 ), . . . , ω n (t n ) into all terms t i . An SoS as a production plant combines availability and maintenance, e.g., for prediction of production process availability and performance. Improved predictive maintenance decision support through 'whatif' scenario analysis and optimisation is often desired. In a typical shallow approach, focus is only on optimising maintenance for each item of equipment in a production line, thus failing to consider the interaction between maintenance and production in sufficient detail. Components and product taxonomies are more informative within activity and process hierarchies, supporting decision-makers in various ways.
In general for machines, faults and failures reduce their function either partly or completely. The traditional engineering view of functioning does not connect accurately with faults. In order to facilitate these connections, we need a common language for representation of faults and functioning, based on appropriate nomenclatures. In addition, machines are operated by a wide range of professionals, and the business of machine production and sales involves other types of professionals.
Numerical approaches to information structure development within the industry as a whole promotes uncertainty and many-valued considerations mostly for analyzing variability, and as related to numerical values only. Logical many-valuedness, dealing differently with these underlying structures, are basically missing in most numerical approaches [8].