From PKC
Jump to navigation Jump to search


A Logic Model is capturing the logic or causal relations in a project of interest. All projects in PKC will be modeled using Logic model, and will be universally managed in a consistent namespace with a common global clock in the form of entropy pool. On the highest level, a Logic model has seven top level keys, they are Context, Goal, Success criteria, Inputs, Process, Outputs, and a set of Boundary conditions. It is also useful to know the meaning of logic through the book called:From Frege to Godel[1].


The goal of using a logic model to represent projects is to offer a unifying construct[2] that captures the common properties in project management. This will help reuse and apply experience and insights into project management across the widest range of applications possible.

Success criteria

A good Logic model has a common set of success criteria. The three common properties in projects are:

  1. Soundness: A sound project should be able to demonstrate/prove its internal logical consistency.
  2. Precision: All activities and resources in a project are accounted for in precise measures.
  3. Terminable: A project should be able to reach a concluding state.


This is an instrument for one to quickly organize thoughts and create a Design Contract with the rest of the world. It can be considered as being the Monad of functional programming and in mathematical logic/Category Theory. Logic Model can be thought of a data structure that captures the different facets of a morphism, which is a kind of universal component in algebra, functional programming, and in topology. A Logic Model is the Monadic design pattern for all of the above applications. It provides the idealized data structure to approximate and standardize all the abstract structures mentioned before.


To deliver outputs from inputs, the intermediary is the process. It can also be considered as an executable function, that must satisfy the soundness, precision, terminable conditions. Moreover, it can be encoded into a function shown as follows:

Process Implementation

A process can be analogously represented as an action or a task in daily life. Computationally, it can be abstractly thought of as a module that defines required inputs and outputs while performing the actual job. An example of such module can be found in the implementation of Ansible automation tool.

An example of Logic Model in a PKC

Logic Model (Meta Logic Model) Template:LogicModel Lua error: Internal error: The interpreter exited with status 126.
Abstract Specification
Context A descriptive statement specifying the spatial and temporal context of the event or project at hand.
Goal Write an imperative statement to describe what is to be accomplished given the context.
Success Criteria A conditional statement that can be composed of multiple conditions and collectively judged to determine the logical status or degree of success on the outputs of the expected execution process.
Concrete Implementation
Given Inputs When Process is executed... Then, we get Outputs
A set of ideally hyperlinked resources that were to be employed in the above mentioned process.

An organized set of actions or sub-processes that takes inputs and transforms them into outputs. A list of promises that were to be created through the process. As the promises get fulfilled or rejected, they can be checked dynamics through their respective hyperlinks.
Boundary/Safety Conditions of Meta Logic Model
The boundary condition of a logic model should include at least three things:
  1. A log of previous execution of similar or exactly the same Logic Model.
  2. A set of statements that illustrates what could affect the validity of the overall project.
  3. A reference for the runtime environment, or the public registry of events that relates to this Logic Model.


The syntax for filling up the Template is as two parts. The top part, surrounded by a blue dashline, is the abstract specification of a function. Describing what it is. The bottom part, surrounded by a red dashline, is the concrete implementation, revealing the resources and strategies to realize the cause-effect linkage between the abstraction specification with the concrete implementation and execution. The two parts, top and bottom of a Logic Model is shown below: (The blue part represents the abstraction specification, or the signature of a function. The red part represents the concrete implementation, which can be considered as the body of a function. Then, all techniques for functional composition can be applied to Logic Model, and henceforth, applied to anything that Logic Model represents.

Boundary Conditions

All projects should have limiting boundaries. As projects of the same time accumulate operational data, it is more likely to identify systematic limitations and can be explicitly stated. It is similar to the notion of exception capture in modern programming languages.

Logic Model ([[{{{name}}}]]) Template:LogicModel Lua error: Internal error: The interpreter exited with status 126.
Abstract Specification
[[{{{name}}}/Context|Context]] {{:{{{name}}}/Context}}
[[{{{name}}}/Goal|Goal]] {{:{{{name}}}/Goal}}
[[{{{name}}}/Criteria|Success Criteria]] {{:{{{name}}}/Criteria}}
Concrete Implementation
Given [[{{{name}}}/Input|Inputs]] When [[{{{name}}}/Process|Process]] is executed... Then, we get [[{{{name}}}/Output|Outputs]]
{{:{{{name}}}/Input}} {{:{{{name}}}/Process}} {{:{{{name}}}/Output}}
Boundary/Safety Conditions of [[{{{name}}}/Boundary|{{{name}}}]]
  1. Lua error: Internal error: The interpreter exited with status 126.
  2. Lua error: Internal error: The interpreter exited with status 126.