senso-concept-Mcs (lagCnkl)

McsHitp-creation:: {2021-01-01}

overview of lagCnkl

× generic: knowledge-language,

· concept-language is a-knowledge-language that maps structure and doing of mind-concepts.
· it is similar with a-human-language on the-input, but it has a-different output which is-understood by humans and computers today.
· also its outpt is more close to mind-views.

* McsEngl.McsTchInf000007.last.html//dirTchInf/dirMcs!⇒lagCnkl,
* McsEngl.dirMcs/dirTchInf/McsTchInf000007.last.html!⇒lagCnkl,
* McsEngl.Lcnpt!⇒lagCnkl, {2021-01-12},
* McsEngl.concept-computer-language!⇒lagCnkl, {2021-03-05},
* McsEngl.concept-language!⇒lagCnkl, {2021-01-04},
* McsEngl.lagCmpr.012-concept!⇒lagCnkl,
* McsEngl.lagCmpr.concept!⇒lagCnkl,
* McsEngl.lagCnpt!⇒lagCnkl, {2021-01-04},
* McsEngl.lagCnkl!=McsTchInf000007,
* McsEngl.lagCnkl!=concept--knowledge-language,
* McsEngl.lagConcept!⇒lagCnkl, {2021-01-24},
* McsEngl.lagCpt!⇒lagCnkl,
* McsEngl.lagKnlg.001-concept!⇒lagCnkl,
* McsEngl.lagKnlg.concept!⇒lagCnkl,
====== langoGreek:
* McsElln.γλώσσα-εννοιών!=lagCnkl,
* McsElln.εννοιακή-γλώσσα-υπολογιστών!=lagCnkl, {2021-03-05},
* McsElln.εννοιών-γλώσσα!=lagCnkl, {2021-01-04},

01_user of lagCnkl

· a-human or technology that uses the-language.

* McsEngl.lagCnkl'user,

human of lagCnkl

· the-human that uses the-language to map his mind-view.

* McsEngl.lagCnkl'human, of lagCnkl

· one or more humans that create one worldview.

* McsEngl.lagCnkl'author,

human.reader of lagCnkl

· a-human that reads the-base.

* McsEngl.lagCnkl'reader,

manager (link) of lagCnkl

02_input of lagCnkl

· the-input conceptual-view-(system of concepts) we want to map for a-machine.

* McsEngl.Cnptlinput,
* McsEngl.lagCnkl'02_input!⇒Cnptlinput,
* McsEngl.lagCnkl'domain!⇒Cnptlinput,
* McsEngl.lagCnkl'input!⇒Cnptlinput,
* McsEngl.lagCnkl'input-view!⇒Cnptlinput,
* problem-domain,

domain of Cnptlinput

· the-set of input-views we want to map.

* McsEngl.Cnptlinput'domain,
* McsEngl.lagCnkl'domain,

schema of Cnptlinput

· input-schema is the-structure of the-input-view expressed in a-lagCnkl.

* McsEngl.Cnptlinput'schema,
* McsEngl.lagCnkl'input-schema,
* McsEngl.input-schema-of-lagCnkl,

mind-concept of Cnptlinput

· a-mind-concept that is-mapped.

* McsEngl.Cnptlicpt,
* McsEngl.Cnptlinput'mind-concept!⇒Cnptlicpt,
* McsEngl.lagCnkl'input-concept!⇒Cnptlicpt,

mind-view of Cnptlinput

· a-system of mind-concepts that is-mapped.

* McsEngl.Cnptlinput'view!⇒Cnptliview,
* McsEngl.Cnptliview,
* McsEngl.lagCnkl'input-view!⇒Cnptliview,

mind-worldview of Cnptlinput

· all the-mind-views of one author that is-mapped.

* McsEngl.Cnptlinput'worldview!⇒Cnptliworld,
* McsEngl.Cnptliworld,
* McsEngl.lagCnkl'input-worldview!⇒Cnptliworld,

mind-base of Cnptlinput

· the-set of input-worldviews that is-mapped.

* McsEngl.Cnptlibase,
* McsEngl.Cnptlinput'base!⇒Cnptlibase,
* McsEngl.lagCnkl'input-base!⇒Cnptlibase,

03_output of lagCnkl

· the-output document a-machine understands.

* McsEngl.Cnptloutput,
* McsEngl.knowledge-base!⇒Cnptloutput,
* McsEngl.lagCnkl'03_output!⇒Cnptloutput,
* McsEngl.lagCnkl'coodomain!⇒Cnptloutput,
* McsEngl.lagCnkl'output!⇒Cnptloutput,
* McsEngl.output-view-of-lagCnkl!⇒Cnptloutput,

output-schema of lagCnkl

· output-schema is the-structure of the-output-view written in a-lagCnkl.

* McsEngl.Cnptloutput'schema,
* McsEngl.lagCnkl'schema,
* McsEngl.output-schema-of-lagCnkl,

output-concept of lagCnkl

· a-model of an-input-concept using the-lagCnkl.

* McsEngl.Cnptlcpt,
* McsEngl.lagCnkl'output-concept!⇒Cnptlcpt,

output-view of lagCnkl

· a-system of output-concepts.

* McsEngl.Cnptlview,
* McsEngl.lagCnkl'output-view!⇒Cnptlview,

output-worldview of lagCnkl

· all the-output-views of one author.

* McsEngl.Cnptlworld,
* McsEngl.lagCnkl'output-worldview!⇒Cnptlworld,

output-base of lagCnkl

· the-set of output-worldviews.

* McsEngl.Cnptlbase,
* McsEngl.knowledge-base-of-Cnklmngr!⇒Cnptlbase,
* McsEngl.lagCnkl'output-base!⇒Cnptlbase,

04_manager of lagCnkl

· concept-knowledge-language--manager is a-knowledge-language--manager that uses a-concept--knowledge-language-(mind-to--machine-meaning) to build its knowledge-base.
· Cnklmngr is techInfo that USES infoDataNo.
· in literature we see it as 'knowledge-tech'.
· any computer-system, with the-programs used and the-knowledge-base created.
· the-machine we want to understand the-input conceptual-system.

* McsEngl.Cklm!=concept-knowledge-language--manager,
* McsEngl.Cnklmngr!=concept-knowledge-language--manager,
* McsEngl.Cnptlmanager!⇒Cnklmngr,
* McsEngl.Knlgmngr.025-concept-language!⇒Cnklmngr,
* McsEngl.Knlgmngr.concept-language!⇒Cnklmngr,
* McsEngl.concept-knowledge-language--manager!⇒Cnklmngr,
* McsEngl.concept-tech!⇒Cnklmngr,
* McsEngl.lagCnkl'04_manager!⇒Cnklmngr,
* McsEngl.lagCnkl'manager!⇒Cnklmngr,
* McsEngl.lagCnkl'technology!⇒Cnklmngr,
* McsEngl.manager.lagCnkl!⇒Cnklmngr,
* McsEngl.tchCpt!⇒Cnklmngr,
* McsEngl.techCnpt!⇒Cnklmngr,
* McsEngl.techCnpt!⇒Cnklmngr,
* McsEngl.techConcept!⇒Cnklmngr,
* McsEngl.techInfo.001-dataNo!⇒Cnklmngr,
* McsEngl.techInfo.dataNo!⇒Cnklmngr,

"Knowledge-Representation-System is an ENTITY (computer or not) that manages knowledge using knowledge-representation-methods, other than simple TEXT or HYPERTEXT. In other words, represents analogically brainual--sub-worldviews and semasial--sub-worldviews."

knowledge-base of Cnklmngr

· the-output of implementing a-concept--knowledge-language.

* McsEngl.Cnklmngr'knowledge-base,
* McsEngl.Knlgbase.concept-knowledge-language--manager,

hard-sys of Cnklmngr

· computer, network used.

* McsEngl.Cnklmngr'hard-sys,

soft-sys of Cnklmngr

· any application used.

* McsEngl.Cnptlapp,
* McsEngl.lagCnkl'01_02_app!⇒Cnptlapp,
* McsEngl.Cnptltool,
* McsEngl.lagCnkl'01_03_tool!⇒Cnptltool,
* McsEngl.lagCnkl'tool!⇒Cnptltool,
* McsEngl.Cnklmngr.tool,

* machine-learning-system,
* machine-reasoning-system,
* machine-translating-system,
* natural-language-processing-system,
* speech-recognition-system,
* speech-to-text-system,
* text-to-speech-system,

info-resource of Cnklmngr


* McsEngl.Cnklmngr'Infrsc,

structure of Cnklmngr

* tech-system,
* application,
* base,

* McsEngl.Cnklmngr'structure,

DOING of Cnklmngr

* building-base,
* retrieving-base,
* development,
* encoding,
* decoding,
* quering,
* reasoning,
** integrating,

* McsEngl.Cnklmngr'doing,

doing.building-base of Cnklmngr

· info is subjective, then the-manager must-support the-construction of many worldviews.
· info must-be monosemantic and consistent; the-manager must-integrate additions to base and find inconsistencies.

* McsEngl.Cnklmngr'building-base,
* McsEngl.Cnklmngr'doing.building-base,
* McsEngl.Cnklmngr'storing-base,

* acquiring-base,
* validating-base,
* name-managing,
* evoluting-storage,

building.acquiring-info of Cnklmngr

· the-methods used to acquire info.
* directly by the-authors.
* collaboratively.
* automated-acquisition.
* machine-learning: reading|understanding natural-language-texts (law, science) is the-most needed function because to the-unmanaged quantity of texts today.
* sensory mechanisms.

* McsEngl.Cnklmngr'acquiring-base,
* McsEngl.Cnklmngr'doing.acquiring-info,

acquiring.automated of Cnklmngr

"despite the-power of author-collaboration, the-amount of information will-force us to automate the-procedures.
for example, in a-future networked-economy the-computers of the-companies and households will automatically feed the-servers with new-data.
* mechanical learning.
* sensor-support: brain-organisms have sensory-systems to acquire information in order to create|update|improve their brain-worldviews. Today computers have-not sensors. In the-future they will-have." [hmnSngo AAj around {2000}]

* McsEngl.Cnklmngr'acquiring.automated,
* McsEngl.Cnklmngr'automated-acquiring,
* McsEngl.Cnklmngr'doing.acquiring.automated,

building.adding-info of Cnklmngr

· the-author must add info in a-natural-language and the-manager to store it in lagCnkl.
· adding concepts the-manager must-check their validity.

* McsEngl.Cnklmngr'adding-info,
* McsEngl.Cnklmngr'doing.adding-info,

building.changing-info of Cnklmngr

· changing concepts the-manager must-check their validity.

* McsEngl.Cnklmngr'changing-info,
* McsEngl.Cnklmngr'doing.changing-info,

building.validating-base of Cnklmngr

· of the-most important function.
· the-manager must-check the-validity of the-base.
* for Consistency on every addition, change.
* for Completeness (no holes).
* for Classification (no undefined names).
* for Clearness (no vague boundaries).

* McsEngl.Cnklmngr'validating-base, of Cnklmngr

· any new name is validating by the-name-mechanism of its language.

* McsEngl.Cnklmngr'name-managing,

building.evoluting-storage of Cnklmngr

· the-universe and our knowledge about it both are constantly EVOLVING. Then the-system must-have the-ability to store and present its information evolutionarily. It must-be able to present its state of knowledge at every previous time-point.
[AAj development]

* McsEngl.Cnklmngr'evoluting-storage,

doing.retreiving-base of Cnklmngr

· info retreival must-be easy and intuitive.

* McsEngl.Cnklmngr'doing.retreiving-base,
* McsEngl.Cnklmngr'retreiving-base,

retreiving.accessing of Cnklmngr

· the-manager must-be an-online|internet-system that anyone can-access.

* McsEngl.Cnklmngr'accessing,
* McsEngl.Cnklmngr'doing.accessing,

retreiving.presenting of Cnklmngr

· the-manager must-present the-base in any-natural-language.
· also written and spoken languages must-supported.
· evolution of the-base and its referent must-supported.
· levels of abstraction also.

* McsEngl.Cnklmngr'doing.presenting,
* McsEngl.Cnklmngr'presenting,

presenting.natural-language of Cnklmngr

· the-system must-can-present the-base in any natural-language.

* McsEngl.Cnklmngr'doing.presenting.natural-language,
* McsEngl.Cnklmngr'presenting.natural-language,

presenting.worldview of Cnklmngr

· the-system must-present the-different VIEWS that exist about an-entity.
· the-system must-have the-ability to COMPARE|analyze any other text/speech against its stored-base.

* McsEngl.Cnklmngr'doing.presenting-worldviews,
* McsEngl.Cnklmngr'presenting-worldviews,
* McsEngl.Cnklmngr'worldviews-presenting,

presenting.evoluting of Cnklmngr

· the-system must-have the-ability to present the-evolution of an-entity AND the-evolution of our-knowledge about this entity.

* McsEngl.Cnklmngr'doing.evoluting-presenting,
* McsEngl.Cnklmngr'evoluting-presenting,
* McsEngl.Cnklmngr'presenting.evoluting,

presenting.levels-of-abstraction of Cnklmngr

· the-system must-have the-ability to present its knowledge in different LEVELS-OF-ABSTRACTION.
· like the-zoom-in, zoom-out functions in the-map-software, it should-present the-same entity with more or less details.

* McsEngl.Cnklmngr'doing.presenting.levels-of-abstraction,
* McsEngl.Cnklmngr'levels-of-abstraction-presenting,
* McsEngl.Cnklmngr'presenting.levels-of-abstraction,

retreiving.navigating of Cnklmngr

· intuitive, graphical, textual and spoken user-interface.
· quering the-system.
· question answering.
· table of contents.

* McsEngl.Cnklmngr'doing.navigating,
* McsEngl.Cnklmngr'navigating,

navigating.natural-language of Cnklmngr

· the-user could-choose any natural-language (written|spoken).

* McsEngl.Cnklmngr'doing.navigating.natural-language,
* McsEngl.Cnklmngr'natural-language-navigating,
* McsEngl.Cnklmngr'navigating.natural-language,
* McsEngl.Cnklmngr'user-interface-for-navigation,

navigating.quering of Cnklmngr

· quering in any language written or spoken.
· the-manager must-can-search RELATED concepts and not only the-entire base; for example AAj's-smart-search.

* McsEngl.Cnklmngr'doing.quering,
* McsEngl.Cnklmngr'finding,
* McsEngl.Cnklmngr'navigating.searching,
* McsEngl.Cnklmngr'quering,
* McsEngl.Cnklmngr'searching,

navigating.table-of-contents of Cnklmngr

· table-of-contents for easy navigation on any attribute of a-concept.

* McsEngl.Cnklmngr'navigating.table-of-contents,
* McsEngl.Cnklmngr'table-of-contents-for-navigation,

retreiving.translating of Cnklmngr

· the-manager must-can-COMPUTE the-translation of the-base in any natural-language and not just store the-translation.
· any natural-language in navigation and presentation.

* McsEngl.Cnklmngr'doing.translating,
* McsEngl.Cnklmngr'translating,

doing.thinking of Cnklmngr

· any human-thinking done by Cnklmngr.

* McsEngl.Cnklmngr'computing!⇒Cnklmngr'thinking,
* McsEngl.Cnklmngr'doing.thinking!⇒Cnklmngr'thinking,
* McsEngl.Cnklmngr'inferencing!⇒Cnklmngr'thinking,
* McsEngl.Cnklmngr'reasoning!⇒Cnklmngr'thinking,
* McsEngl.Cnklmngr'thinking!⇒Cnklmngr'thinking,


* generalizing,
* instantiating,
* integrating,
* specializing,
* translating,

* McsEngl.Cnklmngr'thinking.specific,


"A rule of inference under which, given a knowledge base which contains the formulas "A" and "A implies B", one may conclude "B"."

* McsEngl.Cnklmngr'thinking.modus-ponens,
* McsEngl.modus-ponens-of-Cnklmngr,


"A rule of inference which can be derived from modus ponens under which, given a knowledge base which contains the formulas "Not B" and "A implies B", one may conclude "Not A"."

* McsEngl.Cnklmngr'thinking.modus-tollens,
* McsEngl.modus-tollens-of-Cnklmngr,


· making it a-consistent whole.

* McsEngl.knowledge-integrating,
* McsEngl.Cnklmngr'doing.integrating,



* Mcsmgr,
** Hmcsmgr,
=== generic:
* artificial-intelligence-system,
* collaborative-system,
* conceptual-graphs-system,
* decision-support-system,
* Description-logic-system,
* Design-system,
* Diagnosis-system,
* Expert-system,
* Frame-based-system,
* Java-system,
* Lisp-system,
* logic-system,
* Mcsmgr,
* ontology-system,
* planning/scheduling-system,
* process-control-system,
* rule-based-system,
* Smalltalk-system,
* web-system,
=== individual:
* CODE4,
* ConceptBase,
* Cyc,
* McsmgrAAj,
* McsmgrHitp,
* McsmgrFv,
* Protege,
* WolframAlpha,
* WordNet,

* McsEngl.Cnklmngr.specific,


· controlled-natural-language,
· frame-based,
· logic-based,
· rule-based,
· semantic-network,

* McsEngl.Cnklmngr.specs-division.on-lagConcept,


* C++-system,
* Java-system,
* Lisp-system,
* Prolog-system,
* Smalltalk-system,

* McsEngl.Cnklmngr.specs-division.on-lagPrograming,


* geography-system,
* history-system,
* infotech-system,
* med-system,
* physics-system,
* worldview-system,

* McsEngl.Cnklmngr.specs-division.on-input-info,


* Canada-system,
* Eu-system,
* Usa-system,

* McsEngl.Cnklmngr.specs-division.on-country,

05_evaluation of lagCnkl

· the-cons and pros of the-lagCnkl.

* McsEngl.lagCnkl'05_evaluation,
* McsEngl.lagCnkl'evaluation,

expressiveness-vs-efficiency of lagCnkl

"Expressiveness in a representation language is the ability to express facts, rules, and relationships quickly, easily, and in a principled and factored way.
Efficiency in a representation language is the ability to conclude new facts from existing facts as quickly and easily as possible, with as much coverage as possible...
Most natural languages, for example English, would have a high expressiveness but a low efficiency if used as a knowledge representation language".

* McsEngl.lagCnkl'expressiveness-vs-efficiency,

info-resource of lagCnkl

* McsEngl.Cnptlrsc,
* McsEngl.lagCnkl'Infrsc!⇒Cnptlrsc,


specification of Cnptlrsc

· official formal documentation of the-language.

* McsEngl.Cnptlrsc'specification,
* McsEngl.lagCnkl'specification,

data-exchange-language of Cnptlrsc

"A data interchange (or exchange) language/format is a language that is domain-independent and can be used for data from any kind of discipline.[9] They have "evolved from being markup and display-oriented to further support the encoding of metadata that describes the structural attributes of the information."[10]
Practice has shown that certain types of formal languages are better suited for this task than others, since their specification is driven by a formal process instead of particular software implementation needs. For example, XML is a markup language that was designed to enable the creation of dialects (the definition of domain-specific sublanguages).[11] However, it does not contain domain-specific dictionaries or fact types. Beneficial to a reliable data exchange is the availability of standard dictionaries-taxonomies and tools libraries such as parsers, schema validators, and transformation tools.[citation needed]
Popular languages used for data exchange
* RDF,
* XML,
* Atom,
* Gellish"

* McsEngl.Cnptlrsc'data-exchange-language,
* McsEngl.lagCnkl'data-exchange-language,

modeling-language of Cnptlrsc

"A modeling language is any artificial language that can be used to express information or knowledge or systems in a structure that is defined by a consistent set of rules. The rules are used for interpretation of the meaning of components in the structure."

* McsEngl.Cnptlrsc'modeling-language,
* McsEngl.lagCnkl'modeling-language,
* McsEngl.modeling-language,

formal-concept-analysis of Cnptlrsc

"Formal Concept Analysis (FCA) is a method for data analysis, knowledge representation and information management that is widely unknown among information scientists in the USA even though this technology has a significant potential for applications. FCA was invented by Rudolf Wille in the early 80s (Wille, 1982). For the first 10 years, FCA was developed mainly by a small group of researchers and Wille’s students in Germany. Because of the mathematical nature of most of the publications of that time, knowledge of FCA remained restricted to a group of “insiders”. Through funded research projects, FCA was implemented in several larger-scale applications, most notably an implementation of a knowledge exploration system for civil engineering in cooperation with the Ministry for Civil Engineering of North-Rhine Westfalia (cf. Eschenfelder et al. (2000)). But these applications were not publicized widely beyond Germany."

* McsEngl.Cnptlrsc'formal-concept-analysis,
* McsEngl.FCA'(formal-concept-analysis),
* McsEngl.formal-concept-analysis,


DOING of lagCnkl

* McsEngl.lagCnkl'doing,

* creating,
* learning,
* using,
* translating,
* support automated-reasoning,

evoluting of lagCnkl

=== McsHitp-creation:
· creation of current concept.

"The information covered by Google's Knowledge Graph grew quickly after launch, tripling its size within seven months (covering 570 million entities and 18 billion facts[3]).
By mid-2016, Google reported that it held 70 billion facts[4] and answered "roughly one-third" of the 100 billion monthly searches they handled.
By May 2020, this had grown to 500 billion facts on 5 billion entities.[5]"
* McsEngl.{lagCnkl'2020-05}-Google-knowledge-graph,

· initial release.
"Cortana is a virtual assistant developed by Microsoft, which uses the Bing search engine to perform tasks such as setting reminders and answering questions for the user."
* McsEngl.{lagCnkl'2014-11-06}-Microsoft-Cortana,

· initial release.
· Alexa-voice-service-(AVS) provides cloud-based automatic-speech-recognition-(ASR) and natural-language-understanding-(NLU).
* McsEngl.{lagCnkl'2014-04-02}-Amazon-Alexa,

· WolframAlpha was-released.
· it is a-computational-knowledge-engine or answer-engine developed by WolframAlpha-LLC, a-subsidiary of Wolfram-Research.
· it is an-online-service that answers factual-queries directly by computing the-answer from externally sourced "curated-data", rather than providing a-list of documents or webpages that might contain the-answer, as a-search-engine might.
* McsEngl.{lagCnkl'2009-05-18}-WolframAlpha,

"The World Wide Web Consortium created the "Web Ontology Working Group" which began work on 2001-11-01 chaired by James Hendler and Guus Schreiber. The first working drafts of the abstract syntax, reference and synopsis were published in July 2002. The OWL documents became a formal W3C recommendation on 2004-02-10 and the working group was disbanded on 2004-05-31.[4]"
* McsEngl.{lagCnkl'2004-02-10}-OWL,

"A number of research efforts during the mid to late 1990s explored how the idea of knowledge representation (KR) from AI could be made useful on the World Wide Web. These included languages based on HTML (called SHOE), XML (called XOL, later OIL), and various frame-based KR languages and knowledge acquisition approaches."
* McsEngl.{lagCnkl'i10-2000}-www,

"Rule systems have been implemented and studied since the mid-1970s and saw significant uptake in the 1980s during the height of so-called Expert Systems."
"An expert system, also known as a knowledge based system, is a computer program that contains the knowledge and analytical skills of one or more human experts, related to a specific subject. This class of program was first developed by researchers in artificial intelligence during the 1960s and 1970s and applied commercially throughout the 1980s."
* McsEngl.{lagCnkl'i10-1990}-expert-system,

"In 1984, Doug Lenat started the Cyc Project with the objective of codify, in machine-usable form, millions of pieces of knowledge that comprise human common sense.
CycL presented a proprietary knowledge representation schema that utilized first-order relationships."
* McsEngl.{lagCnkl'1984}-Cyc-project,

"In the field of Artificial Intelligence, a frame is a data structure introduced by Marvin Minsky in the 1970s that can be used for knowledge representation.
Roughly similar to the object-oriented paradigm, they represent classes (called frames) with certain properties called attributes or slots.
Slots may contain values, refer to other frames (relations) or contain methods.
Frames are thus a machine-usable formalization of concepts or schemata."
* McsEngl.{lagCnkl'i10-1980}-frame-based-representation,

"[Prolog] was developed and implemented in Marseille, France, in 1972 by Alain Colmerauer with Philippe Roussel, based on Robert Kowalski's procedural interpretation of Horn clauses.[5][6]"
* McsEngl.{lagCnkl'1972}-Prolog,

"However, the first proposal to use the clausal form of logic for representing computer programs was made by Cordell Green (1969). This used an axiomatization of a subset of LISP, together with a representation of an input-output relation, to compute the relation by simulating the execution of the program in LISP."
* McsEngl.{lagCnkl'1969}-logic-programing,

"From the 1960s, the knowledge frame or just frame has been used. Each frame has its own name and a set of attributes, or slots which contain values; for instance, the frame for house might contain a color slot, number of floors slot, etc."
* McsEngl.{lagCnkl'i10-1970}-frames,

* McsEngl.evoluting-of-lagCnkl,
* McsEngl.lagCnkl'evoluting,


* McsEngl.lagCnkl'whole-part-tree,

* ... Sympan.



* McsEngl.lagCnkl'generic-specific-tree,

* naturalNo-human-mind--language,
* ... entity.

* processing-lagCnkl,
* representation-lagCnkl,
* processing-and-representation-lagCnkl,
* general-purpose,
* generalNo-purpose,
* explicit-krl,
* explicitNo,
* uniform,
* uniformNo,
* common-logic,
* concept-mapping,
* conceptual-graph,
* controlled-natural-language,
* description-logics,
* entity-attribute-value,
* first-order-logic,
* formal-concept-analysis,
* frame-based,
* knowledge-graph,
* logic-krl,
* ontology-krl,
* propositional-lagCnkl,
* semantic-network,
* topic-maps,
* visual,
* Cycl,
* KIF,
* loom,
* OWL,
* RDF,
* RIF,


· it models the-structure of mind-concepts.

* McsEngl.KRL!=knowledge-representation-language!⇒lagCtsr,
* McsEngl.concept-structure-representation--concept-language!⇒lagCtsr,
* McsEngl.descriptive-concept-language!⇒lagCtsr,
* McsEngl.knowledge-representation-language!⇒lagCtsr,
* McsEngl.lagCnkl.001-representation!⇒lagCtsr,
* McsEngl.lagCnkl.representation!⇒lagCtsr,
* McsEngl.lagCtsr!=ConcepT-StructuRe-representation--lagCnkl,
* McsEngl.representation-lagCnkl!⇒lagCtsr,
* McsEngl.structure-lagCnkl!⇒lagCtsr,


· it models the-doings-(inferencing, quering, computing) of mind-concepts.

* McsEngl.concept-doing-representation--concept-language!⇒lagCtdg,
* McsEngl.doing-lagCnkl!⇒lagCtdg,
* McsEngl.lagCnkl.002-processing!⇒lagCtdg,
* McsEngl.lagCnkl.processing!⇒lagCtdg,
* McsEngl.lagCtdg,
* McsEngl.lagCtdg!=ConcepT-DoinG--lagCnkl,
* McsEngl.procedural-concept-language!⇒lagCtdg,
* McsEngl.processing-knowledge-language!⇒lagCtdg,


· it models the-structure and doings of mind-concepts.

* McsEngl.concept-structure-and-doing--lagCnkl!⇒lagCsad,
* McsEngl.doing-and-structure--lagCnkl!⇒lagCsad,
* McsEngl.lagCnkl.003-representation-and-processing!⇒lagCsad,
* McsEngl.lagCnkl.representation-and-processing!⇒lagCsad,
* McsEngl.lagCsad,
* McsEngl.lagCsad!=Concept-Structure-And-Doing-lagCnkl!⇒lagCsad,
* McsEngl.processing-and-structure--lagCnkl!⇒lagCsad,
* McsEngl.reasoning-and-representation--lagCnkl!⇒lagCsad,
* McsEngl.representation-and-reasoning--lagCnkl!⇒lagCsad,
* McsEngl.structure-and-doing--lagCnkl!⇒lagCsad,


· the-output comprised of text.

* McsEngl.lagCnkl.033-textual!⇒lagCtxt,
* McsEngl.lagCnkl.textual!⇒lagCtxt,
* McsEngl.lagCtxt,
* McsEngl.lagCtxt!=textual-lagCnkl,


· the-output comprised of images.

* McsEngl.lagCnkl.034-visual!⇒lagCvkl,
* McsEngl.lagCnkl.visual!⇒lagCvkl,
* McsEngl.lagCvkl!=concept-visual--knowledge-language,


"The Unified Modeling Language™ (UML®) is a standard visual modeling language intended to be used for
* modeling business and similar processes,
* analysis, design, and implementation of software-based systems
UML is a common language for business analysts, software architects and developers used to describe, specify, design, and document existing or new business processes, structure and behavior of artifacts of software systems.
UML can be applied to diverse application domains (e.g., banking, finance, internet, aerospace, healthcare, etc.) It can be used with all major object and component software development methods and for various implementation platforms (e.g., J2EE, .NET)."

* McsEngl.UML!=unified-modeling-language,
* McsEngl.lagCnkl.035-UML!⇒lagUmlg,
* McsEngl.lagCnkl.UML!⇒lagUmlg,
* McsEngl.lagCvkl.UML!⇒lagUmlg,


"A concept map or conceptual diagram is a diagram that depicts suggested relationships between concepts.[1] Concept maps may be used by instructional designers, engineers, technical writers, and others to organize and structure knowledge.
A concept map typically represents ideas and information as boxes or circles, which it connects with labeled arrows, often in a downward-branching hierarchical structure. The relationship between concepts can be articulated in linking phrases such as "causes", "requires", "such as" or "contributes to".[2]
The technique for visualizing these relationships among different concepts is called concept mapping. Concept maps have been used to define the ontology of computer systems, for example with the object-role modeling or Unified Modeling Language formalism."

* McsEngl.concept-mapping,
* McsEngl.lagCnkl.038-concept-mapping,
* McsEngl.lagCnkl.concept-mapping,


What is VUE?
At its core, the Visual Understanding Environment (VUE) is a concept and content mapping application, developed to support teaching, learning and research and for anyone who needs to organize, contextualize, and access digital information. Using a simple set of tools and a basic visual grammar consisting of nodes and links, faculty and students can map relationships between concepts, ideas and digital content.

Concept mapping is not new to the educational field. In fact, the benefits of concept mapping as a learning tool have been documented by over 40 years of cognitive science research. VUE provides a concept mapping interface, which can be used as such, or as an interface to organize digital content in non-linear ways.

Numerous tools currently exist for locating digital information, but few applications are available for making sense of the information available to us. As the availability of digital information continues to increase, VUE sets itself apart as a flexible tool to help faculty and students integrate, organize and contextualize electronic content in their work. Digital content can be accessed via the Web, or using the VUE’s “Resources” panel to tap into digital repositories, FTP servers and local file systems.

Sharing and presenting information are important aspects of academic work. VUE’s pathways feature allows presenters to create annotated trails through their maps, which become expert guided walk-throughs of the information. The pathways feature also provides a “slide view” of the information on the map. The power of VUE’s slide mode is the ability for presenters to focus on content (slide view) while preserving the information’s context (map view), by way of a single toggle between the two views.

VUE also provides supports for in-depth analysis of maps, with the ability to merge maps and export connectivity matrices to import in statistical packages. VUE also provide tools to apply semantic meaning to the maps, by way of ontologies and metadata schemas.

VUE can be used by anyone interested in visually structuring digital content, whether in support of teaching difficult to understand concepts or more generally, a tool for organizing personal digital resources.
[{2023-11-09 retrieved}]

* McsEngl.VUE!=Visual-Understanding-Environment,
* McsEngl.lagCvkl.VUE,
* McsEngl.lagCnkl.041-VUE,
* McsEngl.lagCnkl.VUE,


× generic: markup-language,

· a-markup-language that maps conceptual-systems.

* McsEngl.concept--markup-language,
* McsEngl.lagCnkl.039-markup,
* McsEngl.lagCnkl.markup,
* McsEngl.lagCnklMrkp,


* Xml,
* lagMcsh,

* McsEngl.lagCnklMrkp.specific,

lagCnkl.McsHitp-007 (link)


"overview of frame knowledge representation language:
A frame knowledge representation language is a type of knowledge representation system used in artificial intelligence and computer science to model and organize knowledge in a structured and hierarchical manner. Frames are used to represent entities, concepts, or objects, and their attributes, relationships, and behaviors. Here's an overview of frame knowledge representation language:

1. **Frames:** Frames are the central concept in this representation. A frame is a data structure that encapsulates information about an entity or concept. Each frame represents an object, concept, or class and contains slots to store data about that object.

2. **Slots:** Slots are the building blocks of frames and represent attributes or properties of the entity being modeled. Slots can hold values, references to other frames, or procedures to compute values. For example, a "Person" frame might have slots for "Name," "Age," "Address," and so on.

3. **Values:** Values are the actual data stored in slots. These can be primitive data types like numbers, strings, or more complex data structures, including references to other frames.

4. **Inheritance:** Frames can be organized in a hierarchical manner, where frames can inherit slots and their values from ancestor frames. This allows for the modeling of generalization and specialization relationships. For example, a "Student" frame might inherit attributes from a "Person" frame.

5. **Prototypes:** Prototypes are frames that serve as templates for creating new frames. Instead of defining every attribute for each new frame, you can create a prototype with common attributes and then create instances based on that prototype.

6. **Scripts and Methods:** Frames can also include procedures or methods that define the behavior associated with the frame. These methods can perform actions or computations based on the data in the frame.

7. **Relationships:** Frames can represent relationships between objects or concepts. These relationships can be represented using slots that point to other frames, and this allows for modeling complex networks of relationships.

8. **Default Values:** Frames can have default values for their slots, which are used when a specific value is not explicitly provided. This is helpful for handling missing information or making the representation more efficient.

9. **Semantic Networks:** Frame knowledge representation is closely related to semantic networks, which are graphical representations of knowledge using nodes (frames) and edges (relationships).

10. **Applications:** Frame-based knowledge representation languages have been used in various AI applications, such as expert systems, natural language processing, and semantic web technologies.

Some well-known frame-based knowledge representation languages include:
- **Frame-based systems:** Cyc and KL-ONE are examples of systems that use frame-based knowledge representation.
- **Semantic Web:** The Resource Description Framework (RDF) and Web Ontology Language (OWL) are related to frame-based languages and are used for representing knowledge on the web.

Frame-based knowledge representation is particularly useful when dealing with structured and complex knowledge domains, as it provides a rich and flexible way to model and manipulate information."
[{2023-11-01 retrieved}]

* McsEngl.frame-and-slot-language!⇒lagFram,
* McsEngl.frame-language!⇒lagFram,
* McsEngl.lagCnkl.037-frame!⇒lagFram,
* McsEngl.lagFram,
* McsEngl.lagFram!=frame-language,

input of lagFram


* McsEngl.lagFram'input,

output of lagFram


* McsEngl.lagFram'output,

frame of lagFram


* McsEngl.Framframe,
* McsEngl.frame-of-lagFram!⇒Framframe,
* McsEngl.lagFram'frame!⇒Framframe,
* McsEngl.lagFram'script!⇒Framframe,

evaluation of lagFram

· a-frame-language is a-concept-language because 'frames' are actually concepts.

* McsEngl.lagFram'evaluation,

manager of lagFram

· the-knowledge-manager of a lagFram.

* McsEngl.Frmlmngr!=frame-language--manager,
* McsEngl.frame-based-system!⇒Frmlmngr,
* McsEngl.lagFram'manager!⇒Frmlmngr,

* Cyc,
* FrameNet,
* OntoFrame,

info-resource of lagFram


* McsEngl.lagFram'Infrsc,

evoluting of lagFram


* McsEngl.evoluting-of-lagFram,
* McsEngl.lagFram'evoluting,


* CycL,
* KEE,
* KRL,
* Loom,

* McsEngl.lagFram.specific,


· semantic-network-lang is a-concept-language that models mind-concepts as a-NETWORK.

* McsEngl.frame-network!⇒lagSnet,
* McsEngl.graph-lagCnkl!⇒lagSnet,
* McsEngl.lagCnkl.022-semantic-network!⇒lagSnet,
* McsEngl.lagCnkl.semantic-network!⇒lagSnet,
* McsEngl.lagNtwk!⇒lagSnet,
* McsEngl.lagSnet!=semantic-network,
* McsEngl.semantic-network!⇒lagSnet,

"A semantic network, or frame network is a knowledge base that represents semantic relations between concepts in a network. This is often used as a form of knowledge representation. It is a directed or undirected graph consisting of vertices, which represent concepts, and edges, which represent semantic relations between concepts,[1] mapping or connecting semantic fields. A semantic network may be instantiated as, for example, a graph database or a concept map.
Typical standardized semantic networks are expressed as semantic triples.
Semantic networks are used in natural language processing applications such as semantic parsing[2] and word-sense disambiguation.[3]"

output of lagSnet

"A knowledge graph is a knowledge base that uses a graph-structured data model or topology to integrate data. Knowledge graphs are often used to store interlinked descriptions of entities – objects, events, situations or abstract concepts – with free-form semantics.[1]
Since the development of the Semantic Web, knowledge graphs are often associated with linked open data projects, focusing on the connections between concepts and entities.[2][3] They are also prominently associated with and used by search engines such as Google, Bing, and Yahoo; knowledge-engines and question-answering services such as WolframAlpha, Apple's Siri, and Amazon Alexa; and social networks such as LinkedIn and Facebook."

* McsEngl.Snetoutput,
* McsEngl.knowledge-graph!⇒Snetoutput,
* McsEngl.lagSnet'output!⇒Snetoutput,
* knowledge-base,

*, and its relation with database-graph,

Snetoutput.Google-knowledge-graph (link)

Snetoutput.Wordnet (link)

evoluting of lagSnet

"evolution of semantic-networks:
Semantic networks are a type of knowledge representation used in artificial intelligence and cognitive science to model the organization of concepts and their relationships. They have evolved over time, and their development can be divided into several stages:

1. **Early Cognitive Models (1950s - 1960s):** The roots of semantic networks can be traced back to early cognitive psychology and linguistics. Researchers like Ross Quillian and Allan M. Collins developed some of the earliest models of semantic networks during this period. They proposed simple networks of concepts linked by "is-a" or "kind-of" relationships.

2. **Conceptual Dependency Theory (1970s):** In the 1970s, researchers like Schank and Riesbeck developed the Conceptual Dependency Theory, which extended semantic networks by incorporating a broader range of relationships, such as "agent," "patient," and "instrument." These relationships allowed for more complex knowledge representation.

3. **Frame-Based Systems (1970s - 1980s):** Frames, introduced by Marvin Minsky, are structures that contain information about a specific concept, including its attributes, relationships, and behaviors. Frames serve as the basis for knowledge representation in semantic networks, enabling the representation of richer information about concepts.

4. **Scripts (1970s - 1980s):** Roger Schank's concept of scripts extended semantic networks by introducing the idea of representing stereotypical sequences of events or actions. Scripts are essentially templates for common real-world scenarios and actions.

5. **Connectionist Models (1980s - 1990s):** Connectionist models, such as neural networks, began to influence the development of semantic networks. These models used distributed representations and connection weights to capture the meaning of words and concepts. These representations were less symbolic and more data-driven.

6. **Ontologies and Knowledge Graphs (1990s - Present):** With the advent of the World Wide Web, there was a growing need for more structured and standardized knowledge representation. This led to the development of ontologies and knowledge graphs. Ontologies like the Semantic Web's RDF (Resource Description Framework) and OWL (Web Ontology Language) allowed for the creation of structured, machine-readable representations of knowledge. Knowledge graphs, such as Google's Knowledge Graph, organized vast amounts of structured data, allowing search engines to provide more accurate and context-aware information.

7. **Word Embeddings and Neural Networks (2010s - Present):** In recent years, word embeddings and deep learning methods have become popular for natural language understanding and knowledge representation. Techniques like Word2Vec, GloVe, and BERT have enabled the development of more context-aware and semantically rich representations of words and concepts.

8. **Hybrid Approaches (Present):** Today, semantic networks often combine various methods, including symbolic and connectionist approaches. Hybrid models that use both symbolic representations and distributed representations have gained popularity for tasks like natural language understanding and reasoning.

The evolution of semantic networks reflects the ongoing efforts to create more sophisticated and accurate models for representing and understanding human knowledge and language. As AI and cognitive science continue to advance, semantic networks will likely continue to evolve and adapt to new challenges and opportunities."
[{2023-10-24 retrieved}]

"evolution of semantic-networks:
Semantic networks are a type of knowledge representation that uses nodes and edges to represent concepts and relationships between them. They have been used in a variety of artificial intelligence applications, including natural language processing, machine learning, and expert systems.

The evolution of semantic networks can be traced back to the early days of artificial intelligence, with early examples such as the Cyc project and the Semantic Net project. However, it was not until the late 1980s and early 1990s that semantic networks began to be widely used in practical applications.

One of the main driving forces behind the evolution of semantic networks has been the development of new algorithms for knowledge representation and reasoning. For example, the development of description logics in the 1990s provided a more powerful and expressive way to represent knowledge in semantic networks.

Another important factor in the evolution of semantic networks has been the development of new technologies for knowledge acquisition and sharing. For example, the Semantic Web provides a framework for sharing and interlinking knowledge across the internet.

Semantic networks are now widely used in a variety of applications, including:
* **Natural language processing:** Semantic networks are used to represent the meaning of words and sentences, and to support tasks such as machine translation, text summarization, and question answering.
* **Machine learning:** Semantic networks can be used to represent the features of data and to support tasks such as classification, regression, and clustering.
* **Expert systems:** Semantic networks can be used to represent the knowledge of experts in a particular domain, and to support tasks such as diagnosis, decision making, and planning.

Here are some specific examples of how semantic networks are being used today:
* **Google Search:** Google Search uses semantic networks to understand the meaning of search queries and to provide relevant results.
* **Wikipedia:** Wikipedia uses semantic networks to represent the relationships between different articles.
* **Facebook:** Facebook uses semantic networks to recommend friends to users and to target advertising.
* **Amazon:** Amazon uses semantic networks to recommend products to customers.

Semantic networks are a powerful tool for representing and reasoning about knowledge. They are used in a wide variety of applications, and their importance is likely to continue to grow in the future.

**Recent trends in the evolution of semantic networks**
In recent years, there has been a growing interest in the use of deep learning to improve the performance of semantic networks. For example, deep learning can be used to learn more expressive representations of concepts and relationships, and to develop more efficient algorithms for reasoning.

Another recent trend is the development of new methods for integrating semantic networks with other knowledge representation and reasoning technologies, such as ontologies and rule engines. This integration can lead to more powerful and flexible knowledge-based systems.

Overall, the evolution of semantic networks is a dynamic and exciting area of research. Semantic networks are becoming increasingly powerful and versatile, and they are being used in a wider range of applications."
[{2023-10-24 retrieved}]

* McsEngl.evoluting-of-lagSnet,
* McsEngl.lagSnet'evoluting,



* McsEngl.lagSnet.specific,


"evolution of knowledge-graphs:
Knowledge graphs (KGs) have evolved significantly since their early days. The first KGs were hand-crafted and relatively small, but they quickly grew in size and complexity as researchers developed new techniques for knowledge extraction and reasoning. Today, KGs are used in a wide range of applications, including search, question answering, and machine learning.

One of the key trends in the evolution of KGs has been the shift from entity-based to text-rich graphs. Entity-based KGs represent knowledge as a collection of entities and their relationships. Text-rich KGs, on the other hand, allow for the inclusion of free text descriptions of entities and relationships. This makes text-rich KGs more expressive and easier to maintain and update.

Another important trend is the emergence of dual-neural graphs. Dual-neural graphs combine entity-based and text-rich representations of knowledge. This allows them to take advantage of the strengths of both approaches, while overcoming some of their limitations. For example, dual-neural graphs can be more robust to noise in the data and can better capture the context of knowledge.

Here is a timeline of some of the key milestones in the evolution of knowledge graphs:
* **1970s:** The first KGs are developed, such as Cyc and SUMO. These KGs are hand-crafted and relatively small.
* **1980s and 1990s:** Researchers develop new techniques for knowledge extraction, such as rule-based systems and machine learning algorithms. This leads to the development of larger and more complex KGs.
* **2000s:** The Web of Data is launched, providing a framework for publishing and sharing KGs on the web. This leads to the development of large open KGs, such as DBpedia and Wikidata.
* **2010s:** Dual-neural graphs are developed. These graphs combine entity-based and text-rich representations of knowledge, which makes them more expressive and easier to maintain and update.

Today, KGs are used in a wide range of applications, including:
* **Search:** KGs can be used to improve the accuracy and relevancy of search results. For example, a search engine can use a KG to understand the context of a query and to provide more relevant results.
* **Question answering:** KGs can be used to answer complex questions in a comprehensive and informative way. For example, a question answering system can use a KG to answer questions about the relationships between different entities.
* **Machine learning:** KGs can be used to train and improve the performance of machine learning models. For example, a machine learning model can be trained on a KG to learn how to classify or predict entities.

The evolution of knowledge graphs is still ongoing. Researchers are developing new techniques for knowledge extraction, reasoning, and machine learning. This is leading to the development of more powerful and expressive KGs that can be used in a wider range of applications."
[{2023-10-26 retrieved}]
"evolution of knowledge-graphs:
Knowledge graphs have evolved significantly over the years, driven by advancements in technology and the growing need for organizing and making sense of vast amounts of data. Here is a brief overview of the evolution of knowledge graphs:

1. Early Databases and Semantic Networks:
- The concept of organizing information in a network-like structure can be traced back to early databases and semantic networks in the 1960s and 1970s.
- Systems like the Generalized Markup Language (GML) and early versions of the Semantic Web laid the foundation for structuring data in a graph format.

2. RDF and the Semantic Web:
- The development of the Resource Description Framework (RDF) in the late 1990s marked a significant step in the evolution of knowledge graphs.
- RDF provided a standardized way to represent data in a subject-predicate-object format, which forms the basis of many modern knowledge graphs.
- The Semantic Web project aimed to interconnect these RDF data sources, creating a web of linked data.

3. Ontologies and Taxonomies:
- Knowledge graphs often incorporate ontologies and taxonomies to provide a structured framework for data.
- Ontologies, such as OWL (Web Ontology Language), enable the formal definition of concepts, relationships, and properties within a domain.
- Taxonomies help organize data hierarchically, facilitating categorization and classification.

4. Graph Databases:
- The emergence of graph databases in the early 2000s, such as Neo4j and AllegroGraph, provided a dedicated platform for storing and querying graph-structured data efficiently.
- These databases enable the representation and retrieval of data as graphs, making them well-suited for knowledge graph applications.

5. Linked Data:
- Tim Berners-Lee's Linked Data principles, introduced in the late 2000s, encouraged publishing structured data on the web using RDF and URIs.
- This approach led to the creation of an interconnected web of data, promoting the growth of knowledge graphs.

6. Knowledge Representation and Inference:
- Knowledge graphs have evolved to include inference and reasoning capabilities, allowing for the deduction of new information from existing data.
- Technologies like RDFS (Resource Description Framework Schema) and OWL support reasoning over knowledge graphs.

7. Machine Learning and NLP Integration:
- Recent advancements in machine learning and natural language processing (NLP) have allowed for the automated extraction of structured data from unstructured text, contributing to knowledge graph enrichment.
- Machine learning techniques have been applied to knowledge graph completion and entity resolution.

8. Industry Applications:
- Knowledge graphs have found applications in various industries, including healthcare (patient records and drug interactions), e-commerce (product recommendations), finance (fraud detection), and more.
- They are used for search engines, recommendation systems, and data integration in many domains.

9. Evolving Standards:
- Standards and tools for working with knowledge graphs continue to evolve. Initiatives like the W3C RDF Working Group and various open-source projects contribute to the development of best practices and technologies.

The evolution of knowledge graphs is ongoing, and they continue to play a crucial role in organizing and making data more accessible and meaningful in a variety of fields. Their potential for helping computers understand and reason about information makes them a key component of the future of artificial intelligence and data management."
[{2023-10-26 retrieved}]

* McsEngl.KG!=knowledge-graph!⇒lagKngr,
* McsEngl.knowledge-graph!⇒lagKngr,
* McsEngl.lagCnkl.042-knowledge-graph!⇒lagKngr,
* McsEngl.lagCnkl.knowledge-graph!⇒lagKngr,
* McsEngl.lagKngr!=knowledge-graph--language,
* McsEngl.lagSnet.knowledge-graph!⇒lagKngr,

output of lagKngr


* McsEngl.Knlgbase.knowledge-graph!⇒kbGraph,
* McsEngl.kbGraph!=knowledge-graph--knowledge-base,
* McsEngl.knowledge-graph!⇒kbGraph,
* McsEngl.lagKngr'output!⇒kbGraph,

relation-to-ontology of kbGraph

· both map conceptual-systems.

">knowledge-graph vs ontology:
Knowledge graphs and ontologies are both important tools for representing and organizing information, but they have distinct roles and purposes.

**Knowledge graphs** are structured representations of information that connect entities and their relationships in a meaningful way. They are typically used to store and manage large amounts of data, and they can be queried to answer questions and discover new insights.

**Ontologies** are formal descriptions of concepts and their relationships within a specific domain. They are used to define the meaning of terms and to ensure that information is consistent and accurate.

In simpler terms, knowledge graphs are like detailed maps of information, while ontologies are like dictionaries that define the meaning of the words on those maps.

Here is a table summarizing the key differences between knowledge graphs and ontologies:

| Feature | Knowledge Graph | Ontology |
| Purpose | Represent and organize information | Define the meaning of terms |
| Structure | Graph-based | Formal language-based |
| Focus | Relationships between entities | Concepts and their relationships |
| Use cases | Search, recommendation, knowledge discovery | Data integration, knowledge representation, reasoning |

Here are some examples of how knowledge graphs and ontologies are used:
* **Knowledge graphs** are used by search engines to provide more relevant and context-aware search results.
* **Ontologies** are used by medical systems to ensure that patient data is coded consistently and accurately.
* **Knowledge graphs** are used by social media platforms to recommend people and content to users.
* **Ontologies** are used by engineering design software to ensure that different parts of a design are compatible with each other.

In general, knowledge graphs are a more flexible and general-purpose tool, while ontologies are more specialized and formal. Knowledge graphs are well-suited for tasks that require understanding the relationships between entities, while ontologies are better suited for tasks that require precise definitions of concepts.

I hope this helps!"
[{2023-11-18 retrieved}]

* McsEngl.kbGraph'relation-to-ontology,
* McsEngl.kbOnto'relation-to--knowledge-graph,


">example of knowledge-graph:
Sure, here is an example of a simplified knowledge graph that represents information about a movie:

* **Movie Title:** The Godfather
* **Director:** Francis Ford Coppola
* **Actors:** Marlon Brando, Al Pacino, James Caan
* **Genre:** Crime, Drama
* **Release Year:** 1972
* **Awards:** Academy Award for Best Picture, Academy Award for Best Actor (Marlon Brando)

* **The Godfather is directed by Francis Ford Coppola.**
* **The Godfather stars Marlon Brando, Al Pacino, and James Caan.**
* **The Godfather is a crime and drama film.**
* **The Godfather was released in 1972.**
* **The Godfather won the Academy Award for Best Picture.**
* **Marlon Brando won the Academy Award for Best Actor for his role in The Godfather.**

This is just a simple example, and the Google Knowledge Graph is much more complex and extensive, containing information about millions of entities and relationships."
[{2023-11-18 retrieved}]

* McsEngl.kbGraph.example,


">overview of Freebase:
Freebase was a large, open-collaborative knowledge graph that was acquired by Google in 2010 and later shut down in 2016. It contained over 40 million entities and over 1 billion facts about real-world objects, people, places, and events. Freebase was structured as a graph, which allowed for easy traversal of relationships between entities. This made it a valuable resource for developers, researchers, and anyone who wanted to build applications that could understand and reason about real-world information.

**Key features of Freebase included:**
* **Large and open-source:** Freebase was one of the largest knowledge graphs in the world, and it was open-source, which meant that anyone could contribute to it.
* **Structured as a graph:** Freebase's graph structure made it easy to traverse relationships between entities.
* **Rich information about entities:** Freebase contained a wealth of information about entities, including their properties, relationships, and events.
* **API for accessing data:** Freebase provided an API that made it easy for developers to access its data.

Freebase was used in a variety of applications, including:
* **Building search engines:** Freebase was used to improve the relevance and accuracy of search results.
* **Developing natural language processing (NLP) applications:** Freebase was used to train NLP models to understand natural language.
* **Creating knowledge-based systems:** Freebase was used to build systems that could answer questions about the world.

While Freebase is no longer actively maintained, its data has been incorporated into other knowledge graphs, such as Wikidata and Google's Knowledge Graph. These knowledge graphs continue to be used to build applications that understand and reason about real-world information."
[{2023-11-18 retrieved}]

* McsEngl.Freebase-kbGraph,
* McsEngl.kbGraph.Freebase,


">overview of Google-knowledge-graph:
Sure, here is an overview of the Google Knowledge Graph:

**What is the Google Knowledge Graph?**
The Google Knowledge Graph is a massive database of information about real-world entities, such as people, places, organizations, events, things, animals, foods, abstract notions, concepts, etc. It is used to provide more informative and relevant search results in Google Search and other Google products.

**How does the Google Knowledge Graph work?**
The Google Knowledge Graph is built from a variety of sources, including public sources such as Wikipedia and Freebase, as well as data from Google's own products and services, such as Google Maps, Google Search, and Google Books. Google algorithms extract and process this information to create a structured representation of the world, which is then used to answer search queries and provide other information.

**What are the benefits of using the Google Knowledge Graph?**
The Google Knowledge Graph has a number of benefits, including:
* **Improved search results:** The Knowledge Graph provides more informative and relevant search results by understanding the relationships between entities. For example, if you search for "Leonardo da Vinci," the Knowledge Graph can show you information about his paintings, his inventions, and his life.
* **Enhanced knowledge discovery:** The Knowledge Graph can help you discover new information and connections between entities by revealing hidden patterns and relationships. For example, if you are interested in learning about the history of the United States, the Knowledge Graph can show you how different historical events are related to each other.
* **Enabling intelligent applications:** The Knowledge Graph is used to power a variety of intelligent applications, such as recommendation systems, virtual assistants, and chatbots. For example, recommendation systems use the Knowledge Graph to suggest products or content based on your preferences and relationships between items.

**How can I access the Google Knowledge Graph?**
There are a few ways to access the Google Knowledge Graph:
* **Google Search:** The Knowledge Graph is used to provide information in the knowledge panels that appear to the right of Google Search results.
* **Google Knowledge Graph API:** The Google Knowledge Graph API allows developers to access the Knowledge Graph programmatically.
* **Google Cloud Knowledge Graph:** Google Cloud Knowledge Graph is a managed service that allows businesses to create and manage their own knowledge graphs.

**What is the future of the Google Knowledge Graph?**
The Google Knowledge Graph is constantly evolving and expanding. Google is working to make the Knowledge Graph more comprehensive, more accurate, and more useful. The company is also exploring new ways to use the Knowledge Graph to power intelligent applications and improve the way people interact with information.

I hope this overview is helpful. Please let me know if you have any other questions."
[{2023-11-18 retrieved}]

"The Google Knowledge Graph is a knowledge base used by Google and its services to enhance its search engine's results with information gathered from a variety of sources. The information is presented to users in an infobox next to the search results. These infoboxes were added to Google's search engine in May 2012, starting in the United States, with international expansion by the end of the year.[1] Google has referred to these infoboxes, which appear to the right (top on mobile) of search results, as "knowledge panels".[2]
The information covered by Google's Knowledge Graph grew quickly after launch, tripling its size within seven months (covering 570 million entities and 18 billion facts[3]). By mid-2016, Google reported that it held 70 billion facts[4] and answered "roughly one-third" of the 100 billion monthly searches they handled. By May 2020, this had grown to 500 billion facts on 5 billion entities.[5]
There is no official documentation of how the Google Knowledge Graph is implemented.[6] According to Google, its information is retrieved from many sources, including the CIA World Factbook, Wikidata, and Wikipedia.[1][7] It is used to answer direct spoken questions in Google Assistant[8][9] and Google Home voice queries.[10] It has been criticized for providing answers without source attribution or citation.[11]"

* McsEngl.Google-knowledge-graph!⇒kbGkgraph,
* McsEngl.Snetoutput.Google-knowledge-graph,
* McsEngl.kbGkgraph!=Google-knowledge-graph,
* McsEngl.kbGraph.Google!⇒kbGkgraph,

language of kbGkgraph

">Google Knowledge Graph language:
The Google Knowledge Graph uses a variety of data formats and languages to represent and store information. These formats and languages are designed to be machine-readable and to allow for efficient processing and querying of the Knowledge Graph.

**Core Data Formats:**
1. **RDF (Resource Description Framework):** RDF is a standard format for representing linked data. It uses triples of subject, predicate, and object to represent relationships between entities.
2. **JSON-LD (JSON for Linked Data):** JSON-LD is an extension of JSON that incorporates RDF concepts. It allows for embedding structured data within JSON documents.
3. **Turtle (Terse RDF Triple Language):** Turtle is a more compact and human-readable format for representing RDF data. It uses a simplified syntax with keywords and abbreviations.

**Query Languages:**
1. **SPARQL (SPARQL Protocol and RDF Query Language):** SPARQL is a standard query language for RDF data. It allows for querying the Knowledge Graph using complex expressions and filters.
2. **GRDDL (GRaph Data Description Language):** GRDDL is a language for extracting RDF data from HTML documents. It allows for automatic discovery of RDF information embedded in web pages.

**Additional Languages and Tools:**
1. **** is a collaborative effort to define a common vocabulary for microdata, which is structured data embedded in HTML pages. The Google Knowledge Graph uses markup to extract information from websites.
2. **Freebase:** Freebase is a public knowledge graph developed by Google. It is one of the sources of data for the Google Knowledge Graph.
3. **Google Cloud Knowledge Graph API:** The Google Cloud Knowledge Graph API allows developers to access and query the Google Knowledge Graph programmatically.

The Google Knowledge Graph is constantly evolving, and new data formats and languages may be adopted in the future. However, the core languages and formats described above provide a solid foundation for understanding the structure and operation of the Google Knowledge Graph."
[{2023-11-18 retrieved}]

* McsEngl.kbGkgraph'language,

kbGraph.Wikidata (link)


"overview of concept-maps:
A concept map is a visual tool used to represent and organize knowledge or ideas in a structured and interconnected manner. Concept maps are graphical diagrams that consist of nodes (or concepts) and links (or relationships) between those concepts. They are often used in education, problem-solving, brainstorming, and knowledge management to help individuals or groups better understand, communicate, and navigate complex topics. Here's an overview of concept maps:

**Components of Concept Maps:**
1. **Concepts (Nodes):** Concepts are represented as nodes in a concept map. They can be words, phrases, or symbols that encapsulate specific ideas or topics. Each concept typically contains a label or description.

2. **Relationships (Links):** Relationships between concepts are represented as lines or arrows connecting the nodes. These links indicate how concepts are related or connected to one another. Relationships may include various types such as "is a part of," "causes," "leads to," "is a type of," etc.

3. **Cross-links:** In more complex concept maps, cross-links can connect concepts from different areas of the map, showing how seemingly unrelated concepts can be linked in a meaningful way.

4. **Examples and Descriptions:** Concept maps often include examples or additional information to clarify the concepts and relationships.

**Characteristics of Concept Maps:**
1. **Hierarchy:** Concept maps can have hierarchical structures with main concepts at the top and sub-concepts branching below. This hierarchy helps in organizing information from general to specific.

2. **Nonlinear Structure:** Unlike outlines or linear text, concept maps are non-linear, allowing for complex relationships and multiple connections among concepts.

3. **Visual Representation:** The visual nature of concept maps makes them effective for visual learners and for conveying complex ideas more intuitively.

4. **Dynamic:** Concept maps can evolve as knowledge grows or as more connections and relationships are discovered. They are not static and can be updated or revised.

**Uses of Concept Maps:**
1. **Education:** Concept maps are widely used in education as a tool for learning and teaching. Students create concept maps to summarize and organize their understanding of a subject, while educators use concept maps to illustrate complex topics and facilitate discussions.

2. **Problem Solving:** Concept maps can aid in problem-solving by helping individuals break down complex problems into simpler components and explore possible solutions.

3. **Knowledge Management:** In organizations, concept maps can be used to capture and represent organizational knowledge, making it easier to navigate and transfer knowledge among employees.

4. **Brainstorming:** Teams and individuals use concept maps to brainstorm ideas, concepts, and solutions. They help in generating creative ideas and understanding the relationships between them.

5. **Research and Planning:** Researchers often use concept maps to visualize research topics, hypotheses, and data relationships. They can also be used in project planning to clarify project scope and objectives.

6. **Communication:** Concept maps can serve as a communication tool for sharing complex information with others in a clear and concise manner.

Concept maps are versatile and can be adapted to a wide range of applications and contexts. They are a valuable tool for promoting critical thinking, knowledge organization, and knowledge sharing."
[{2023-10-24 retrieved}]

* McsEngl.lagCnkl.032-concept-map!⇒lagCtmp,
* McsEngl.lagCnkl.concept-map!⇒lagCtmp,
* McsEngl.lagCtmp,
* McsEngl.lagCtmp!=concept-map,
* McsEngl.lagSnet.concept-map!⇒lagCtmp,
* McsEngl.concept-map!⇒lagCtmp,

"A concept map or conceptual diagram is a diagram that depicts suggested relationships between concepts.[1] Concept maps may be used by instructional designers, engineers, technical writers, and others to organize and structure knowledge.
A concept map typically represents ideas and information as boxes or circles, which it connects with labeled arrows, often in a downward-branching hierarchical structure. The relationship between concepts can be articulated in linking phrases such as "causes", "requires", "such as" or "contributes to".[2]
The technique for visualizing these relationships among different concepts is called concept mapping. Concept maps have been used to define the ontology of computer systems, for example with the object-role modeling or Unified Modeling Language formalism."


· XML is a-markup-language that can-model conceptual-views human and machine-readable.

* McsEngl.XML!=extensible-markup-language!=lagXmlg,
* McsEngl.lagCnkl.010-XML!⇒lagXmlg,
* McsEngl.lagCnkl.XML!⇒lagXmlg,
* McsEngl.lagXmlg,
* McsEngl.lagXmlg!=extensible-markup-language,

"The Extensible Markup Language (XML) is a subset of SGML that is completely described in this document.
Its goal is to enable generic SGML to be served, received, and processed on the Web in the way that is now possible with HTML.
XML has been designed for ease of implementation and for interoperability with both SGML and HTML."
"Extensible Markup Language (XML) is a markup language that defines a set of rules for encoding documents in a format that is both human-readable and machine-readable. The World Wide Web Consortium's XML 1.0 Specification[2] of 1998[3] and several other related specifications[4]—all of them free open standards—define XML.[5]
The design goals of XML emphasize simplicity, generality, and usability across the Internet.[6] It is a textual data format with strong support via Unicode for different human languages. Although the design of XML focuses on documents, the language is widely used for the representation of arbitrary data structures[7] such as those used in web services.
Several schema systems exist to aid in the definition of XML-based languages, while programmers have developed many application programming interfaces (APIs) to aid the processing of XML data."

machine of lagXmlg

· any computer.

* McsEngl.lagXmlg'machine,

input of lagXmlg

· lagXmlg maps simple conceptual-views eg a-person[a] with some attributes of it[a].

* McsEngl.lagXmlg'input,

output of lagXmlg

· the-output is a-markup-document with Xmlelements denoting concepts or attributes of concepts.

* McsEngl.Xmldoc,
* McsEngl.lagXmlg'instance-document!⇒Xmldoc,
* McsEngl.lagXmlg'output!⇒Xmldoc,

entity of Xmldoc

"Physically, the document is composed of units called entities. An entity may refer to other entities to cause their inclusion in the document. A document begins in a "root" or document entity."

* McsEngl.Xmldoc'entity!⇒Xmlentity,

Xmlentity.root of Xmldoc

"[Definition: The document entity serves as the root of the entity tree and a starting-point for an XML processor.] This specification does not specify how the document entity is to be located by an XML processor; unlike other entities, the document entity has no name and might well appear on a processor input stream without any identification at all."

* McsEngl.Xmldoc'document-entity,
* McsEngl.Xmldocument-entity,
* McsEngl.Xmlentity.document,
* McsEngl.Xmlentity.root,

Xmlentity.parsed of Xmldoc

"Entities may be either parsed or unparsed.
[Definition: The contents of a parsed entity are referred to as its replacement text; this text is considered an integral part of the document.]"

* McsEngl.Xmlentity.parsed,

Xmlentity.unparsed of Xmldoc

"[Definition: An unparsed entity is a resource whose contents may or may not be text, and if text, may be other than XML. Each unparsed entity has an associated notation, identified by name. Beyond a requirement that an XML processor make the identifiers for the entity and notation available to the application, XML places no constraints on the contents of unparsed entities.]"

* McsEngl.Xmlentity.unparsed,

text of Xmldoc

"Definition: A parsed entity contains text, a sequence of characters, which may represent markup or character data."

* McsEngl.Xmldoc'text!⇒Xmltext,
* McsEngl.Xmltext,

character of Xmldoc

"Definition: A character is an atomic unit of text as specified by ISO/IEC 10646 [ISO/IEC 10646].
Legal characters are tab, carriage return, line feed, and the legal characters of Unicode and ISO/IEC 10646. ..Character Range
[2] Char ::= [#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] /* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. */
[2a] RestrictedChar ::= [#x1-#x8] | [#xB-#xC] | [#xE-#x1F] | [#x7F-#x84] | [#x86-#x9F]
The mechanism for encoding character code points into bit patterns may vary from entity to entity. "

* McsEngl.Xmlchar,
* McsEngl.Xmldoc'character!⇒Xmlchar,
* McsEngl.Xmltext'character!⇒Xmlchar,
* McsEngl.character//XML!⇒Xmlchar,


"S (white space) consists of one or more space (#x20) characters, carriage returns, line feeds, or tabs.
White Space
[3] S ::= (#x20 | #x9 | #xD | #xA)+
The presence of #xD in the above production is maintained purely for backward compatibility with the First Edition. As explained in 2.11 End-of-Line Handling, all #xD characters literally present in an XML document are either removed or replaced by #xA characters before any other processing is done. The only way to get a #xD character to match this production is to use a character reference in an entity value literal."

* McsEngl.Xmlchar.whitespace,

"[Definition: A Name is a token beginning with a letter or one of a few punctuation characters, and continuing with letters, digits, hyphens, underscores, colons, or full stops, together known as name characters.] Names beginning with the string "xml", or with any string which would match (('X'|'x') ('M'|'m') ('L'|'l')), are reserved for standardization in this or future versions of this specification.
The Namespaces in XML Recommendation [XML Names] assigns a meaning to names containing colon characters. Therefore, authors should not use the colon in XML names except for namespace purposes, but XML processors must accept the colon as a name character.
... Names and Tokens
[4] NameStartChar ::= ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
[4a] NameChar ::= NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
[5] Name ::= NameStartChar (NameChar)*
[6] Names ::= Name (#x20 Name)*
[7] Nmtoken ::= (NameChar)+
[8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*"

* McsEngl.Xmlname,


"Definition: An XML namespace is identified by a URI reference [RFC3986]; element and attribute names may be placed in an XML namespace using the mechanisms described in this specification."

* McsEngl.Xmlchar.namespace!⇒Xmlnamespace,
* McsEngl.Xmlnamespace,
* McsEngl.namespace//XML,


"[Definition: An expanded name is a pair consisting of a namespace name and a local name. ]
[Definition: For a name N in a namespace identified by a URI I, the namespace name is I. For a name N that is not in a namespace, the namespace name has no value. ]
[Definition: In either case the local name is N. ]
It is this combination of the universally managed URI namespace with the vocabulary's local names that is effective in avoiding name clashes."

* McsEngl.Xmlnamespace'name,
* McsEngl.namespace-name//XML,


"[Definition: An expanded name is a pair consisting of a namespace name and a local name. ]
[Definition: For a name N in a namespace identified by a URI I, the namespace name is I. For a name N that is not in a namespace, the namespace name has no value. ]
[Definition: In either case the local name is N. ]
It is this combination of the universally managed URI namespace with the vocabulary's local names that is effective in avoiding name clashes."

* McsEngl.Xmlchar.expanded-name,
* McsEngl.expanded-name//XML,


"[Definition: An expanded name is a pair consisting of a namespace name and a local name. ]
[Definition: For a name N in a namespace identified by a URI I, the namespace name is I. For a name N that is not in a namespace, the namespace name has no value. ]
[Definition: In either case the local name is N. ]
It is this combination of the universally managed URI namespace with the vocabulary's local names that is effective in avoiding name clashes."

* McsEngl.Xmlchar.local-name,
* McsEngl.local-name//XML,


"URI references can contain characters not allowed in names, and are often inconveniently long, so expanded names are not used directly to name elements and attributes in XML documents. Instead qualified names are used.
[Definition: A qualified name is a name subject to namespace interpretation. ]
In documents conforming to this specification, element and attribute names appear as qualified names. Syntactically, they are either prefixed names or unprefixed names. An attribute-based declaration syntax is provided to bind prefixes to namespace names and to bind a default namespace that applies to unprefixed element names; these declarations are scoped by the elements on which they appear so that different bindings may apply in different parts of a document. Processors conforming to this specification MUST recognize and act on these declarations and prefixes.
... In XML documents conforming to this specification, some names (constructs corresponding to the nonterminal Name) MUST be given as qualified names, defined as follows:

Qualified Name
[7] QName ::= PrefixedName | UnprefixedName
[8] PrefixedName ::= Prefix ':' LocalPart
[9] UnprefixedName ::= LocalPart
[10] Prefix ::= NCName
[11] LocalPart ::= NCName
The Prefix provides the namespace prefix part of the qualified name, and MUST be associated with a namespace URI reference in a namespace declaration. [Definition: The LocalPart provides the local part of the qualified name.]
Note that the prefix functions only as a placeholder for a namespace name. Applications SHOULD use the namespace name, not the prefix, in constructing names whose scope extends beyond the containing document.

* McsEngl.Xmlcha.qualified-name,
* McsEngl.qualified-name//XML,

markup of Xmldoc

"Definition: Markup takes the form of start-tags, end-tags, empty-element tags, entity references, character references, comments, CDATA section delimiters, document type declarations, processing instructions, XML declarations, text declarations, and any white space that is at the top level of the document entity (that is, outside the document element and not inside any other markup)."

* McsEngl.Xmldoc'markup!⇒Xmlmarkup,
* McsEngl.Xmlmarkup,


"Definition: The beginning of every non-empty XML element is marked by a start-tag."

* McsEngl.Xmldoc'start-tag,
* McsEngl.Xmldoc'tagStart,
* McsEngl.Xmlmarkup.tagStart,


"[Definition: The end of every element that begins with a start-tag must be marked by an end-tag containing a name that echoes the element's type as given in the start-tag:]
[42] ETag ::= '</' Name S? '>'
An example of an end-tag:

* McsEngl.Xmldoc'end-tag,
* McsEngl.Xmldoc'tagEnd,
* McsEngl.Xmlmarkup.tagEnd,


"[Definition: An element with no content is said to be empty.] The representation of an empty element is either a start-tag immediately followed by an end-tag, or an empty-element tag. [Definition: An empty-element tag takes a special form:]
Tags for Empty Elements
[44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' [WFC: Unique Att Spec]
Empty-element tags may be used for any element which has no content, whether or not it is declared using the keyword EMPTY. For interoperability, the empty-element tag should be used, and should only be used, for elements which are declared EMPTY.
Examples of empty elements:
<IMG align="left" src="" />

* McsEngl.Xmldoc'empty-tag,
* McsEngl.Xmldoc'tagEmpty,
* McsEngl.Xmlmarkup.tagEmpty,


"[Definition: An entity reference refers to the content of a named entity.]
[Definition: References to parsed general entities use ampersand (&) and semicolon (;) as delimiters.]
[Definition: Parameter-entity references use percent-sign (%) and semicolon (;) as delimiters.]"

* McsEngl.Xmldoc'entity-reference,
* McsEngl.Xmldoc'referenceEntity,
* McsEngl.Xmlmarkup.referenceEntity,


"[Definition: A character reference refers to a specific character in the ISO/IEC 10646 character set, for example one not directly accessible from available input devices.]"

* McsEngl.Xmldoc'character-reference,
* McsEngl.Xmldoc'referenceCharacter,
* McsEngl.Xmlmarkup.referenceCharacter,


"[Definition: Comments may appear anywhere in a document outside other markup; in addition, they may appear within the document type declaration at places allowed by the grammar. They are not part of the document's character data; an XML processor may, but need not, make it possible for an application to retrieve the text of comments. For compatibility, the string "--" (double-hyphen) must not occur within comments.] Parameter entity references must not be recognized within comments.
[15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
An example of a comment:
<!-- declarations for <head> & <body> -->
Note that the grammar does not allow a comment ending in --->. The following example is not well-formed.
<!-- B+, B, or B--->"

* McsEngl.Xmlmarkup.comment,


"Definition: CDATA sections may occur anywhere character data may occur; they are used to escape blocks of text containing characters which would otherwise be recognized as markup. CDATA sections begin with the string "<![CDATA[" and end with the string "]]>":]
CDATA Sections
[18] CDSect ::= CDStart CData CDEnd
[19] CDStart ::= '<![CDATA['
[20] CData ::= (Char* - (Char* ']]>' Char*))
[21] CDEnd ::= ']]>'
Within a CDATA section, only the CDEnd string is recognized as markup, so that left angle brackets and ampersands may occur in their literal form; they need not (and cannot) be escaped using "<" and "&". CDATA sections cannot nest.
An example of a CDATA section, in which "<greeting>" and "</greeting>" are recognized as character data, not markup:
<![CDATA[<greeting>Hello, world!</greeting>]]>"

* McsEngl.Xmldoc'CDATA-section-delimiter,
* McsEngl.Xmlmarkup.CDATA-section-delimiter,


"Definition: The XML document type declaration contains or points to markup declarations that provide a grammar for a class of documents. This grammar is known as a document type definition, or DTD. The document type declaration can point to an external subset (a special kind of external entity) containing markup declarations, or can contain the markup declarations directly in an internal subset, or can do both. The DTD for a document consists of both subsets taken together."

* McsEngl.Xmldoc'declarationDocument-type,
* McsEngl.Xmldoc'document-type-declaration,
* McsEngl.Xmlmarkup.declarationDocument-type,


· example: <?xml version="1.1"?>

* McsEngl.Xmldoc'declarationXml,
* McsEngl.Xmldoc'Xml-declaration,
* McsEngl.Xmlmarkup.declarationXml,


"External parsed entities should each begin with a text declaration.
Text Declaration
[77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
The text declaration must be provided literally, not by reference to a parsed entity. The text declaration must not appear at any position other than the beginning of an external parsed entity. The text declaration in an external parsed entity is not considered part of its replacement text."

* McsEngl.Xmldoc'declarationText,
* McsEngl.Xmldoc'text-declaration,
* McsEngl.Xmlmarkup.declarationText,


"[Definition: Processing instructions (PIs) allow documents to contain instructions for applications.]
Processing Instructions
[16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
[17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
PIs are not part of the document's character data, but must be passed through to the application. The PI begins with a target (PITarget) used to identify the application to which the instruction is directed. The target names "XML", "xml", and so on are reserved for standardization in this or future versions of this specification. The XML Notation mechanism may be used for formal declaration of PI targets. Parameter entity references must not be recognized within processing instructions."

* McsEngl.Xmldoc'processing-instruction!⇒Xmlpi,
* McsEngl.Xmlmarkup.processing-instruction!⇒Xmlpi,
* McsEngl.Xmlpi,

character-data of Xmldoc

"Definition: All text that is not markup constitutes the character data of the document."

* McsEngl.Xmldoc'character-data,

element of Xmldoc

"Definition: Each XML document contains one or more elements, the boundaries of which are either delimited by start-tags and end-tags, or, for empty elements, by an empty-element tag. Each element has a type, identified by name, sometimes called its "generic identifier" (GI), and may have a set of attribute specifications."

* McsEngl.Xmldoc'element!⇒Xmlelement,
* McsEngl.Xmlelement,
* McsEngl.element//XML,

name of Xmlelement


* McsEngl.Xmlelement'name,

attribute of Xmlelement

"Definition: The Name-AttValue pairs are referred to as the attribute specifications of the element"

* McsEngl.Xmlelement'attribute,

content of Xmlelement

"[Definition: The text between the start-tag and end-tag is called the element's content:]
Content of Elements
[43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*"

* McsEngl.Xmlelement'content,


"[Definition: There is exactly one element, called the root, or document element, no part of which appears in the content of any other element.] For all other elements, if the start-tag is in the content of another element, the end-tag is in the content of the same element. More simply stated, the elements, delimited by start- and end-tags, nest properly within each other."

* McsEngl.Xmlelement.document,
* McsEngl.Xmlelement.root,


"[Definition: As a consequence of this, for each non-root element C in the document, there is one other element P in the document such that C is in the content of P, but is not in the content of any other element that is in the content of P. P is referred to as the parent of C, and C as a child of P.]"

* McsEngl.Xmlelement.parent-of-e,


"[Definition: As a consequence of this, for each non-root element C in the document, there is one other element P in the document such that C is in the content of P, but is not in the content of any other element that is in the content of P. P is referred to as the parent of C, and C as a child of P.]"

* McsEngl.Xmlelement.child-of-e,

schema of Xmldoc

· Xmlschema is a-document that describes the-structure of an-Xmldoc expressed in a-lagCnkl.

* McsEngl.Xmldoc'schema!⇒Xmlschema,
* McsEngl.Xmlschema,

"The purpose of a schema is to define a class of XML documents, and so the term "instance document" is often used to describe an XML document that conforms to a particular schema."


"There are languages developed specifically to express XML schemas. The document type definition (DTD) language, which is native to the XML specification, is a schema language that is of relatively limited capability, but that also has other uses in XML aside from the expression of schemas. Two more expressive XML schema languages in widespread use are XML Schema (with a capital S) and RELAX NG."

* McsEngl.Xmlschema.specific,


· XML-Schema is an-Xmlschema created by W3C after DTD.

* McsEngl.XML-Schema!⇒xsd,
* McsEngl.xsd,
* McsEngl.xsd!=XML-Schema,
* McsEngl.Xmlschema.XML-Schema!⇒xsd,

XML-Schema-language of xsd

· the-language in which an-xsd is-written.
· it is an-XML-language.
"There are several different languages available for specifying an XML schema. Each language has its strengths and weaknesses.
The primary purpose of a schema language is to specify what the structure of an XML document can be. This means which elements can reside in which other elements, which attributes are and are not legal to have on a particular element, and so forth. A schema is analogous to a grammar for a language; a schema defines what the vocabulary for the language may be and what a valid "sentence" is."

* McsEngl.XML-Schema-language!⇒lagXsdl,
* McsEngl.lagXsdl,
* McsEngl.lagXsdl!=XML-Schema-language,
* McsEngl.xsd'language!⇒lagXsdl,


schema-element of xsd

· example:
<xsd:schema xmlns:xsd="">

* McsEngl.xsd'schema-element!⇒xsd:schema,
* McsEngl.xsd:schema,

element-element of xsd

· example:
<xsd:element name="street" type="xsd:string"/>

* McsEngl.xsd:element-element,

attribute-element of xsd

· example:
<xsd:attribute name="country" type="xsd:NMTOKEN" fixed="US"/>

* McsEngl.xsd:attribute-element,

complexType-element of xsd

· example:
"<xsd:complexType name="USAddress" >
   <xsd:element name="name" type="xsd:string"/>
   <xsd:element name="street" type="xsd:string"/>
   <xsd:element name="city" type="xsd:string"/>
   <xsd:element name="state" type="xsd:string"/>
   <xsd:element name="zip" type="xsd:decimal"/>
 <xsd:attribute name="country" type="xsd:NMTOKEN" fixed="US"/>

The consequence of this definition is that any element appearing in an instance whose type is declared to be USAddress (e.g. shipTo in po.xml) must consist of five elements and one attribute. These elements must be called name, street, city, state and zip as specified by the values of the declarations' name attributes, and the elements must appear in the same sequence (order) in which they are declared. The first four of these elements will each contain a string, and the fifth will contain a number. The element whose type is declared to be USAddress may appear with an attribute called country which must contain the string US.
... In XML Schema, there is a basic difference between complex types which allow elements in their content and may carry attributes, and simple types which cannot have element content and cannot carry attributes."

* McsEngl.xsd-compleType-element,

simpleType-element of xsd

· example:
<xsd:simpleType name="SKU">
 <xsd:restriction base="xsd:string">
   <xsd:pattern value="\d{3}-[A-Z]{2}"/>

"simple types which cannot have element content and cannot carry attributes."

* McsEngl.xsd:simpleType-element,



    The Purchase Order Schema, po.xsd
    <xsd:schema xmlns:xsd="">

        <xsd:documentation xml:lang="en">
         Purchase order schema for
         Copyright 2000 All rights reserved.

      <xsd:element name="purchaseOrder" type="PurchaseOrderType"/>

      <xsd:element name="comment" type="xsd:string"/>

      <xsd:complexType name="PurchaseOrderType">
          <xsd:element name="shipTo" type="USAddress"/>
          <xsd:element name="billTo" type="USAddress"/>
          <xsd:element ref="comment" minOccurs="0"/>
          <xsd:element name="items"  type="Items"/>
        <xsd:attribute name="orderDate" type="xsd:date"/>

      <xsd:complexType name="USAddress">
          <xsd:element name="name"   type="xsd:string"/>
          <xsd:element name="street" type="xsd:string"/>
          <xsd:element name="city"   type="xsd:string"/>
          <xsd:element name="state"  type="xsd:string"/>
          <xsd:element name="zip"    type="xsd:decimal"/>
        <xsd:attribute name="country" type="xsd:NMTOKEN"

      <xsd:complexType name="Items">
          <xsd:element name="item" minOccurs="0" maxOccurs="unbounded">
                <xsd:element name="productName" type="xsd:string"/>
                <xsd:element name="quantity">
                    <xsd:restriction base="xsd:positiveInteger">
                      <xsd:maxExclusive value="100"/>
                <xsd:element name="USPrice"  type="xsd:decimal"/>
                <xsd:element ref="comment"   minOccurs="0"/>
                <xsd:element name="shipDate" type="xsd:date" minOccurs="0"/>
              <xsd:attribute name="partNum" type="SKU" use="required"/>

      <!-- Stock Keeping Unit, a code for identifying products -->
      <xsd:simpleType name="SKU">
        <xsd:restriction base="xsd:string">
          <xsd:pattern value="\d{3}-[A-Z]{2}"/>


    The Purchase Order, po.xml
    <?xml version="1.0"?>
    <purchaseOrder orderDate="1999-10-20">
       <shipTo country="US">
          <name>Alice Smith</name>
          <street>123 Maple Street</street>
          <city>Mill Valley</city>
       <billTo country="US">
          <name>Robert Smith</name>
          <street>8 Oak Avenue</street>
          <city>Old Town</city>
       <comment>Hurry, my lawn is going wild</comment>
          <item partNum="872-AA">
             <comment>Confirm this is electric</comment>
          <item partNum="926-AA">
             <productName>Baby Monitor</productName>


* McsEngl.xsd.example,


· an-XmlDtd is an-Xmlschema, the-first created by W3C.
"A DTD defines the valid building blocks of an XML document.
It defines the document structure with a list of validated elements and attributes.
A DTD can be declared inline inside an XML document, or as an external reference.[1]
XML uses a subset of SGML DTD.
As of 2009, newer XML namespace-aware schema languages (such as W3C XML Schema and ISO RELAX NG) have largely superseded DTDs. A namespace-aware version of DTDs is being developed as Part 9 of ISO DSDL. DTDs persist in applications that need special publishing characters, such as the XML and HTML Character Entity References, which derive from larger sets defined as part of the ISO SGML standard effort."

* McsEngl.DTD-of-lagXmlg!⇒XmlDtd,
* McsEngl.Xmldoc'DTD!⇒XmlDtd,
* McsEngl.XmlDtd,
* McsEngl.XmlDtd!=DTD-for-XML,
* McsEngl.lagXmlg'DTD!⇒XmlDtd,


security of XmlDtd

"An XML DTD can be used to create a denial of service (DoS) attack by defining nested entities that expand exponentially, or by sending the XML parser to an external resource that never returns.[10]
For this reason, .NET Framework provides a property that allows prohibiting or skipping DTD parsing,[10] and recent versions of Microsoft Office applications (Microsoft Office 2010 and higher) refuse to open XML files that contain DTD declarations."

* McsEngl.XmlDtd'security,

evaluation of lagXmlg


* McsEngl.lagXmlg'evaluation,

relation-to-lagJson (link) of lagXmlg

relation-to-lagHtml of lagXmlg

"XML differs from HTML in three major respects:
1. Information providers can define new tag and attribute names at will.
2. Document structures can be nested to any level of complexity.
3. Any XML document can contain an optional description of its grammar for use by applications that need to perform structural validation.

* McsEngl.lagXmlg'relation-to-HTML,
* McsEngl.lagHtml'relation-to-XML,

tool of lagXmlg


* McsEngl.lagXmlg'tool,

info-resource of lagXmlg

*, a-schema-language for Xmlg,

* McsEngl.lagXmlg'Infrsc,

specification of lagXmlg

* Extensible Markup Language (XML) 1.1 (Second Edition), W3C Recommendation 16 August 2006, edited in place 29 September 2006,,
* Namespaces in XML 1.0 (Third Edition), W3C Recommendation 8 December 2009,,
* XML Schema Part 0: Primer Second Edition, W3C Recommendation 28 October 2004,,
* W3C XML Schema Definition Language (XSD) 1.1 Part 1: Structures, W3C Recommendation 5 April 2012,,
* W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes, W3C Recommendation 5 April 2012,,

* McsEngl.Xmlspec,
* McsEngl.lagXmlg'specification!⇒Xmlspec,

DOING of lagXmlg

* parsing,
* validating,

* McsEngl.lagXmlg'doing,

validating of lagXmlg

"The process of checking to see if a XML document conforms to a schema is called validation, which is separate from XML's core concept of syntactic well-formedness. All XML documents must be well-formed, but it is not required that a document be valid unless the XML parser is "validating", in which case the document is also checked for conformance with its associated schema. DTD-validating parsers are most common, but some support XML Schema or RELAX NG as well.
Validation of an instance document against a schema can be regarded as a conceptually separate operation from XML parsing. In practice, however, many schema validators are integrated with an XML parser."

* McsEngl.lagXmlg'validating,

evoluting of lagXmlg

"XSD 1.1 became a W3C Recommendation in April 2012, which means it is an approved W3C specification."

"XML Schema, published as a W3C recommendation in May 2001,[2] is one of several XML schema languages. It was the first separate schema language for XML to achieve Recommendation status by the W3C. Because of confusion between XML Schema as a specific W3C specification, and the use of the same term to describe schema languages in general, some parts of the user community referred to this language as WXS, an initialism for W3C XML Schema, while others referred to it as XSD, an initialism for XML Schema Definition.[3][4] In Version 1.1 the W3C has chosen to adopt XSD as the preferred name, and that is the name used in this article."
* McsEngl.{lagCnkl'2001-05}-XML-Schema,

"XML was developed by an XML Working Group (originally known as the SGML Editorial Review Board) formed under the auspices of the World Wide Web Consortium (W3C) in 1996. It was chaired by Jon Bosak of Sun Microsystems with the active participation of an XML Special Interest Group (previously known as the SGML Working Group) also organized by the W3C. The membership of the XML Working Group is given in an appendix. Dan Connolly served as the Working Group's contact with the W3C."
* McsEngl.{lagCnkl'1996}-XML-creation,

* McsEngl.evoluting-of-lagXmlg,
* McsEngl.lagXmlg'evoluting,



* McsEngl.lagXmlg.specific,



"overview of symbolic-language:
A symbolic language is a type of programming language that operates on symbols and expressions rather than just numeric values or low-level operations. It is used for symbolic computation, which involves manipulating symbols and performing operations on them to solve mathematical, logical, or abstract problems. Here's an overview of symbolic languages:

1. **Symbolic Computation:** Symbolic languages are designed for symbolic computation, which means they work with abstract entities, such as variables, functions, and mathematical expressions, rather than specific numeric values. This enables them to perform operations like simplification, differentiation, and integration symbolically.

2. **Mathematical Manipulation:** Symbolic languages excel at performing mathematical operations symbolically. They can handle algebraic expressions, solve equations, perform calculus, and work with matrices, vectors, and tensors in a symbolic manner. This is particularly useful in scientific and engineering applications.

3. **Pattern Matching:** Symbolic languages often include powerful pattern-matching capabilities. They can search for and manipulate subexpressions that match specific patterns within larger symbolic expressions. Pattern matching is essential for symbolic manipulation and symbolic reasoning.

4. **Logic and Theorem Proving:** Symbolic languages are used in symbolic logic and automated theorem proving. They can manipulate logical statements, evaluate truth values, and derive logical conclusions based on formal rules.

5. **Computer Algebra Systems (CAS):** Many symbolic languages are the basis for Computer Algebra Systems (CAS). These systems are extensively used in mathematics, science, and engineering for performing algebraic and calculus operations. Mathematica, Maple, and Maxima are examples of CAS built on symbolic languages.

6. **Artificial Intelligence:** Symbolic languages have been used in artificial intelligence and expert systems for representing knowledge in a symbolic form. They can be used for rule-based reasoning, knowledge representation, and natural language understanding.

7. **Functional and Declarative Programming:** Symbolic languages are often designed in a functional or declarative programming style, where the focus is on specifying what needs to be done rather than explicitly detailing how to do it. This can make code more expressive and easier to understand.

8. **Education:** Symbolic languages are used in educational settings for teaching mathematical concepts, computer science principles, and logical reasoning. Their symbolic nature allows students to work with abstract concepts in a concrete way.

9. **Examples:** Some symbolic languages and systems include Wolfram Language (used in Mathematica and Wolfram Alpha), Maple, Maxima, Lisp (in particular, Common Lisp), and Prolog. Each of these has its own strengths and areas of application.

Symbolic languages are particularly valuable in fields where mathematical and logical reasoning is essential, such as mathematics, physics, engineering, computer science, and artificial intelligence. They enable users to work with abstract concepts and derive solutions in a more human-readable and intuitive manner than traditional imperative languages that focus on low-level operations and numeric values."
[{2023-10-22 retrieved}]

* McsEngl.lagCnkl.040-symbolic,
* McsEngl.lagCnkl.symbolic,
* McsEngl.symbolic-language,


this webpage was-visited times since {2021-01-01}

page-wholepath: / worldviewSngo / dirTchInf / lagCnkl

· this page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
· clicking on the-green-BAR of a-page you have access to the-global--locator-names of my-site.
· use the-prefix 'lagCnkl' for sensorial-concepts related to current concept 'knowledge-representation-language'.
· TYPE CTRL+F "McsLag4.words-of-concept's-name", to go to the-LOCATION of the-concept.
· a-preview of the-description of a-global-name makes reading fast.

• author: Kaseluris.Nikos.1959
• email:
• edit on github:,
• comments on Disqus,
• twitter: @synagonism,

• version.last.dynamic: McsTchInf000007.last.html,
• version.1-0-0.2021-04-09: (0-51) ../../dirMiwMcs/dirTchInf/filMcsLagCnpt.1-0-0.2021-04-09.html,
• filMcsLknlg.0-1-0.2021-01-01.last.html: draft creation,

support (link)