(数学的帰納法などの証明方法)

http://www.sw.it.aoyama.ac.jp/2018/Math1/lecture14.html

© 2006-19 Martin J. Dürst Aoyama Gakuin University

- Remaining Schedule
- Summary of last lecture
- Digit sums and digital roots
- Proof Methods
- Mathematical Induction

- January 15: this lecture
- January 18: 15th lecture (makeup class)
- January 25,
**11:10**-12:35: Term final exam

About makeup classes: The material in the makeup class is part of the final exam. If you have another makeup class at the same time, please inform the teacher as soon as possible.

補講について: 補講の内容は期末試験の対象。補講が別の補講とぶつかる場合には事前に申し出ること。

- Congruence (≡) is at the core of Modular Arithmetic
- Two integers are congruent (modulo
`n`) if they have the same remainder when divided by`n` - The Congruence Relation is an equivalence relation, with the remainder as the class representative
- Congruence relations and modulo operations have many useful properties
- The result of the modulo operation for negative operands depends on the definition (programming language)
- Modular division is defined as multiplication by the modular multiplicative inverse (where defined)

Draw the Hasse diagram of a Boolean algebra of order 4 (16 elements).

Sorry, it was removed! :)

Digit sum: Sum of all of the digits of a number

Digital root: Single-digit result of repeatedly calculating the digit sum

Example in base 10:

The digit sum of 1839275 is 1+8+3+9+2+7+5 = 35

The digit sum of 35 is 3+5 = 8

The digital root of 1839275 is 8

Example in base 16:

The digit sum of A8FB is A+8+F+B (10+8+15+11) = (44) 2C

The digit sum of 2C is 2+C (2+12) = (14) E

The digital root of A8FB is E

- The digital root of a number
`n`in base`b`is equal to`n`mod (`b`-1)

(dr(`n`_{b}) =`n`mod (`b`-1)) - Reason: For
`n`=`d`_{k}...`d`_{1}`d`_{0}=`d`_{k}×`b`^{k}+`d`_{(k-1)}×`b`^{(k-1)}+...+`d`_{1}×`b`^{1}+`d`_{0}×`b`^{0},

because`b`^{m}≡_{(mod (b-1))}1^{m}= 1,`n`≡_{(mod (b-1))}`d`_{k}+`d`_{(k-1)}+...+`d`_{1}+`d`_{0}^{ }

- If
`b`=10, then`b`-1=9 - Example in base 10: 1839275 mod 9 = 8
- Example in base 16: A8FB mod F = E
- This can be used for cross-checking the result of an arithmetic
operation:

`a`·`b`=`c`⇒ dr(dr(`a`) · dr(`b`)) ≡ dr(`c`)

`a`·`b`≠`c`⇐ dr(dr(`a`) · dr(`b`)) ≢ dr(`c`)

- Example (homework): Only one of the two equations below is correct. Which
one?

1346021 · 6292041 = 8469219318861

3615137 · 8749019 = 31628902349603

- From a (famous) book about (formal) language theory

Please ignore pieces about language theory and automata theory - Selected because it is general and easily readable
- Sometimes, is uses a different mathematical "dialect"
- The contents is part of the final exam

- Very important tool for Mathematics

(the goal of Mathematics is to prove as many useful and interesting theorems and properties from very few axioms and definitions) - For computer science and information technology:
- Proofs of properties of data structures
- Proofs of correctness or other properties of algorithms
- Proofs of correctness or other properties (e.g. speed) of a program
- Proofs of correctness of program transformations

- Intuition
- (Program) test: Individual test cases
- Level of detail of a proof:
- Rough proof

Example:`x`+ (`y`+ 1) = (`x`+ 1) +`y` - Detailled proof

Example:`x`+ (`y`+ 1)

=^{(commutativity of addition)}

`x`+ (1 +`y`)

=^{(associativity of addition)}

(`x`+ 1) +`y`

- Rough proof
- How to express a proof:
- Mostly textual proof
- Proof using formulæ
- Automatically verified proof
- Mixtures

- Deductive proof (proof by deduction)
- Inductive proof (proof by induction)
- Proof by contradiction
- Proof by counterexample
- Proof about sets
- Proof by enumeration

(`S` is the the theorem to be proven, expressed as a proposition or
predicate)

- Deductive proof: (
`H`∧ (`H`→`S`)) ⇒`S`, etc. - Inductive proof:
`S`(0) ∧ (∀`k`∈ℕ:`S`(`k`) →`S`(`k`+1)) ⇒ (∀`n∈ℕ`:`S`(`n`))

- Proof by contradiction: (¬
`S`→`S`) ⇒`S`Confirmation:

`S`¬ `S`¬ `S`→`S`(¬ `S`→`S`) →`S`F T F T T F T T - Proof by counterexample:

(∃`x`:¬S(`x`)) ⇒ ¬∀`x`: S(`x`) - Proof by enumeration: example: truth table

- Deduction: Conclude some specific fact from some general law
- Induction: Infer some general law from some sample observations
- Mathematical induction
- Goal: Proof of some property about (almost) all parts of some structure
- The integers are the most frequent "structure", but also tree structures,...
- Mathematical induction is actually a kind of deduction, not induction

- Applications of mathematical induction in information technology:
- Design and proof of properties of algorithms and data structures
- Proofs about programs:
- Loops
- Recursion

`S`(0) ∧ (∀`k`∈ℕ: `S`(`k`) →
`S`(`k`+1)) ⇒ (∀`n∈ℕ`:
`S`(`n`))

- Base case (basis (step)): proof of
`S`(0) - Inductive step (induction, inductive case): proof of
∀
`k`∈ℕ:`S`(`k`) →`S`(`k`+1)

- (inductive) Assumption: clearly state
`S`(`k`) - Actual proof of inductive step
Method: Formula manipulation so that the assumption can be used

- (inductive) Assumption: clearly state

Look at the following equations:

= 0 (adding up no numbers results in 0)

1 = 1

1 + 3 = 4

1 + 3 + 5 = 9

1 + 3 + 5 + 7 = 16

1 + 3 + 5 + 7 + 9 = 25

Express the general rule contained in the above additions as a hypothesis.

Prove the hypothesis using Mathematical induction.

- The right side of the equations is
`n`^{2}(`n`≥0) - The left side of the equations is the sum of the (consecutive)
`n`smallest odd numbers (`n`≥0) - Hypothesis: The sum of the
`n`smallest odd numbers is`n`^{2}(`n`≥0)

∀`n`≥0: ∑^{n}_{i=1}2`i`-1 =`n`^{2}

Prove the property for `n` = 0:
∑^{0}_{i=1} 2`i`-1 = 0 =
0^{2}

a. Inductive assumption: Assume that the property is true for some
`k`≥0: ∑^{k}_{i=1}
2`i`-1 = `k`^{2}

b. Show that the property is true for `k` + 1:

∑^{(k+1)}_{i=1} 2`i`-1 =
(`k`+1)^{2}

[start with right side]

(`k`+1)^{2} [expansion]

= `k`^{2} + 2`k +` 1 [arithmetic]

= `k`^{2} + 2`k +` 2 - 1 [arithmetic]

= `k`^{2} + 2(`k+`1) - 1 [use
assumption]

= ∑^{k}_{i=1}2`i`-1 +
2(`k+`1) - 1 [property of ∑]

= ∑^{k+1}_{i=1} 2`i`-1
Q.E.D.

- Start with
`S`(1) or`S`(2),... instead of`S`(0)

S(`b`) ∧ (∀`k`∈ℕ,`k`≥`b`:`S`(`k`) →`S`(`k`+1)) ⇒ (∀`n∈ℕ, n`≥`b`:`S`(`n`))

We can interpret this as proving`T`(`n`-`b`) =`S`(`n`), so that we again start at 0

- In the proof of step 2 for
`S`(`k`+1), use not only

`S`(`k`), but some or all`S`(`j`) where 0≤`j``≤``k`

(this is called*strong induction*or*complete induction*)

`S`(0) ∧ (∀`k`∈ℕ: (∀`i`(0≤`i`≤`k`):`S`(`i`)) →`S`(`k`+1)) ⇒ ∀`n∈ℕ`:`S`(`n`)

- Limit the proof to some subset of integers (examples: even numbers only,
2
^{m}only)

We can interpret this as proving`T`(`n`/2) or`T`(`m`= log_{2}`n`) - Proof not about integers, but about something that can be ordered using integers
- Branching tree structure or some other structure (e.g. (half) order)

- Theorem to be proved:

In a binary tree with`l`leaves, the number of nodes is`n`= 2`l`-1 - Definition of binary tree:

Directed graph with the following conditions:

- No cycles
- If there is a directed edge (arrow) from node
`a`to node`b`, then`a`is the*parent*of`b`, and`b`is the*child*of`a`

- All nodes except the
*root*have a parent - There are two types of nodes:
- Leaves, which have no children
*Internal nodes*, which have exactly two children

We start with a very small tree consisting only of the root, and grow it step by step. We can create any shape of binary tree this way.

- Base case: In a tree with only the root node,
`n`=1 and`l`=1, therefore`n`= 2`l`-1 is correct. - Inductive step: Grow the tree one step by replacing a leaf with an
internal node with two leaves.

Denote the number of nodes before growing by`n`, the number of leaves before growing by`l`, the number of nodes after growth by`n`', and the number of leaves after growth by`l`'. We need to prove`n`' = 2`l`'-1.- Inductive assumption:
`n`= 2`l`-1 - In one growth step, the number of nodes increases by two:
`n`'=`n`+2 (1)

In one growth step, the number of leaves increases by two but is reduced by one:`l`'=`l`+2-1=`l`+1;`l`=`l`'-1 (2)

`n`' [(1)]

=`n`+2 [assumption]

= 2`l`-1+2 [(2)]

= 2(`l`'-1)-1+2 [arithmetic]

= 2`l`'-1 Q.E.D.

- Inductive assumption:

(no need to submit)

- Answer the question on the slide "Application of Congruence: Casting out Nines"
- Find out the problem in the following proof:
Theorem: All

`n`lines on a plane that are not parallel to each other will cross in a single point.Proof:

- Base case: Obviously true for
`n`=2 - Induction:
- Assumption:
`k`lines cross in a single point. - For
`k`+1 lines, both the first`k`lines and the last`k`lines will cross in a single point, and this point will have to be the same because it is shared by`k`-1 lines.

- Assumption:

- Base case: Obviously true for
- Read the handout
- Find a question regarding past examinations that you can ask in the next lecture.

- digit
- 数字、桁
- digit sum
- 数字和
- digital root
- 数字根
- casting out nines
- 九去法
- (formal) language theory
- 言語理論
- automata theory
- オートマトン理論
- proof
- 証明
- to prove
- 証明する
- data structure
- データ構造
- intuition
- 直感
- test case
- テスト・ケース
- deductive proof
- 演繹的証明
- inductive proof
- 帰納的証明
- proof by contradiction
- 背理法
- proof by counterexample
- 反例による証明
- proof about sets
- 集合についての証明
- proof by enumeration
- 列挙による「証明」
- mathematical induction
- 数学的帰納法
- structure
- 構造
- loop
- 繰返し
- base case
- 基底
- inductive step
- 帰納
- inductive assumption
- (帰納の) 仮定
- recursion
- 再帰
- hypothesis
- 仮説
- equation
- 方程式
- consecutive
- 連続的な
- odd (number)
- 奇数
- inductive assumption
- (帰納の) 仮定
- strong induction
- 完全帰納法 (または累積帰納法)
- structural induction
- 構造的帰納法
- binary tree
- 二分木
- node (of a tree/graph)
- 節
- leaf (of a tree)
- 葉
- directed graph
- 有効グラフ
- cycle (of a graph)
- 閉路
- parent (in a tree)
- 親
- child (in a tree)
- 子
- root (of a tree)
- 根
- internal node
- 内部節
- parallel
- 平行