Write up on Discrete Mathematics in an educational Curriculum for grade school and high school students (Part 1 & Part 2)

 
Literature Review
1.1 Discrete Mathematics used for Computer Science as a Fundamental basics to learn Algorithms
The Need for Computer Science
This is largely based on how exposed students are to computational thinking and computer science concepts. Additionally, educating students in computer science is beneficial for all students. With the digital age rising, there is a need to develop logical thinking and problem-solving which are all a part of learning computer science.
Computer Science Standards and Model Curriculum give students experiences that help them discover and take part in a world continually influenced by technology and to understand the role of computing
What is Discrete Mathematics?
Discrete Mathematics is an area of mathematics that most closely connects with the field of computer science. It is the study of mathematical structures that are countable or otherwise distinct and separable (as opposed to continuous quantities like in algebra or calculus).
What Is Discrete Mathematics?
Discrete Mathematics is a rapidly growing and increasingly used area of mathematics, with many practical and relevant applications.
• Because it is grounded in real-world problems, discrete mathematics lends itself easily to implementing the recommendations fo the National Council of Teachers of Mathematics (NCTM) standards. (The recently published Standards and Principles for School Mathematics notes that “As an active branch of contemporary mathematics that is widely used in business and industry, discrete mathematics should be an integral part of the school mathematics curriculum.”)
• Because many discrete math problems are simply stated and have few mathematical prerequisites, they can be introduced at all grade levels, even with children who are not yet fluent readers.
Discrete mathematics will make math concepts come alive for your students. It’s an excellent tool for improving reasoning and problem-solving skills, and is appropriate for students at all levels and of all abilities. Teachers have found that discrete mathematics offers a way of motivating unmotivated students while challenging talented students at the same time.
Because many discrete math problems are simply stated and have few mathematical prerequisites, they can be easily be introduced at the middle school grade level.
1.2 How Discrete Mathematics Can Help Students
The National Council of Teachers of Mathematics (NCTM) recommends that discrete mathematics be implemented into the curriculum as early as the seventh 4 grade, because it benefits students and helps maintain their interest in mathematics [5, p. 362]. But beyond what the NCTM recommends, is discrete mathematics really advantageous to students, and if so, why? Discussed below are some of the reasons. First, it keeps students interested in mathematics. It helps entice them to regularly attend and participate in class. When students are interested in the material, it is easier for them to learn and stay focused when presented with tough, complex problems. While solving problems in discrete mathematics can be complicated, the problems themselves can be easily understood. The students, therefore, are able to understand and work the problems, which gives them a much needed confidence [12, pp. 35-36].
 Many students are lost from mathematics forever during high school. Discrete mathematics is a great way to help these students stay interested and involved in mathematics. Second, discrete mathematics benefits students by allowing them to see the connections between the mathematics they are studying and the real world. “For example, we might be able to convince our students that calculus can be used to help civil engineers build better bridges, but the students still might not see how it really works. But in graph theory [and other areas of discrete mathematics], we can explain the applications, the students can see how they work, and they can actually see real problems” [7, p. 94]. Teachers need to help students dismiss the idea that there is nothing new left to discover in mathematics and help them to look beyond basic arithmetic computation.
 Discrete mathematics is the mathematical foundation of computer science and is “used extensively in business, industry, and government. For example, difference equations are an essential mathematical tool for high-technology engineering firms, and matrices are indispensable for computer graphics” [4, p. 75].
 Another benefit of discrete mathematics is that it enriches the traditional curriculum. It places more emphasis on teaching students to think mathematically and less emphasis on certain computational skills [1, p. 83]. Discrete mathematics lends itself to group work more easily than does traditional mathematics. It is also helpful to teachers because it gives them a new way of teaching elements in the curriculum, which may make the traditional concepts easier to teach and learn.
By using discrete mathematics to teach already existing elements in the curriculum, it can help to change the way students view mathematics altogether. Below are some of the ways that discrete mathematics complements topics already in the traditional secondary-school curriculum: · Algebraic skills are needed and reinforced throughout discrete mathematics. · In geometry, graph theory can be used to enrich the study of polygons and polyhedral. · Difference equations give use to the fascinating new geometry of fractals [4, p. 75]. The NCTM does not provide teachers with detailed guidelines. They only provide a set of goals and topics to cover in high school for discrete mathematics. Therefore, it is up to each individual teacher, or the mathematics department within each school, to decide how these topics should be implemented.

Unfortunately, many teachers are unfamiliar, and even uncomfortable, with discrete mathematics. Thus, it can be difficult for them to know how to incorporate these topics into the curriculum. Because discrete mathematics can be used to teach traditional elements in the curriculum, these topics can be covered in different ways throughout the school year, without having to set aside extra time to cover them. 6 While the implementation of discrete mathematics into the curriculum is not discussed here in detail, many references cited in this thesis give numerous ideas on how to do so. Some also give sample lessons and projects for different skill levels. Some excellent resources are: · DIMACS Series in Discrete Mathematics and Theoretical Computer Science 36 (eds. J.G. Rosenstein, D.S. Franzblau, and F.S. Roberts), American Mathematical Society; 1997. · Discrete Mathematics Across the Curriculum, K–12 (eds. M.J. Kenney, and C.R. Hirsch), NCTM, Inc, Reston, Virginia; 1991. · Mathematics Teacher, a monthly journal magazine.
https://repository.lsu.edu

These political battles over the mathematics curriculum resulted in discrete mathematics largely being ignored in these countries. Of the discrete mathematics topics specifed above, very few are part of the standard curriculum in most of the countries we are familiar with. Through personal communication, it appears that:
Combinatorics is included in the secondary curriculum of several countries, including Spain, US, England, Germany, Hungary, Brazil, Israel.
Connecting recursive patterns and sequences with algebraic formulas is taught, to some degree, in Spain, Germany, and the United States.
• Graph theory is included in Italy and some isolated state curriculum in the US. In England, students focusing on mathematics can take a special track in which they have extensive exposure to discrete mathematics. In many countries, it appears that the opportunities for dealing with discrete mathematics in schools, especially when it goes beyond combinatorics, are often only seen on the level of optional recreational mathematics (Colipan & Liendo, 2022; Gravier & OuvrierBufet, 2022; Greefrath et al., 2022). We wonder if one contributing issue for the lack of discrete topics taught in the schools may be that the term discrete mathematics’ is not well understood. Perhaps, each of the discrete topics mentioned above should be considered individually. For example, fair division algorithms and economic game theory are almost self-explanatory. While combinatorics sounds complicated, counting is clearly important. Instead of using the termgraph theory’ which may be misleading to some, we could talk about vertex-edge graphs or networks, which most people are familiar with. Iteration can be described in terms of simple recursive situations, such as repeatedly folding a piece of paper or compounding of interest, along with its accessibility through the use of spreadsheets. Therefore, it might be more productive to talk about the individual discrete topics than the discipline as a whole. This is also intended to describe the mentioned topic areas of discrete mathematics for school more clearly once again. We therefore shortly go into a little more detail on the most common discrete topics and how they may support mathematical competencies.



1.3  Potential benefits of discrete mathematics topics for mathematics education
We see the potential benefits of teaching discrete mathematical topics in three broad areas, and some of these benefits have been highlighted in existing literature. The first potential benefit is offered by the content, which is accessible and offers interesting and relevant topics for teaching and learning (Anderson et al., 2004; DeBellis & Rosenstein, 2004).
Potential benefits of discrete mathematics topics for mathematics education
The second potential benefit is the learning of mathematics and the acquisition of general mathematical competencies (Coenen et al., 2018; Vorhölter et al., 2019) including afect (Goldin, 2018) that influences the learning of mathematics and the third potential is the relevance of discrete mathematics for living in the modern world (Hart & Martin, 2018; Rosenstein, 2007). In this section, we will discuss general benefts and in Sect. 6, the benefts resulting from specifc discrete mathematics topics.
Accessible topics for teaching and learning As early as the end of the 1980s, there were calls to integrate discrete mathematics into teaching, not only in higher education but also in schools (Dolgos, 1990). Advocates of discrete mathematics have noted that problems in discrete mathematics are relatively accessible, in the sense that a student may be able to understand what a problem is asking or can explore a situation without needing a lot of prior mathematical experience (Anderson et al., 2004; Devaney, 2018; Ferrarello & Mammana, 2018; Rosenstein, 2007). This is often because the problems themselves do not require knowledge of technical definitions or specific mathematical knowledge, and students can exemplify and explore objects.
The discrete nature of the objects would seem to lend itself to this accessibility. This accessibility of discrete mathematics is something that seems to be agreed upon by many mathematicians, mathematics educators and mathematics education researchers, and it is often used as an argument for the importance of the inclusion of discrete mathematics in curriculum (Anderson et al., 2004; Burghes, 1995; Dolgos, 1990; Hart & Martin, 2018). While we note that this is an aspect of discrete mathematics that would benefit from more systematic study and research, this accessibility has come through in some research studies, but not as an explicit focus of the study. Some of the research on the teaching and learning of discrete mathematics with younger students highlights not only the accessibility of topics but that this accessibility can help students make sense of the current curriculum.
 For example, iterative problems and difference equations can help students learn algebra (Amit & Neria, 2008; Blanton & Kaput, 2005; Carraher et al., 2008; Radford, 2008; Rivera & Becker, 2008; Sandefur et al., 2018; Steele, 2008; Yeap & Kaur, 2008). Even very young students can reason about combinatorial problems in meaningful ways (de Beer et al., 2015; Maher et al., 2011). English (1991, 1993) reports on young children’s strategies as they engage with combinatorial problems. As another example, students can naturally `invent’ graph theory to solve a problem (Ferrarello & Mammana, 2018; Greefrath et al., 2022; van den Heuvel & Krabbendam, 1991). We can only wonder how much better would the students’ work be if they already knew some graph theory or had previous experience with counting or recursive problems?

For many topics in discrete mathematics, students ranging from young children to undergraduate students can be posed similar questions and have a reasonable chance at investigating the problem at their different levels. This results in self differentiating tasks that allow individual approaches to the problem (Ostkirchen & Greefrath, 2022). For example, how many 2-color towers can I make of height 5, can be extended to more complicated problems for older students by increasing the number of colors and the height of the tower. Maher et al. (2011) describe the use of combinatorial problems in such contexts among students in a longitudinal study. Students as young as the third grade can investigate recursive structures they build with toothpicks and stickers while high school students can develop recursive models of bacteria growth and the spread of epidemics, which is a simplified version of models studied by epidemiologists (Radford, 2008; Sandefur & Manaster, 2022; Yeap & Kaur, 2008).
https://link.springer.com/article/10.1007/s11858-022-01399-7
Chapter 2:
Write up on Discrete Mathematics Logic, Tree, and Lambda Equations could be utilized in Highschool Computer Science Curriculum
Discrete Mathematics
2.1
The key aspect to rooted trees — which is both their greatest advantage and greatest limitation — is that every node has one and only one path to the root. This behavior is inherited from free trees: as we noted, every node has only one path to every other.
Trees have a myriad of applications. Think of the files and folders on your hard drive: at the top is the root of the filesystem (perhaps “/” on Linux/Mac or “C:\\” on Windows) and underneath that are named folders. Each folder can contain files as well as other named folders, and so on down the hierarchy. The result is that each file has one, and only one, distinct path to it from the top of the filesystem. The file can be stored, and later retrieved, in exactly one way.
An “org chart” is like this: the CEO is at the top, then underneath her are the VP’s, the Directors, the Managers, and finally the rank-and-file employees. So is a military organization: the Commander in Chief directs generals, who command colonels, who command majors, who command captains, who command lieutenants, who command sergeants, who command privates.
The human body is even a rooted tree of sorts: it contains skeletal, cardiovascular, digestive, and other systems, each of which is comprised of organs, then tissues, then cells, molecules, and atoms. In fact, anything that has this sort of part-whole containment hierarchy is just asking to be represented as a tree.
In computer programming, the applications are too numerous to name. Compilers scan code and build a “parse tree” of its underlying meaning. HTML is a way of structuring plain text into a tree-like hierarchy of displayable elements. AI chess programs build trees representing their possible future moves and their opponent’s probable responses, in order to “see many moves ahead” and evaluate their best options. Object-oriented designs involve “inheritance hierarchies” of classes, each one specialized from a specific other. Etc. Other than a simple sequence (like an array), trees are probably the most common data structure in all of computer science.
Rooted tree terminology
root.
Figure 2-1

in our example. Note that unlike trees in the real world, computer science trees have their root at the top and grow down. Every tree has a root except the empty tree, which is the “tree” that has no nodes at all in it. (It’s kind of weird thinking of “nothing” as a tree, but it’s kind of like the empty set ∅∅, which is still a set.)
parent.
Every node except the root has one parent: the node immediately above it. D’s parent is C, C’s parent is B, F’s parent is A, and A has no parent.
child.
Some nodes have children, which are nodes connected directly below it. A’s children are F and B, C’s are D and E, B’s only child is C, and E has no children.
sibling.
A node with the same parent. E’s sibling is D, B’s is F, and none of the other nodes have siblings.
ancestor.
Your parent, grandparent, great-grandparent, etc., all the way back to the root. B’s only ancestor is A, while E’s ancestors are C, B, and A. Note that F is not C’s ancestor, even though it’s above it on the diagram: there’s no connection from C to F, except back through the root (which doesn’t count).
descendent.
Your children, grandchildren, great-grandchildren, etc., all the way the leaves. B’s descendents are C, D and E, while A’s are F, B, C, D, and E.
leaf.
A node with no children. F, D, and E are leaves. Note that in a (very) small tree, the root could itself be a leaf.
internal node.
Any node that’s not a leaf. A, B, and C are the internal nodes in our example.
depth (of a node).
A node’s depth is the distance (in number of nodes) from it to the root. The root itself has depth zero. In our example, B is of depth 1, E is of depth 3, and A is of depth 0.
height (of a tree).
A rooted tree’s height is the maximum depth of any of its nodes; i.e., the maximum distance from the root to any node. Our example has a height of 3, since the “deepest” nodes are D and E, each with a depth of 3. A tree with just one node is considered to have a height of 0. Bizarrely, but to be consistent, we’ll say that the empty tree has height -1! Strange, but what else could it be? To say it has height 0 seems inconsistent with a one-node tree also having height 0. At any rate, this won’t come up much.
level.
All the nodes with the same depth are considered on the same “level.” B and F are on level 1, and D and E are on level 3. Nodes on the same level are not necessarily siblings. If F had a child named G in the example diagram, then G and C would be on the same level (2), but would not be siblings because they have different parents. (We might call them “cousins” to continue the family analogy.)
subtree.
Finally, much of what gives trees their expressive power is their recursive nature. This means that a tree is made up of other (smaller) trees. Consider our example. It is a tree with a root of A. But the two children of A are each trees in their own right! F itself is a tree with only one node. B and its descendents make another tree with four nodes. We consider these two trees to be subtrees of the original tree. The notion of “root” shifts somewhat as we consider subtrees — A is the root of the original tree, but B is the root of the second subtree. When we consider B’s children, we see that there is yet another subtree, which is rooted at C. And so on. It’s easy to see that any subtree fulfills all the properties of trees, and so everything we’ve said above applies also to it.
Binary trees (BT’s)
The nodes in a rooted tree can have any number of children. There’s a special type of rooted tree, though, called a binary tree which we restrict by simply saying that each node can have at most two children. Furthermore, we’ll label each of these two children as the “left child” and “right child.” (Note that a particular node might well have only a left child, or only a right child, but it’s still important to know which direction that child is.)
The left half of is a binary tree, but the right half is not (C has three children). A larger binary tree (of height 4) is shown in  .
Traversing binary trees
There were two ways of traversing a graph: breadth-first, and depth-first. Curiously, there are three ways of traversing a tree: pre-order, post-order, and in-order. All three begin at the root, and all three consider each of the root’s children as subtrees. The difference is in the order of visitation.
Figure 2-2
The node at the top of the tree, which is A

Rules in Prolog
Using rules, we can build a relationships among facts.
% Define what a mother, father, and a grandparent is
mother(M, C) :- parent(M, C), female(M).
father(F, C) :- parent(F, C), male(F).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).
The rule named mother defines the meaning of the mother relationship: If M is a parent of C, and if M is female, then M is a mother.
Similarly, the father rule defines the meaning of the father relationship: If F is a parent of C, and if F is male, then F is a father.
Lastly, the grandparent rule defines the meaning of the grandparent relationship: if X is a parent of Y, and Y is a parent of Z, then X is a grandparent of Z.
Rules in Prolog
Using rules, we can build a relationships among facts.
% Define what a mother, father, and a grandparent is
mother(M, C) :- parent(M, C), female(M).
father(F, C) :- parent(F, C), male(F).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).
The rule named mother defines the meaning of the mother relationship: If M is a parent of C, and if M is female, then M is a mother.
Similarly, the father rule defines the meaning of the father relationship: If F is a parent of C, and if F is male, then F is a father.
Lastly, the grandparent rule defines the meaning of the grandparent relationship: if X is a parent of Y, and Y is a parent of Z, then X is a grandparent of Z.
                                                Logical Programming
Logic is the discipline concerned with unassailably valid reasoning. By valid we mean that if we start with true statements and from them deduce new statements, following the given logical laws of deduction, we will always end up with new statements that are also true. Logics are thus systems of symbols and rules for manipulating them that have the property that syntactic deduction, involving mechanical manipulation of strings, is always a semantically valid operation, involving the truths of derived statements.
There is not just one logic. There are many. First-order predicate logic with equality is central to everyday mathematics. Propositional logic is equivalent to the language of Boolean expressions as found in conditional expressions in most programming languages. Temporal logics provide ways to reason about what statements remain true in evolving worlds. Dependent type theory is a logic, a richer form of predicate logic, in which propositions are formalized as types and proofs are essentially programs and data structures written in pure, typed, functional programming languages, and so can be type checked for correctness.
Logic is a pillar of computer science. It has been said that logic is to computer science as calculus is to natural science and engineering. As scientists and engineers use everyday mathematics to represent and reason about properties of physical things, so computer scientists use various logical languages to specify and reason about properties of programs, algorithms, the states of programs as they execute, problems to be solved by algorithms, and even about the real world in which software is meant to operate.
Propositional logic , essentially the language of Boolean expressions, is ubiquitous in programming. First-order predicate logic is widely used to reason about many issues that arise in computer science, from the complexity of algorithms to the correctness of programs. Hoare logic is a specialized extension of first-order predicate logic that is especially well suited to specifying how programs must behave and for showing that they do behave according to given logical specifications. Dependent type theory is the logic of modern proof assistant tools, including Lean (as well as Coq and Agda), which we will use in this class.
Dependent type theory and the tools that support it now play important roles in both the development of programming languages and in the production of trustworthy software. In lieu of testing of a given computer program to see if it works correctly on some inputs, one proves that it works correctly on all possible inputs. A tool then checks such proofs for correctness. Mathematicians are increasingly interested in the possibilities for automated checking of complex proofs as well.
At the heart of logic are the concepts of propositions and proofs. A proposition is an expression that we interpret as making a claim that some particular state of affairs holds in some particular domain of discourse (some world of interest). A proof is a compelling argument, in a precise form, that shows beyond any doubt that such a proposition is true. The existence of a valid proof of a proposition shows that it is true. In mathematical logic, the arbiter of truth is the existence of a proof. Proof implies truth; truth demands proof.
This first section of this course, on logic, provides a rigorous survey of forms of propositions and the construction and use of corresponding proofs in the language of predicate logic. You will learn how to write propositions in predicate logic, and how to both construct and use proofs of them in a logical reasoning system called natural deduction. As you will also quickly see, natural deduction is essentially a form of computation in a typed, pure functional programming language in which all programs terminate (there can be no infinite loops). To learn logic in this style is thus also learn a very important style of programming: functional programming. You will learn to compute with propositions and proofs.
 propositions need not be a true statement. Propositions only need to be declarative. Their truth value may be true or false. However, all propositions must have a particular truth value. The statement cannot be both true and false. The statement must be able to be interpreted as true or false.
From the previous definition and examples, propositions are therefore not questions, general statements, demands, or hypotheses. Propositions do not have any variables, quantifiers, or parameters (e.g. the words “some” or “any” typically do not appear). Consider now a few non-examples.
Examples of statements that are not propositions
Do you have a dog?
Let’s go!
Some coffee mug with a mermaid on it.
x+2=3
y=x2−1
Checkpoint
Are each of these propositions?
I am a dolphin.
Supercalifragilisticexpialidocious.
Jupiter is the 5th planet from the sun.
On Thursdays, van Gogh painted landscapes.
11+56∗3−819=9
Solution
Constructing Propositions
An entire proposition is often denoted by a single propositional variable. Propositional variables are typically among p,q,r,s,t,….
Using propositional variables
p:= “The sky is blue”
q:= “The sun rises from the west”
We also denote truth values in particular ways. “True” may be denoted by T. “False” may be denoted by F. When a proposition (or proposition variable) is known to always be true, we can replace it by T. When a proposition (or proposition variable) is known to always be false, we can replace it by F.
Connectives
We can combine propositions (and propositional variables) into compound propositions or propositional formulas. This is akin to compound sentences and other logical connectives in natural language.
In propositional logic, we have 5 main connectives. Each connective has a corresponding meaning in natural language as we will soon see.
Negation: ¬
Conjunction: ∧
Disjunction: ∨
Implication: →
Biconditional: ↔
Logical connectives are like arithmetic operators (+,−,×,÷).
Negation
The negation of a proposition results in a proposition with the opposite truth value. It is akin to adding “not” into a sentence, or starting a sentence with “it is not that case that…”.
Given a proposition p its negation is ¬p and has the following truth values.
Table 1.1 Negation truth table
p
¬p
F
T
T
F
Negation
Let p:= “the sky is blue”.
¬p is “the sky is not blue” or “it is not the case that the sky is blue”.
Let q:= “2+2=5”.
¬q is “2+2≠5.
Notice in these examples that negation does not necessarily make a proposition false. Rather, it makes the proposition have the opposite truth value.
Conjunction
The conjunction of two propositions is the logical “and” of the two propositions. The conjunction of two proposition is only true if both the propositions are individually true, otherwise the conjunction is false.
Given proposition p and q their conjunction is denoted p∧q and has the following truth values.
Table 1.2 Conjunction truth table
p
q
p∧q
F
F
F
F
T
F
T
F
F
T
T
T
Conjunction
Let p be “birds lay eggs” and q be “my eyes are blue”. p∧q is then “birds lay eggs and my eyes are blue”.
Disjunction
The disjunction of two propositions is the “or” of the two propositions. The disjunction is true if at least one of the propositions is individually true, otherwise the disjunction is false.
Given proposition p and q their disjunction is denoted p∨q and has the following truth values.
Table 1.3 Disjunction truth table
p
q
p∨q
F
F
F
F
T
T
T
F
T
T
T
T
Disjunction
Let p be “it is raining” and q be “I am wearing sunglasses”. p∨q is then “it is raining or I am wearing sunglasses”.
Notice that in this previous example, it is may be true that it is both raining and that I am wearing sunglasses. While that may be silly, p∨q is still true! In logic, we only require that at least one of the propositions in a disjunction is true. That means both are allowed to simultaneously be true.
Caution
In natural language, “or” is often interpreted as an exclusive or.
Language “or”
“You can have a cookie or a piece of cake.” Most people assume that this means you can have a cookie or a piece of cake, but not both.
In logic, “or” is not exclusive. You can have a cookie, a piece of cake, or both!
If you want logical exclusive or, we use the symbol ⊕. However, we will not use that in this course.

Checkpoint
What is the truth value of these compound propositions?
“The earth is round and the sky is blue.”
“Dogs or cats make great pets.”
“It is 20∘ Celsius outside and it is snowing.”
“Lemons are purple or grass is green”
Solution

Implication
Implication is one of the most challenging connectives to understand. Yet it is arguably the most important for creating logical arguments).
An implication is a conditional statement. For two propositions p and q, p→q is an implication which is read “if p, then q”. You can also say “p implies q”.
Implication
Let p be “it is raining” and q be “the ground is wet”. p→q can be read “if it is raining, then the ground is wet”.
In an implication p→q, the first proposition p is known as the hypothesis, antecedent, or premise. The second proposition q is known as the conclusion or consequence.
Because an implication is a conditional, the truth value of the implication as a whole changes depending on the truth value of the premise. The following truth table summarizes the truth values of an implication.
Table 1.4 Implication truth table
p
q
p→q
F
F
T
F
T
T
T
F
F
T
T
T
An implication can be viewed as an obligation, a contract, or a commitment. The implication p→q is false (the contract is broken; the obligation is unmet) only when p is true and q is false.
There are several important observations from this truth table about logical implication.
If q is true, then p→q is always true.
If p is true and the implication correct (the obligation is upheld), then q can never be false.
“Falsity can imply anything.” If the hypothesis is false, then the implication is always true, regardless of the whether or not the conclusion is true.
Some of these observations may seem counter-intuitive at first. Let us clarify with some examples.
The truth value of implications
Let p be “that animal is a panda bear” and q be “that animal is black and white”. p→q can be read as “if that animal is a panda bear, then that animal is black and white”.
If p is true, and that animal is indeed a panda bear (and the implication is correct),
then it is also black and white. If q is true, and the animal is black and white, it might be a panda bear, but it might also be a cow.
From p→q, we can say that knowing the animal is a panda bear is sufficient to know that the animal is black and white.
Valid implications can be formed from completely unrelated propositions. Moreover, if you begin with a nonsensical hypothesis, then one can construct valid (but equally nonsensical) implications. Falsity implies anything.
Absurd but valid implications
“If pigs can fly, then I am the pope.”
“If 2+2=5, then lemons are purple.”
“If the sun is made of ice, then my father is Morgan Freeman”.
There are many equivalent ways to think about the implication p→q.
If p, then q
p implies q
q when p
q, if p
q whenever p
q follows from p
p is sufficient for q
q is necessary for p
Necessity and Sufficiency
An implication connects propositions by a necessary or sufficient condition. From p→q we get two relations:
p is sufficient for q
q is necessary for p
That is, “if sufficient condition, then necessary condition”.
Necessary and Sufficient
“If all birds have feathers, then a chicken is a type of bird.”
Knowing birds have feathers is sufficient information to conclude that a chicken is a type of bird. If a chicken is a type of bird, then chickens necessarily have feathers.
Fig. 1.1 Being in the inner circle is sufficient for being in the outer circle. Being in the outer circle is necessary for being in the inner circle.
Biconditional
For two propositions p and q, they can be connected by a biconditional as p↔q.
A biconditional is an double implication. A biconditional is true if both propositions have the same truth value. p↔q can be read as “p if and only if q”. A biconditional has the following truth table.
Table 1.5 Biconditional truth table
p
q
p↔q
F
F
T
F
T
F
T
F
F
T
T
T
The biconditional p↔q can be expressed in many ways:
“p if and only if q”
“if p then q, and if q then p”
“p is necessary and sufficient for q”
“p iff q”
Biconditional
Let p be “2 is an even number”. Let q be “4 is an even number”. p↔q is a biconditional and its truth value is true, since both p and q are true.
Tip (thinking in memes)
“The venn diagram is a circle” exactly means that the two subjects form a biconditional.

Checkpoint
What is the truth value of these compound propositions?
“The Earth is flat” → “Pigeons are robots”
“Bats have wings” → “Bats are birds”
“A square is a rectangle” ↔ “A square had four 90∘ interior angles”
“Spinach is green” ↔ “Penguins can fly”
Solution

Propositional Formulas
In the previous section we saw 5 different logical connectives: ¬, ∧, ∨, →, and ↔. Much like arithmetic formulas using addition, multiplication, division, etc., propositional formulas may use several connectives simultaneously.
Remember BEDMAS or PEDMAS? Now we have “PaNCo DIB” (“Panko Dib”)?
For logical connectives we have a similar order of precedence.
Parenthesis: always perform operations on expressions inside parentheses first.
Negation: apply negation to a proposition before binary connectives.
Conjunction: conjunction before disjunction
Disjunction: disjunction after conjunction, but before implication
Implication: → after ∧, ∨
Biconditional: ↔ after ∧,∨,→.
Logical order of precendence
p∨q→¬r   is the same as   (p∨q)→(¬r)
p∨¬q∧r   is the same as   p∨( (¬q) ∧r)
Propositional variables need not be associated with a particular proposition or truth value. A propositional variable could be just that: a variable. Replacing the variables in a propositional formula with a truth value is called a truth assignment.
Definition (truth assignment)
A truth assignment is the assignment of a truth value (true or false) to a propositional variable. Equally, it is the replacement of a propositional variable with a truth value.
Much like logical connectives, propositional formulas will result in different truth values depending on the particular truth assignment on its consituent propositional variables. When at least one truth assignment exists so that a formula is true, that formula is said to be satisfiable.
Definition (satisfiable)
A propositional formula is satisfiable if its truth value can be true under some truth assignment. If every possible truth assignment makes the formula have false as its truth value, that formula is said to be unsatisfiable.
In order to determine the truth value of a propositional formula, and to determine if it is satisfiable, we can create a truth table.

Truth Tables
Truth tables are tools for determining the truth values of propositional formulas.
The table is separated into two sets of columns:
The first set of columns represent each proposition (or propositional variable) in a formula.
The second set of columns represents the sub-formulas and formulas whose truth values are to be determined.
There must be one row in the table for every possible combination of truth values of the propositional variables. For example, in a formula with two variables, the possible combinations are: (T,T),(T,F),(F,T),(F,F).
3-variable truth table
Let p,q,r be propositional variables. A truth table for the formula (p∧q)∨r is:
p
q
r
p∧q
(p∧q)∨r
F
F
F
F
F
F
F
T
F
T
F
T
F
F
F
F
T
T
F
T
T
F
F
F
F
T
F
T
F
T
T
T
F
T
T
T
T
T
T
T
Notice that every possible combination of truth values for p, q, and r is contained in this table. Since at least one choice of truth value for p, q, and r results in the formula being true, then this formula is satisfiable.
In a truth table, you begin by filling out the columns corresponding to each propositional variable. These columns represent every possible combination of truth values on those variables. Then, you add columns for each sub-formula, one at a time, building up to the final formula.
Consider the formula p∧q∧r ∨ ¬q∧r→p. By order of precendence, this is equal to ( (p∧q∧r) ∨ ((¬q)∧r) )→p This contains several sub-formulas which we can parse:
¬q
¬q∧r
p∧q
(p∧q)∧r
(p∧q∧r)∨(¬q∧r)
( (p∧q∧r)∨(¬q∧r) )→p
To be as explicit as possible, we could create a truth table with 3 + 6 = 9 columns (3 variables, 6 sub-formulas). But this is excessive. For example, we could directly compute (¬q∧r) and (p∧q∧r). This gives the following truth table.
A large truth table
A truth table for the propositional formula p∧q∧r ∨ ¬q∧r→p.
p
q
r
p∧q∧r
¬q∧r
(p∧q∧r)∨(¬q∧r)
(p∧q∧r)∨(¬q∧r)→p
F
F
F
F
F
F
T
F
F
T
F
T
T
F
F
T
F
F
F
F
T
F
T
T
F
F
F
T
T
F
F
F
F
F
T
T
F
T
F
T
T
T
T
T
F
F
F
F
T
T
T
T
T
F
T
T

Checkpoint
Construct a truth table
Give a truth table for the propositional formula p∧r→q∨¬r
Solution

Implication, Inverse, Converse, and Contrapositive
Now that we have seen propositional formulas and truth tables, let’s revisit implications. This connective has many related conditionals.
Consider the propositional formula p→q. Then, we have:
Converse: q→p
Inverse: ¬p→¬q
Contrapositive: ¬q→¬p
A conditional and its inverse
The proposition “if it is raining, then I wear a jacket” is a conditional statement. Its inverse is “if it is not raining I do not wear a jacket”.
Notice from this previous example than an implication and its inverse are not exactly the same. If the conditional “if it is raining, then I wear a jacket” is true, that is not the same as its inverse. Indeed, you might still wear a jacket even if its not raining. Maybe you’re just cold.
Important
An implication is not equivalent to its converse or inverse. However, it is equivalent to its contrapositive.

 Logical laws are similar to algebraic laws. For example, there is a logical law corresponding to the associative law of addition, a+(b+c)=(a+b)+c.a+(b+c)=(a+b)+c. In fact, associativity of both conjunction and disjunction are among the laws of logic. Notice that with one exception, the laws are paired in such a way that exchanging the symbols ∧,∧, ∨,∨, 1 and 0 for ∨,∨, ∧,∧, 0, and 1, respectively, in any law gives you a second law. For example, p∨0⇔pp∨0⇔p results in p∧1⇔p.p∧1⇔p. This is called a duality principle. For now, think of it as a way of remembering two laws for the price of one. We will leave it to the reader to verify a few of these laws with truth tables. However, the reader should be careful in applying duality to the conditional operator and implication since the dual involves taking the converse. For example, the dual of p∧q⇒pp∧q⇒p is p∨q⇐p,p∨q⇐p, which is usually written p⇒p∨q.p⇒p∨q.
Example : Verification of an Identity Law
The Identity Law can be verified with this truth table. The fact that (p∧1)↔p(p∧1)↔p is a tautology serves as a valid proof.
Table 3.4.13.4.1: Truth table to demonstrate the identity law for conjunction.
pp
11
p∧1p∧1
(p∧1)↔p(p∧1)↔p
00
11
00
11
11
11
11
11
Some of the logical laws in Table 3.4.33.4.3 might be less obvious to you. For any that you are not comfortable with, substitute actual propositions for the logical variables. For example, if pp is “John owns a pet store” and qq is “John likes pets,” the detachment law should make sense.
Table 3.4.23.4.2: Basic Logical Laws – Equivalences
Commutative Laws
p∨q⇔q∨pp∨q⇔q∨p
p∧q⇔q∧pp∧q⇔q∧p
Associative Laws
(p∨q)∨r⇔p∨(q∨r)(p∨q)∨r⇔p∨(q∨r)
(p∧q)∧r⇔p∧(q∧r)(p∧q)∧r⇔p∧(q∧r)
Distributive Laws
p∧(q∨r)⇔(p∧q)∨(p∧r)p∧(q∨r)⇔(p∧q)∨(p∧r)
p∨(q∧r)⇔(p∨q)∧(p∨r)p∨(q∧r)⇔(p∨q)∧(p∨r)
Identity Laws
p∨0⇔pp∨0⇔p
p∧1⇔pp∧1⇔p
Negation Laws
p∧¬p⇔0p∧¬p⇔0
p∨¬p⇔1p∨¬p⇔1
Idempotent Laws
p∨p⇔p∨p⇔
p∧p⇔pp∧p⇔p
Null Laws
p∧0⇔0p∧0⇔0
p∨1⇔1p∨1⇔1
Absorption Laws
p∧(p∨q)⇔pp∧(p∨q)⇔p
p∨(p∧q)⇔pp∨(p∧q)⇔p
DeMorgan’s Laws
¬(p∨q)⇔(¬p)∧(¬q)¬(p∨q)⇔(¬p)∧(¬q)
¬(p∧q)⇔(¬p)∨(¬q)¬(p∧q)⇔(¬p)∨(¬q)
Involution Laws
¬(¬p)⇔p¬(¬p)⇔p
Table 3.4.33.4.3: Basic Logical Laws – Common Implications and Equivalences
Detachment (AKA Modus Ponens)
(p→q)∧p⇒q(p→q)∧p⇒q
Indirect Reasoning (AKA Modus Tollens)
(p→q)∧¬q⇒¬p(p→q)∧¬q⇒¬p
Disjunctive Addition
p⇒(p∨q)p⇒(p∨q)
Conjunctive Simplification
(p∧q)⇒p(p∧q)⇒p and (p∧q)⇒q(p∧q)⇒q
Disjunctive Simplification
(p∨q)∧¬p⇒q(p∨q)∧¬p⇒q and (p∨q)∧¬q⇒p(p∨q)∧¬q⇒p
Chain Rule
(p→q)∧(q→r)⇒(p→r)(p→q)∧(q→r)⇒(p→r)
Conditional Equivalence
p→q⇔¬p∨qp→q⇔¬p∨q
Biconditional Equivalences
(p↔q)⇔(p→q)∧(q→p)⇔(p∧q)∨(¬p∧¬q)(p↔q)⇔(p→q)∧(q→p)⇔(p∧q)∨(¬p∧¬q)
Contrapositive
(p→q)⇔(¬q→¬p)
Lambda
Function terms, called lambda abstractions, are literal expressions that represent mathematical functions. Yes, you can and should now think of functions as being values, too. Function definitions are terms in predicate logic and in functional programming languages. As we will see later on, we can pass functions as arguments to other functions, and receive them as results. Functions that take functions as arguments or that return functions as results are called higher-order functions. We will get to this topic later on.
Consider the simple lambda expression, . It’s a term that represents a function that takes one argument, n, of type, nat. When applied to an actual parameter, or argument, it returns the value of that argument plus one.
Here’s the example in Lean. It first shows that the literal function expression reduces to the value that it represents directly. It then shows that this function can be applied to an actual parameter, i.e., an argument, 5, reducing to the value 6. Third, it shows that a literal function term can be bound to an identifier, here f, and finally that this makes it easier to write code to apply the function to an argument.
#reduce (λ n : ℕ, n + 1)
#eval (λ n : ℕ, n + 1) 5
def f := (λ n : ℕ, n + 1)
#eval f 5
Lambda calculus terms can be viewed as a kind of binary tree. A lambda calculus term consists of:
Variables, which we can think of as leaf nodes holding strings.
Applications, which we can think of as internal nodes.
Lambda abstractions, which we can think of as a special kind of internal node whose left child must be a variable. (Or as a internal node labeled with a variable with exactly one child.)
It’s slightly annoying to have to define a helper procedure add-three just so we can use it as the argument to every. We’re never going to use that procedure again, but we still have to come up with a name for it. We’d like a general way to say “here’s the function I want you to use” without having to give the procedure a name. In other words, we want a general-purpose procedure-generating procedure!
Lambda is the name of a special form that generates procedures. It takes some information about the function you want to create as arguments and it returns the procedure. It’ll be easier to explain the details after you see an example.
(define (add-three-to-each sent)
  (every (lambda (number) (+ number 3)) sent))
> (add-three-to-each ‘(1 9 9 2))
(4 12 12 5)
The first argument to every is, in effect, the same procedure as the one we called add-three earlier, but now we can use it without giving it a name. (Don’t make the mistake of thinking that lambda is the argument to every. The argument is the procedure returned by lambda.)
Perhaps you’re wondering whether “lambda” spells something backward. Actually, it’s the name of the Greek letter L, which looks like this: λ. It would probably be more sensible if lambda were named something like make-procedure, but the name lambda is traditional.[1]
Creating a procedure by using lambda is very much like creating one with define, as we’ve done up to this point, except that we don’t specify a name. When we create a procedure with define, we have to indicate the procedure’s name, the names of its arguments (i.e., the formal parameters), and the expression that it computes (its body). With lambda we still provide the last two of these three components.
As we said, lambda is a special form. This means, as you remember, that its arguments are not evaluated when you invoke it. The first argument is a sentence containing the formal parameters; the second argument is the body. What lambda returns is an unnamed procedure. You can invoke that procedure:
> ((lambda (a b) (+ (* 2 a) b)) 5 6)
16
> ((lambda (wd) (word (last wd) (first wd))) ‘impish)
It’s slightly annoying to have to define a helper procedure add-three just so we can use it as the argument to every. We’re never going to use that procedure again, but we still have to come up with a name for it. We’d like a general way to say “here’s the function I want you to use” without having to give the procedure a name. In other words, we want a general-purpose procedure-generating procedure!
Lambda is the name of a special form that generates procedures. It takes some information about the function you want to create as arguments and it returns the procedure. It’ll be easier to explain the details after you see an example.
(define (add-three-to-each sent)
  (every (lambda (number) (+ number 3)) sent))
> (add-three-to-each ‘(1 9 9 2))
(4 12 12 5)
The first argument to every is, in effect, the same procedure as the one we called add-three earlier, but now we can use it without giving it a name. (Don’t make the mistake of thinking that lambda is the argument to every. The argument is the procedure returned by lambda.)
Perhaps you’re wondering whether “lambda” spells something backward. Actually, it’s the name of the Greek letter L, which looks like this: λ. It would probably be more sensible if lambda were named something like make-procedure, but the name lambda is traditional.[1]
Creating a procedure by using lambda is very much like creating one with define, as we’ve done up to this point, except that we don’t specify a name. When we create a procedure with define, we have to indicate the procedure’s name, the names of its arguments (i.e., the formal parameters), and the expression that it computes (its body). With lambda we still provide the last two of these three components.
As we said, lambda is a special form. This means, as you remember, that its arguments are not evaluated when you invoke it. The first argument is a sentence containing the formal parameters; the second argument is the body. What lambda returns is an unnamed procedure. You can invoke that procedure:
> ((lambda (a b) (+ (* 2 a) b)) 5 6)
> ((lambda (wd) (word (last wd) (first wd))) ‘impish)
Searching algorithms are used to find a specified element within a data structure. For example, a searching algorithm could be used to find the name “Alan Turing” in an array of names. Numerous different searching algorithms exist, each of which is suited to a particular data structure of format of data. Different searching algorithms are used depending on each individual scenario. Binary Search The binary search algorithm can only be applied on sorted data and works by finding the middle element in a list of data before deciding which side of the data the desired element is to be found in. The unwanted half of the data is then discarded and the process repeated until the desired element is found or until it is known that the desired element doesn’t exist in the data.
 Pseudocode for binary search is shown below. A ​ = Array of data x ​ = Desired element low = 0  high = A.length -1  while low <= high:  mid = (low + high) / 2  if A[mid] == x:  return mid  else if
A[mid] > x:  high = mid -1  else:  low = mid + 1  endif  endwhile  return
 “Not found in data”  With each iteration of binary search, half of the input data is discarded, making the algorithm very efficient. In fact, the time complexity of binary search is O(log n)​ .
www.pmt.education Example 1 Find the location of “Dylan” in the data below.
 0  Alice
1 Bob
2  Charlie
3 Dylan
5 Ellie
 6  Franz
Gabbie Hugo Ingrid To start with, our values for high and low and 8 and 0 respectively. The first step is to find the middle position.
 In this case, it’s (0 + 8) / 2 = ​4​ . Next we inspect the data in position 4: Ellie. This is higher than the desired data and so we discard elements 4-8, setting high as 3. 0  Alice 1  2  3  4  5  6  7  8  Bob Charlie Dylan Ellie Franz Gabbie Hugo Ingrid Again, we calculate the value of the middle position.
This time it’s (0 + 3) / 2 = ​2 (We have to round to the nearest whole number). Inspecting the data at this position we find Charlie, which is lower than the. This breaks the condition of low being less than or equal to high, and so breaks the while loop in the pseudocode. The algorithm then returns “Not found in data” before terminating. Example 3 Look at how the algorithm finds the letter R in the first 20 characters of the alphabet. It’s clear from this example that the algorithm halves the remaining data to be searched with each iteration, gradually reducing the size of the problem to be solved. A B C D E F G H I J K L M N O P Q R S T  A B C D E F G H I J K L M N O P Q R S T  A B C D E F G H I J K L M N O P Q R S T  A B C D E F G H I J K L M N O P Q R S T 
.pmt.education
Linear Search Linear search is the most basic searching algorithm. You can think of it as going along a bookshelf one by one until you come across the book you’re looking for. Sometimes the algorithm gets lucky and finds the desired element almost immediately, while in other situations, the algorithm is incredibly inefficient.
 It’s time complexity is O(n)​ . There’s a lot of pot luck involved with linear search, but it’s incredibly easy to implement. Unlike binary search, linear search doesn’t require the data to be sorted. A ​ = Array of data x ​ = Desired element i = 0  while i < A.length:  if A[i] == x:  return i  else:  i = i + 1  endif  endwhile  return “Not found in data”  Example 1
 Find the position of Apple in the data. 0  Banana
1  Orange
2  3  4  Apple
Kiwi First we inspect position 0,
 and find Banana.
Not the element we’re after.
0  1  2  3  Mango
 4  Banana
Orange
 Apple
 Kiwi
Next we inspect position 1, finding Orange.
Again, not what we’re looking for. 0  1  2  3 
www.pmt.education Example 2 Look at how this algorithm finds the letter R in the first 20 characters of the alphabet and compare it to binary search above. It’s clear from this example that the algorithm is much less efficient than binary search, particularly when the search value is towards the end of the data to be searched.
A B C D E F G H I J K L M N O P Q R S T
 A B C D E F G H I J K L M N O P Q R S T
A B C D E F G H I J K L M N O P Q R S T
A B C D E F G H I J K L M N O P Q R S T
A B C D E F G H I J K L M N O P Q R S T
A B C D E F G H I J K L M N O P Q R S T
 A B C D E F G H I J K L M N O P Q R S T
 A B C D E F G H I J K L M N O P Q R S T
 A B C D E F G H I J K L M N O P Q R S T
A B C D E F G H I J K L M N O P Q R S T
A B C D E F G H I J K L M N O P Q R S T
 A B C D E F G H I J K L M N O P Q R S T
 A B C D E F G H I J K L M N O P Q R S T
A B C D E F G H I J K L M N O P Q R S T
 A B C D E F G H I J K L M N O P Q R S T
 A B C D E F G H I J K L M N O P Q R S T
A B C D E F G H I J K L M N O P Q R S T A B C D E F G H I J K L M N O P Q
Conclusion:
While we note that this is an aspect of discrete mathematics that would benefit from more systematic study and research, this accessibility has come through in some research studies, but not as an explicit focus of the study. Some of the research on the teaching and learning of discrete mathematics with younger students highlights not only the accessibility of topics but that this accessibility can help students make sense of the current curriculum. For example, iterative problems and difference equations can help students learn algebra (Amit & Neria, 2008; Blanton & Kaput, 2005; Carraher et al., 2008; Radford, 2008; Rivera & Becker, 2008; Sandefur et al., 2018; Steele, 2008; Yeap & Kaur, 2008). Even very young students can reason about combinatorial problems in meaningful ways (de Beer et al., 2015; Maher et al., 2011). English (1991, 1993) reports on young children’s strategies as they engage with combinatorial problems. As another example, students can naturally `invent’ graph theory to solve a problem (Ferrarello & Mammana, 2018; Greefrath et al., 2022; van den Heuvel & Krabbendam, 1991).
We can only wonder how much better would the students’ work be if they already knew some graph theory or had previous experience with counting or recursive problems? For many topics in discrete mathematics, students ranging from young children to undergraduate students can be posed similar questions and have a reasonable chance at Investigating the problem at their different levels.
This results in self differentiating tasks that allow individual approaches to the problem (Ostkirchen & Greefrath, 2022). For example, how many 2-color towers can I make of height 5, can be extended to more complicated problems for older students by increasing the number of colors and the height of the tower. Maher et al. (2011) describe the use of combinatorial problems in such contexts among students in a longitudinal study. Students as young as the third grade can investigate recursive structures they build with toothpicks and stickers while high school students can develop recursive models of bacteria growth and the spread of epidemics, which is a simplified version of models studied by epidemiologists (Radford, 2008; Sandefur & Manaster, 2022; Yeap & Kaur, 2008).
This highlights what we mean by accessibility – students can have access to mathematical topics and ideas regardless of background and prerequisite knowledge (DeBellis & Rosenstein, 2004; Ferrarello & Mammana, 2018). Although we have several examples of empirical research that implicitly demonstrates the accessibility of discrete mathematics and the value of this accessibility, we note that there is also more work to be done. There is a need for the field to focus on the issue of accessibility more systematically and explicitly.
Part II
Computational Thinking at first glance – What, why and how
1.1. Definition of Computational Thinking (CT) Is that a fact? There is still no universally accepted definition of “Computational Thinking”. The concept of computational thinking (CT) was first introduced by an educationalist Seymour Papert in 1967 talking about LOGO, the programming language he developed at MIT (Massachusetts Institute of Technology) to teach programming to children. He was convinced that the use of computers could foster formal thinking in children and, in particular, could allow children to autonomously “construct” their learning and thinking. The concept of CT was then revitalized in 2006 by a computer scientist Jeannette M. Wing who, in the article “Computational Thinking”, argued that it addresses the conundrum of machine intelligence by asking what machines do better than man and what man does better than machines. Wing argues that computational thinking is not simply a procedural coding activity, but is a basic conceptual skill that, along with reading, writing and arithmetic, should be taught to all children. It appears that computational thinking purports to be critical thinking in evaluating situations and an advanced problem-solving ability using computerized tools. If computer science is the science of what can be computerized and how to computerize it, however, computational thinking is not a skill unique to computer scientists. It allows problems to be solved, a system to be designed and human behaviour to be understood in everyday life, in an alternative way, through the fundamental concepts of information technology.
Key Skills for Computational Thinking There are four key skills in computational thinking:
 1 Decomposition
2 Pattern Recognition
3 Pattern Abstraction
4 Algorithm Design
 1) Decomposition Breaking down big and difficult problems into something much simpler. Often big problems are just many little problems put together. Decomposition is an important life skill to be relied on in the future when students and adults need to take on larger tasks. Students will learn ways to delegate group projects and build time management skills
 2) Pattern Recognition Sometimes when a problem is made up of many small bits, you will notice that these bits have something in common. If they do not, they could, however, have strong similarities with the pieces of another problem that has already been solved. If you are able to find these regularities, it will become a lot easier to identify the individual pieces: pattern recognition is simply looking for patterns in the puzzles and determining if any of the problems or solutions we encountered in the past may apply to a present situation. May, what we learned in the past, help us sort out the actual problem? If you have ever built a piece of IKEA furniture, you will understand the importance of patterns. While assembling an IKEA drawer unit, it is likely to take you much longer to assemble the first drawer than the fourth or fifth. When we repeat steps in our assembling process we learn how to solve the instructions more quickly and learn from our mistakes. The painstaking process of assembling that first part teaches us the skills to perform the process more efficiently in the future.
3) Pattern Abstraction Once you have located a pattern, it is possible to abstract (ignore) the details that differentiate the various things and use general techniques for finding solutions that work for more than one problem. Identifying the crucial information in a problem and disregarding the irrelevant information is one of the hardest parts of computational learning.
 4) Algorithm design When the solution is ready, it is possible to write it down so it can be executed step by step. This makes easier to obtain the expected results. Algorithm design is setting out the steps and rules needed to follow in order to achieve the same desired outcome every time.
Concepts of computational thinking Computational thinking is a cognitive or thought process involving logical reasoning by which problems are solved and artefacts, procedures and systems are better understood. It embraces:
● the ability to think algorithmically;
● the ability to think in terms of decomposition;
 ● the ability to think in generalisations, identifying and making use of patterns;
 ● the ability to think in abstractions, choosing good representations; and
 ● the ability to think in terms of evaluation. Computational thinking skills enable pupils to access parts of the Computing subject content. Importantly, they relate to thinking skills and problem solving across the whole curriculum and through life in general. Computational thinking can be applied to a wide range of artefacts including: systems, processes, objects, algorithms, problems, solutions, abstractions, and collections of data or information. In the following discussion of concepts, artefact refers to any of these. Logical reasoning Logical reasoning enables pupils to make sense of things by analysing and checking facts through thinking clearly and precisely. It allows pupils to draw on their own knowledge and internal models to make and verify predictions and to draw conclusions. It is used extensively by pupils when they test, debug, and correct algorithms. Logical reasoning is the novel application of the other computational thinking concepts to solve problems.
Design and technology pupils, designing a model of a truck, choose materials for different elements of a project. They are employing generalisation when they recognise that the properties of a material used in one situation make it suitable to use in another completely different context. Being able to divide the new project into different parts, requiring different materials, is an example of decomposition. The pupil is using logical reasoning to design a truck. Pupils use logical reasoning when learning about gravity using a weighted string suspended from the lid of a glass jar. Before tilting the jar, pupils can make predictions about the behaviour of the weighted string. They can then evaluate the results of their tests. They may be able to generalise the behaviour to other situations such as a crane. The novel use in understanding a property of gravity is logical reasoning. Logical reasoning is key in allowing pupils to debug their code. They can work with peers to evaluate each other’s code, to isolate bugs, and to suggest fixes. During this process, they may have opportunities to employ abstraction, evaluation, and algorithmic design. The novel use in correcting mistakes in code requires logical reasoning.
 Abstraction in the Computer Science Classroom
Although we have presented relevant characterisations of abstraction, it is still far from clear how an abstraction-oriented perspective could become part of the pedagogical practice. Already in the late 1990s, as a revision of the spreading object-first orientaTable 1
 PGK Hierarchy levels from Perrenet et al. (2005) and their mapping to K-5 settings according to Waite et al. (2018). PGK Level Definition K-5 name K-5 question Problem Algorithm perceived as a problem solving strategy problem “What is needed” Object (algorithm) Algorithm understood independently of any specific implementation design “What it should do” Program Algorithmic grasp of the program code “How it is done” Execution Focus on individual runs with specific inputs running the code “What it does” 630 C. Mirolo et al. tion, Machanick (1998) endorsed an abstraction-first instructional approach where the implementation of abstract data types is delayed as much as possible in order to stress an abstract view of the models.
Kramer remarked that abstraction per se is not the subject of any computing course, but that all computing courses “rely on or utilize abstraction to explain, model, specify, reason or solve problems,” so confirming that “abstraction is an essential aspect of computing, but that it must be taught indirectly through other topics” (Kramer, 2007, p. 41). In line with Kramer’s remark, Hazzan (2008) discussed abstraction as a soft idea, “that can be neither rigidly nor formally defined, nor is it possible to guide students as to its precise application.” And although “it is not a trivial matter,” like other soft ideas, abstraction should be taught in a computer science curriculum.
Then, a small number of educators have provided guidelines to teach abstraction at different instruction levels. Hence, this section briefly explores their approaches to foster and assess abstraction skills. 5.1. Teaching to Trigger Abstraction in Computer Science Often instructors aim to develop students’ abstraction skills indirectly, by devising particular learning trajectories that are supposed to foster higher-level thinking and require students to use abstraction to succeed. In a program development project, for example, they could assign refactoring tasks in which learners are asked to look for recurrent patterns of code and to re-organise the code by introducing meaningful procedural and/or data abstractions with the purpose of making the whole program easier to read, debug and modify. In the following paragraphs we will outline a selection of representative approaches to (an implicit) abstraction-oriented instruction. Pattern-oriented instruction. This approach has the aim of improving students’ competencies in algorithmic problem solving (Muller and Haberman, 2008).
An algorithm is indeed seen by these authors as a combination of plan patterns in Soloway’s sense (Soloway, 1986), resulting via sequencing, nesting or merging plans from a repertory of basic algorithmic patterns specifically designed for pedagogical purposes. In Muller and Haberman’s scenario, abstraction plays a crucial role in pattern recognition, chunking, and problem structure identification. Their approach relies on having an appropriate pattern repository, as well as on presenting carefully selected problems of gradually increasing difficulty; teachers should then discuss and compare different solutions to a given problem in terms of pattern composition. Additional guidelines for pattern-oriented instruction include:
(1) patterns should be abstracted from related examples or by generalising a simpler problem,
(2) patterns should be revisited in different contexts, in order to make the identification of common problem features easier, and (3) similarities, differences, and also possible misuses of patterns should be considered. According to Muller and Haberman, comparative studies appear to show that novices exposed to this approach develop enhanced problem solving abilities. Multiple representations perspective. Dealing with multiple representations of a given phenomenon can play a key role in the development of abstract concepts. Ac- cording to Ainsworth (2008), in particular, in order “to construct a deeper understanding of a domain,” if the learners “fail to relate representations, then processes like abstraction cannot occur. Moreover, although learners find it difficult to relate different forms of representations, if the representations are too similar, then abstraction is also unlikely to occur.” She then recommends that teachers should foster abstraction over multiple representations “by providing focused help and support on how to relate representations and giving learners sufficient time to master this process.” In this respect, Gautam et al. (2020) have recently proposed an interesting interdisciplinary approach to integrate science (namely, chemistry) and computational thinking in the curriculum. While abstraction is usually “presented as hierarchical” in terms of (i) extracting important features and ignoring unimportant ones, and (ii) finding commonalities across contexts, in their standpoint “abstraction in science” as well as in computing “requires students to move laterally across different representations of the concepts or actions.” In the reported study, the micro-level process of photosynthesis was modeled by a code snippet, and by discussing commonalities and differences between, e.g., a whiteboard and the code representation of the implied chemical reaction, “the instructor pushed students towards higher-level abstract thinking.” Moreover, they suggest to allow for friction emerging when the students explore different representations, in that it encourages to consider alternative views and “negotiate the elements with one another.” According to the authors, this approach “created meaningful accounts of science phenomenon and the science provided access to how computation embeds ideas.” Exploration of artefacts.
 A more recent pedagogical trend in programming education attempts to trigger abstraction through activities inspired by the use-modify-create framework. The idea is that the understanding of artefacts such as programs would gradually progress through three major stages, corresponding to
exploration via passive use (as a consumer),
(ii) experimentation of the internal machinery by modifying some features, and finally
(iii) creation of new, original artefacts to achieve specific goals. While discussing the use-modify-create approach, Lee et al. (2014) observe that abstraction, as well as other computational thinking abilities, are “not explicitly taught but rather [develop] through one’s impetus to create;” nevertheless, in this progression the abilities to modify and, later, to create imply the enhancement of learner’s abstraction skills.
This is a course on discrete mathematics as used in Computer Science. It’s only a one-semester course, so there are a lot of topics that it doesn’t cover or doesn’t cover in much depth. But the hope is that this will give you a foundation of skills that you can build on as you need to, and particularly to give you a bit of mathematical maturity—the basic understanding of what mathematics is and how mathematical definitions and proofs work.
So why do I need to learn all this nasty mathematics?
 Why you should know about mathematics, if you are interested in Computer Science: or, more specifically, why you should take CS202 or a comparable course:
• Computation is something that you can’t see and can’t touch, and yet (thanks to the efforts of generations of hardware engineers) it obeys strict, well-defined rules with astonishing accuracy over long periods of time.
• Computations are too big for you to comprehend all at once. Imagine printing out an execution trace that showed every operation a typical $500 desktop computer executed in one (1) second.
If you could read one operation per second, for eight hours every day, you would die of old age before you got halfway through. Now imagine letting the computer run overnight. So in order to understand computations, we need a language that allows us to reason about things we can’t see and can’t touch, that are too big
 
for us to understand, but that nonetheless follow strict, simple, well-defined rules. We’d like our reasoning to be consistent: any two people using the language should (barring errors) obtain the same conclusions from the same information. Computer scientists are good at inventing languages, so we could invent a new one for this particular purpose, but we don’t have to: the exact same problem has been vexing philosophers, theologians, and mathematicians for much longer than computers have been around, and they’ve had a lot of time to think about how to make such a language work.
 Philosophers and theologians are still working on the consistency part, but mathematicians (mostly) got it in the early 20th-century. Because the first virtue of a computer scientist is laziness, we are going to steal their code.
But isn’t math hard? Yes and no. The human brain is not really designed to do formal mathematical reasoning, which is why most mathematics was invented in the last few centuries and why even apparently simple things like learning how to count or add require years of training, usually done at an early age so the pain will be forgotten later. But mathematical reasoning is very close to legal reasoning, which we do seem to be very good at.1 There is very little structural difference between the two sentences: 1. If x is in S, then x + 1 is in S. 2. If x is of royal blood, then x’s child is of royal blood.
 But because the first is about boring numbers and the second is about fascinating social relationships and rules, most people have a much easier time deducing that to show somebody is royal we need to start with some known royal and follow a chain of descendants than they have deducing that to show that some number is in the set S we need to start with some known element of S and show that repeatedly adding 1 gets us to the number we want. And yet to a logician these are the same processes of reasoning. So why is statement
(1) trickier to think about than statement
 (2)? Part of the difference is familiarity—we are all taught from an early age what it means to be somebody’s child, to take on a particular social role, etc. For mathematical concepts, this familiarity comes with exposure and practice, just as with learning any other language. But part of the difference is that 1For a description of some classic experiments that demonstrate this, see http://
Foundations and logic Why: This is the assembly language of mathematics—the stuff at the bottom that everything else compiles to.
 • Propositional logic.
 • Predicate logic.
 • Axioms, theories, and models.
• Proofs.
• Induction and recursion
 
English Language Arts
To Critical Thinking, the critical person is something like a critical consumer of information; he or she is driven to seek reasons and evidence. Part of this is a matter of mastering certain skills of thought: learning to diagnose invalid forms of argument, knowing how to make and defend distinctions, and so on. Much of the literature in this area, especially early on, seemed to be devoted to lists and taxonomies of what a “critical thinker” should know and be able to do (Ennis 1962, 1980). More recently, however, various authors in this tradition have come to recognize that teaching content and skills is of minor import if learners do not also develop the dispositions or inclination to look at the world through a critical lens. By this, Critical Thinking means that the critical person has not only the capacity (the skills) to seek reasons, truth, and evidence, but also that he or she has the drive (disposition) to seek them. For instance, Ennis claims that a critical person not only should seek reasons and try to be well informed, but that he or she should have a tendency to do such things (Ennis 1987, 1996). Siegel criticizes Ennis somewhat for seeing dispositions simply as what animates the skills of critical thinking, because this fails to distinguish sufficiently the critical thinker from critical thinking. For Siegel, a cluster of dispositions (the “critical spirit”) is more like a deep-seated character trait, something like Scheffler’s notion of “a love of truth and a contempt of lying” (Siegel 1988; Scheffler 1991). It is part of critical thinking itself. Paul also stresses this distinction between skills and dispositions in his distinction between “weak-sense” and “strong-sense” critical thinking. For Paul, the “weak-sense” means that one has learned the skills and can demonstrate them when asked to do so; the “strong-sense” means that one has incorporated these skills into a way of living in which one’s own assumptions are re-examined and questioned as well. According to Paul, a critical thinker in the “strong sense” has a passionate drive for “clarity, accuracy, and fairmindedness” (Paul 1983, 23; see also Paul 1994). This dispositional view of critical thinking has real advantages over the skills-only view. But in important respects it is still limited. First, it is not clear exactly what is entailed by making such dispositions part of critical thinking. In our view it not only broadens the notion of criticality beyond mere “logicality,” but it necessarily requires a greater attention to institutional contexts and social relations than Critical Thinking authors have provided. Both the skills-based view and the skills-plus-dispositions view are still focused on the individual person. But it is only in the context
A second theme in the Critical Thinking literature has been the extent to which critical thinking can be characterized as a set of generalized abilities and dispositions, as opposed to content-specific abilities and dispositions that are learned and expressed differently in different areas of investigation. Can a general “Critical Thinking” course develop abilities and dispositions that will then be applied in any of a range of fields; or should such material be presented specifically in connection to the questions and content of particular fields of study? Is a scientist who is a critical thinker doing the same things as an historian who is a critical thinker? When each evaluates “good evidence,” are they truly thinking about problems in similar ways, or are the differences in interpretation and application dominant? This debate has set John McPeck, the chief advocate of content-specificity, in opposition to a number of other theorists in this area (Norris 1992; Talaska 1992). This issue relates not only to the question of how we might teach critical thinking, but also to how and whether one can test for a general facility in critical thinking (Ennis 1984). A third debate has addressed the question of the degree to which the standards of critical thinking, and the conception of rationality that underlies them, are culturally biased in favor of a particular masculine and/or Western mode of thinking, one that implicitly devalues other “ways of knowing.” Theories of education that stress the primary importance of logic, conceptual clarity, and rigorous adherence to scientific evidence have been challenged by various advocates of cultural and gender diversity who emphasize respect for alternative world views and styles of reasoning. Partly in response to such criticisms, Richard Paul has developed a conception of critical thinking that regards “sociocentrism” as itself a sign of flawed thinking (Paul 1994). Paul believes that, because critical thinking allows us to overcome the sway of our egocentric and sociocentric beliefs, it is “essential to our role as moral agents and as potential shapers of our own nature and destiny”(Paul 1990, 67). For Paul, and for some other Critical Thinking authors as well, part of the method of critical thinking involves fostering dialogue, in which thinking from the perspective of others is also relevant to the assessment of truth claims; a too-hasty imposition of one’s own standards of evidence might result not only in a premature rejection of credible alternative points of view, but might also have the effect of silencing the voices of those who (in the present context) need to be encouraged as much as possible to speak for themselves. In this respect, we see Paul introducing into the very definition of critical thinking some of the sorts of social and contextual factors that Critical Pedagogy writers have emphasized.
http://mediaeducation.org.mt/wp-content/uploads/2013/05/Critical-Thinking-and-Critical-Pedagogy.pdf
CHAPTER TWO BASIC CONCEPTS OF LOGIC
Chapter Overview Logic, as field of study, may be defined as the organized body of knowledge, or science that evaluates arguments. The aim of logic is to develop a system of methods and principles that we may use as criteria for evaluating the arguments of others and as guides in constructing arguments of our own. Argument is a systematic combination of two or more statements, which are classified as a premise or premises and conclusion. A premise refers to the statement, which is claimed to provide a logical support or evidence to the main point of the argument, which h known as conclusion. A conclusion is a statement, which is claimed to follow from the alleged evidence. Depending on the logical and real ability of the premise(s) to support the conclusion, an argument can be either a good argument or a bad argument. However, unlike all kinds of passages, including those that resemble arguments, all arguments purport to prove something. Arguments can generally be divided into deductive and inductive arguments. A deductive argument is an argument in which the premises are claimed to support the conclusion in such a way that it is impossible for the premises to be true and the conclusion false. On the other hand, an inductive argument is an argument in which the premises are claimed to support the conclusion in such a way that it is improbable that the premises be true and the conclusion false. The deductiveness or inductiveness of an argument can be determined by the particular indicator word it might use, the actual strength of the inferential relationship between its component statements, and its argumentative form or structure. A deductive argument can be evaluated by its validity and soundness. Likewise, an inductive argument can be evaluated by its strength and cogency. Depending on its actually ability to successfully maintain its inferential claim, a deductive argument can be either valid or invalid. That is, if the premise(s) of a certain deductive argument actually support its conclusion in such a way that it is impossible for the premises to be true and the conclusion false, then that particular deductive argument is valid. If, however, its premise(s) actually support its conclusion in such a
way that it is possible for the premises to be true and the conclusion false, then that particular deductive argument is invalid. Similarly, an inductive argument can be either strong or weak, depending on its actually ability to successfully maintain its inferential claim. That is, if the premise(s) of a certain inductive argument actually support its conclusion in such a way that it is improbable for the premises to be true and the conclusion false, then that particular inductive argument is strong. If, however, its premise(s) actually support its conclusion in such a way that it is probable for the premises to be true and the conclusion false, then that particular inductive argument is weak. Furthermore, depending on its actually ability to successfully maintain its inferential claim as well as its factual claim, a deductive argument can be either sound or unsound. That is, if a deductive argument actually maintained its inferential claim, (i.e., if it is valid), and its factual claim, (i.e., if all of its premises are true), then that particular deductive argument will be a sound argument. However, if it fails to maintain either of its claims, it will be an unsound argument. Likewise, depending on its actually ability to successfully maintain its inferential claim as well as its factual claim, an inductive argument can be either cogent or uncogent. That is, if an inductive argument actually maintained its inferential claim, (i.e., if it is strong), and its factual claim, (i.e., if all of its premises are probably true), then that particular inductive argument will be a cogent argument. However, if it fails to maintain either of its claims, it will be an uncogent argument. In this chapter, we will discuss logic and its basic concepts, the techniques of distinguishing arguments from non-argumentative passages, and the types of arguments.
Chapter Objectives: Dear learners, after the successful completion of this chapter, you will be able to:
Ø Understand the meaning and basic concepts of logic;
Ø Understand the meaning, components, and types of arguments; and
Ø Recognize the major techniques of recognizing and evaluating arguments
Lesson 1: Basic Concepts of Logic: Arguments, Premises and Conclusions Lesson Overview Logic is generally be defined as a philosophical science that evaluates arguments. An argument is a systematic combination of one or more than one statements, which are claimed to provide a logical support or evidence (i.e., premise(s) to another single statement which is claimed to follow logically from the alleged evidence (i.e., conclusion). An argument can be either good or bad argument, depending on the logical ability of its premise(s) to support its conclusion. The primary aim of logic is to develop a system of methods and principles that we may use as criteria for evaluating the arguments of others and as guides in constructing arguments of our own. The study of logic increases students‘ confidence to criticize the arguments of others and advance arguments of their own. In this lesson, we will discuss the meaning and basic concepts of logic: arguments, premises, and conclusions. Lesson Objectives: After the accomplishment of this lesson, you will be able to:
Ø Understand the meaning.
Ø Identify the subject matter of logic.
 Ø Understand the meaning of an argument.
Ø Identify the components of an argument.
 Ø Understand the meaning and nature of a premise.
Ø Comprehend the meaning and nature of a conclusion.
Ø Recognize the techniques of identifying the premises and conclusion of an argument.
Conditional Statements
A conditional statement is an ―if . . . then . . .‖ statement.
Example: If you study hard, then you will score „A‟ grade.
 Every conditional statement is made up of two component statements. The component statement immediately following the ―if‖ is called the antecedent (if-clause), and the one following the ―then‖ is called the consequent (then-clause). However, there is an occasion that the order of antecedent and consequent is reversed.
That is, when occasionally the word ‗‗then‘‘ is left out, the order of antecedent and consequent is reversed. For example if we left out ―then‖ from the above example the antecedent and consequent is reversed: You will score „A‟ grade if you study hard. In the above example, the antecedent is ―You study hard,‖ and the consequent is ―
You will score „A‟ grade.‖ In this example, there is a meaningful relationship between antecedent and consequent.
However, such a relationship need not exist for a statement to count as conditional. The statement ―If Getaneh Kebede is a singer, then Hawassa is in Mekelle‖ is just as much a conditional statement as that in the above example.
Conditional statements are not arguments, because they fail to meet the criteria given earlier.
In an argument, at least one statement must claim to present evidence, and there must be a claim that this evidence implies something. In a conditional statement, there is no claim that either the antecedent or the consequent presents evidence. In other words, there is no assertion that either the antecedent or the consequent is true. Rather, there is only the assertion that if the antecedent is true, then so is the consequent.
For example, the above example merely asserts that if you study hard, then you will score ‗A‘. It does not assert that you study hard.
Nor does it assert you scored ‗A‘. Of course, a conditional statement as a whole may present evidence because it asserts a relationship between statements. Yet when conditional statements are taken in this sense, there is still no argument, because there is then no separate claim that this evidence implies anything.
 Therefore, a single conditional statement is not an argument.
The fact that a statement begins with ―if‖ makes it the idea conditional and not a final reasonable assertion.
That is why also conditional statements are not evaluated as true or false without separately evaluating the antecedent and the consequent. They only claim that if the antecedent is true then so is the consequent. However, some conditional statements are similar to arguments in that they express the outcome of a reasoning process. As such, they may be said to have a certain inferential content. Consider the following example: If destroying a political competitor gives you joy, then you have a low sense of morality
https://wcu.edu.et/FirstYearModule/CRITICAL%20THINKING%20module.pdf
Discrete Mathematics
The Conditional Statement Before we give a formal definition of the conditional statement, we start with an example so we can understand when a conditional statement should be true. For the example, we need the following notation and terminology:
 Notation 1.1.
 If p and q are statements, the conditional of q by p is “if p then q” denoted p → q. We call p the hypothesis of the conditional and q the conclusion.
 Example 1.2. Consider the conditional statement, “if I am healthy, I will come to class.” To determine the truth value of this statement, we need to determine when this statement is false, so we consider the four different possibilities for the truth values of p and q.
Let p :=“I am healthy” and q :=“I will come to class”. We shall fill in the following table:
p q p → q T T T T F F F T T F F T
 • For case # 1, if I am healthy and I come to class, the conditional is clearly true.
 • For case # 2, if I am healthy, but I have decided to stay home and not go to class, the conditional is false – the hypothesis is satisfied, but the conclusion is not satisfied, so the statement cannot possibly be true.
• For case # 3, if I am not healthy, but I have come to class anyway though all the people sitting around may not be happy about it, the conditional statement has not been violated since the hypothesis does not hold i.e. the conditional statement is meaningless since the hypothesis is not true. Therefore, the conditional must be true.
 • Likewise, for case # 4, if I am not healthy, and I did not come to class, the conditional statement has not been violated since
the hypothesis does not hold. Therefore, the conditional is true. This example implies that a conditional statement is false only when the hypothesis is true and the conclusion is false. Though it is clear that a conditional statement is false only when the hypothesis is true and the conclusion is false, it is not clear why when the hypothesis is false, the conditional statement is always true. To try to explain why this is this case, we consider another example.
 Example 1.3.
 Consider the mathematical statement “if n is a perfect square, then n is not prime.” Clearly this is a true statement for any n, so it will be true when we substitute values in for n. Now substitute 3 for n: “if 3 is a perfect square, then 3 is not prime.” As remarked above, this conditional statement is still true yet its hypothesis and conclusion are both false. Similarly, if we substitute 6 into this statement, it becomes “if 6 is a perfect square, then 6 is not prime.” This conditional statement is true yet its hypothesis is false and its conclusion is true.
 We can now write down a formal definition for the conditional statement.
 Definition 1.4. If p and q are statements, the conditional of q by p is “if p then q” or “p implies q” denoted p → q. A conditional statement is false only when the hypothesis is false and the conclusion is true. The truth table for the conditional statement is as follows:
p q p → q
T T T T F F
F T T F F T
https://faculty.up.edu/wootton/discrete/section1.2.pdf
Conditional reasoning
Conditional reasoning is based on the construction “if 𝑝, then 𝑞” when the premise is true,
the conclusion will be true. However, this leaves open the question of what happens when
𝑝 is false, which means that, in this case, 𝑞 can logically be either true or false. Studies
are abundant about four main conditional inferences: modus ponens, modus tollens,
affirmation of the consequent and denial of the antecedent. Johnson-Laird and Byrne
(2002) discuss that, among all four conditional inferences mentioned in §§3.1.2, only
modus ponens and modus tollens are valid for the conditional interpretation. The following
is an example of modus ponens:
If it rains, then you get wet.
It rains.
Therefore, you get wet.
https://summit.sfu.ca/_flysystem/fedora/2022-08/input_data/22441/etd21791.pdf
Critics have claimed that mathematics taught in K-11 and K-12 is nothing more than memorizing the facts rather than computing the method of solving the given problem with a known concept of study.
Topic of study which includes discrete mathematics are Set Theory, Relations and Functions, Principles of Mathematical Induction, Permutation and Combinations, Mathematical Reasoning, Probability and some study about Matrices and Determinants.
Discrete Mathematics course is a core part of computer / information science & technology and it facilitates the study of applications in the field of computer science, especially in the areas of data structures, the theory of computer languages and the analysis of algorithms. In addition, this course also provides students with understanding of applications in engineering and the physical and life sciences, as well as in statistics and the social sciences.
 To introduce the student at the high-school level, if not earlier, to the topics and techniques of discrete methods and combinatorial reasoning. Whenever the structures from abstract algebra are required, only the basic theory needed for the application development. Further, the solution of the some applications contribute to the iterative procedures that lead to specific algorithms. The algorithmic approach and solution for the problems is fundamental in discrete mathematics.
Counting concept introduces the basic collection of counting techniques with few motivational examples such as paper folding example, Rubik’s cube problem etc. This provides, count visually distinguishable patterns (Binomial Theorem) for collection of objects with identifiable types of objects, each with several copies are available. Counting the number of distinct elements in a union of possibly non-disjoint sets (inclusion-exclusion formula). Probability theory conceptualize the foundational explanations (event, sample space, independence). Methods of determining the probabilities of events are introduced and the notion of equally likely outcomes are defined. The notion of a random variable is to create a variable whose value is determined by the outcome of a random experiment. Probability distribution described for a particular pattern and a collection of conditional probabilities into a different set of conditional probabilities (Bayes’s Theorem). On higher level, they should be aware of some meta-knowledge and heuristics, and be able to use them appropriately. They should be aware that there are many approaches to achieve the same goal but using the appropriate method of solving the problem and reach the desired result. Influenced by all the examples in discrete mathematics concepts, students shall know it is good to work systematically and in phases, virtually every time when it is possible. Educational targets describes above includes both practical usability and theoretical knowledge. These two aspect shall strength each other systematically, where every student of K-11 and K-12 grade classes efficiently.