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

https://www.sw.it.aoyama.ac.jp/2019/Math1/lecture14.html

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

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

- January 24: 15th lecture
- January 31,
**11:10**-12:35: Term final exam

About makeup classes: The material in the makeup class is part of the final exam.

*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). In this lecture, we use the Mathematical definition.
- Modular division is defined as multiplication by the
*modular multiplicative inverse*(where defined)

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:

`x`·`y`=`z`⇒ dr(dr(`x`) · dr(`y`)) ≡_{mod (b-1)}dr(`z`)

`x`·`y`≠`z`⇐ dr(dr(`x`) · dr(`y`)) ≢_{mod (b-1)}dr(`z`)

- 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 is not a proof
- (Program) test: Individual test cases are not enough for a proof
- 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

- Mostly textual proof
- Proof using formulæ
- Automatically verified proof
- Mixtures of the above

- 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

4 = 1 + 3

9 = 1 + 3 + 5

16 = 1 + 3 + 5 + 7

25 = 1 + 3 + 5 + 7 + 9

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

Prove the hypothesis using Mathematical induction.

- The left side of the equations is
`n`^{2}(`n`≥0) - The right 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}for`n`≥0:

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

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`^{2} =
∑^{k}_{i=1} 2`i`-1

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

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

[start with left 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

Both the basis and the induction are true. This proves the hypothesis. 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, lattice,...): structural induction

- 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

- Inductive assumption:

Both the basis and the induction are true. This proves the hypothesis. Q.E.D.

(no need to submit)

- Answer the question on the slide "Application of Congruence: Casting out Nines"
- Find 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
- 平行