Swift Programming and Logic

NSSpain 2019 (Sep 20, 2019)
https://2019.nsspain.com

Video: https://vimeo.com/362179375
Code: https://github.com/inamiy/SwiftAndLogic

Transcript

1. Swift Programming ∧ Logic 2019/09/20 NSSpain 2019 Yasuhiro Inami / @inamiy
2. Logic A method of making a conclusion from given premises using the concept of Truth
3. ! NSSpain is iOS Conference iOS Conference is Awesome Therefore, 
 ! NSSpain is Awesome
4. If A then B If B then C Therefore, if A then C
5. Q. Is this always true?
6. I am Gorilla Gorilla is Handsome Therefore, 
 I am Handsome
8. What is True? How should we define 
 “correctness” more precisely?
9. Separate the definition of “correctness” 1. Form (Syntax) 2. Meaning (Semantics)
10. Syntax Using symbolic formulas and inference rules to systematically deduce a new formula
11. Patterns of Formula If A then B A and B A or B not A A → B A ∧ B A ∨ B ¬A
12. Symbols in Formula Operators Variables Constants ∧ , ∨ , ¬, → A, B, C, ⋯ ⊤ , ⊥
13. Examples of Formula A ∧ (B → C) (A ∨ B) ∧ (C → D) (¬A → ⊥ ) ∨ (¬B ∧ ⊤ )
14. Example of Inference Rule: Modus Ponens A → B A B Inference Rules as a part of axiomatic system Premise 1: If A then B Premise 2: A Conclusion: B
15. Example of Proof Tree
16. Semantics Interpreting the meaning of formula by assigning truth value (true or false)
17. Truth Table (Interpretation of the formula) A B ¬A A∧B A∨B A→B 1 1 0 1 1 1 1 0 0 0 1 0 0 1 1 0 1 1 0 0 1 0 0 1 Valuation A → B A ∧ B A ∨ B ¬A
18. Example of Truth Table A B ¬A ¬A∨B A→B (¬A∨B) → (A→B) (A→B) → (¬A∨B) 1 1 0 1 1 1 1 1 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0 1 1 1 1 1 Some formulas are always 1 (true)
19. (A → B) ↔ (¬A ∨ B) Tautology: Formulas that are always true in every possible interpretation P ↔ Q := (P → Q) ∧ (Q → P)
20. Examples of Tautology A → A Law of Identity A ∨ ¬A Law of Excluded Middle
21. Examples of Tautology (A → B) → ((B → C) → (A → C)) ((((A → B) → (¬C → ¬D)) → C) → E) → ((E → A) → (D → A)) ¬(A ∧ ¬A) (A ∧ ¬A) → B ((A → B) → A) → A ¬¬A → A (A → B) ↔ (¬B → ¬A) ¬(A ∧ B) ↔ (¬A ∨ ¬B) ¬(A ∨ B) ↔ (¬A ∧ ¬B)
22. (A → B) → ((B → C) → (A → C)) ((((A → B) → (¬C → ¬D)) → C) → E) → ((E → A) → (D → A)) ¬(A ∧ ¬A) (A ∧ ¬A) → B ((A → B) → A) → A ¬¬A → A (A → B) ↔ (¬B → ¬A) ¬(A ∧ B) ↔ (¬A ∨ ¬B) ¬(A ∨ B) ↔ (¬A ∧ ¬B) Examples of Tautology Law of 
 Contradiction Principle of
 Explosion Double Negation
 Elimination Peirce’s Law Law of
 Contraposition De Morgan’s Laws Transitive Law Meredith’s Axiom
23. Examples of Tautology There are infinite number of tautologies… Can we abstract into a finite subset as a basis? A → ¬¬A A → ¬¬¬¬A A → ¬¬¬¬¬¬A ⋯
24. Building Formal System
25. Formal System Axiom l Base premises (part of tautologies) Inference Rules l Deduces new formula from existing ones Using Axioms and Inference Rules to deduce Theorem (all possible tautologiesʣ
26. Styles of Formal System •Gentzen Style l Many inference rules •Natural Deduction l + No axioms •Sequent Calculus l + 1 axiom (identity) •Hilbert Style •Many axioms + 1 inference rule (modus ponens)
27. Gentzen Natural Deduction A B A ∧ B A ∧ B A A ∧ B B A A ∨ B B A ∨ B A ∨ B C C C A → B A B B A → B ⊥ ¬A A ¬A ⊥ ⊥ A ⋮ [A] ¬¬A A ⋮ [A] ⋮ [B] ⋮ [A]
28. Hilbert Style A → B A B B → (A → B) (A → (B → C)) → ((A → B) → (A → C)) ¬¬A → A A → A ∨ B ⊥ → A B → A ∨ B (A → C) → ((B → C) → ((A ∨ B) → C)) A ∧ B → A A ∧ B → B A → (B → (A ∧ B)) (A → ¬A) → ¬A ¬A → (A → B) Modus ponens is the only available
 inference rule
29. Formulas look like
 Swift Programming
30. Logic 㱻 Swift Programming A → B A ∧ B A ∨ B ¬A := A → ⊥ 㱻 Function Tuple Either ⊥ Either<A, B> Never typealias Not<A> = (A) -> Never (A, B) (A) -> B Bottom
31. Gentzen Natural Deduction A B A ∧ B A ∧ B A A ∧ B B A A ∨ B B A ∨ B A ∨ B C C C A → B A B B A → B ⊥ ¬A A ¬A ⊥ ⊥ A ⋮ [A] ¬¬A A ⋮ [A] ⋮ [B] ⋮ [A]
32. /// `B ===> A → B` /// - Note: More formally, A ⊢ B ===> ⊢ A → B. func implyIntro<A, B>(_ b: B) -> ((A) -> B) { { _ in b } } /// `A, A → B ===> B` (Modus ponens) func implyElim<A, B>(_ f: (A) -> B, _ a: A) -> B { f(a) } A → B A B B A → B ⋮ [A]
33. /// `A, B ===> A ∧ B` func andIntro<A, B>(_ a: A, _ b: B) -> (A, B) { (a, b) } /// `A ∧ B ===> A` func andElim1<A, B>(_ ab: (A, B)) -> A { ab.0 } /// `A ∧ B ===> B` func andElim2<A, B>(_ ab: (A, B)) -> B { ab.1 } A B A ∧ B A ∧ B A A ∧ B B
34. /// `A ===> A ∨ B` func orIntro1<A, B>(_ a: A) -> Either<A, B> { .left(a) } /// `B ===> A ∨ B` func orIntro2<A, B>(_ b: B) -> Either<A, B> { .right(b) } /// `A ∨ B, A → C, B → C ===> C` func orElim<A, B, C>( _ e: Either<A, B>, _ ac: (A) -> C, _ bc: (B) -> C ) -> C { switch e { case let .left(a): return ac(a) case let .right(b): return bc(b) } } A A ∨ B B A ∨ B A ∨ B C C C ⋮ [A] ⋮ [B]
35. struct Not<A> { let f: (A) -> Never } /// `A ⊢ ⊥ ===> ⊢ ¬A` func notIntro<A>(_ x: Never) -> Not<A> { Not { _ in x } } /// `A, ¬A ===> ⊥` (NOTE: not using `fatalError`) func notElim<A>(_ a: A, _ notA: Not<A>) -> Never { notA.f(a) } ⊥ ¬A A ¬A ⊥ ⋮ [A]
36. /// `⊥ ===> A` func absurd<A>(_ x: Never) -> A { // Do nothing, but it compiles. } ⊥ A
37. Hilbert Style B → (A → B) (A → (B → C)) → ((A → B) → (A → C)) A → A ∨ B B → A ∨ B (A → C) → ((B → C) → ((A ∨ B) → C)) A ∧ B → A A ∧ B → B A → (B → (A ∧ B)) A → B A B Modus ponens is the only available
 inference rule ¬¬A → A ⊥ → A (A → ¬A) → ¬A ¬A → (A → B)
38. (A → C) → ((B → C) → ((A ∨ B) → C)) A → A ∨ B B → A ∨ B A ∧ B → A A ∧ B → B A → (B → (A ∧ B)) ¬¬A → A ⊥ → A (A → ¬A) → ¬A ¬A → (A → B) Hilbert Style A → B A B Modus ponens is the only available
 inference rule (A → (B → C)) → ((A → B) → (A → C)) A ∨ B := ¬A → B := ¬B → A A ∧ B := ¬(A → ¬B) := ¬(B → ¬A) ¬A := A → ⊥ NOTE: ∨, ∧, ¬ can be rewritten using → and ⊥ only B → (A → B)
39. Combinatory Logic Kxy = x Sxyz = xz(yz) I = SKK K : X → Y → X S : (Z → Y → X) → (Z → Y) → Z → X I : X → X
40. /// `K = A → (B → A)` func k<A, B>(_ a: A) -> (B) -> A { { _ in a } } /// `S = (A → (B → C)) → ((A → B) → (A → C))` func s<A, B, C>(_ a: @escaping (C) -> (A) -> B) -> (_ b: @escaping (C) -> A) -> (C) -> B { { b in { c in a(c)(b(c)) } } }
41. /// `I = SKK: A → A` func i<A>(_ a: A) -> A { let k_: (A) -> (A) -> A = k let skk: (A) -> A = s(k)(k_) return skk(a) } i("hello") // "hello" i(123) // 123
42. Logic ⇕ Swift Programming
44. ((A → B) → A) → A A ∨ ¬A ¬¬A → A ¬(A ∧ B) → (¬A ∨ ¬B) (A → B) → (¬A ∨ B) (¬B → ¬A) → (A → B) Law of Excluded Middle Double Negation Elimination (One of)
 Law of Contraposition (One of) De Morgan’s Law Material Implication Peirce’s Law NOTE: Converse
 is tautology Tautologies that can’t be implemented in Swift
45. /// `A ∨ ¬A` (Law of excluded middle) func excludedMiddle<A>() -> Either<A, Not<A>> { fatalError("Can't impl in Swift”) }
46. /// `A ∨ ¬A` (Law of excluded middle) func excludedMiddle<A>() -> Either<A, Not<A>> { fatalError("Can't impl in Swift”) } ANY LANGUAGES! (No Premises) A ∨ ¬A
47. /// `((A → B) → A) → A` func peirceLaw<A, B>() -> (((A) -> B) -> A) -> A { { (aba: ((A) -> B) -> A) in let ab: (A) -> B = { fatalError("Can't impl ") }() let a = aba(ab) return a } }
48. 8IBU
    XF
    TBX
    TP
    GBS
    JT
    ʜ Classical Logic Interpreting the meaning of formula by assigning truth value (true or false)
49. “→” in Classical Logic A → B Bool true false true or false (2 values)
50. “→” in Swift Programming Types Int Bool (A) -> B (Int)->Bool New type is constructed
51. Classical Logic ↓
 Constructive Logic
 (Intuitionistic Logic)
52. Intuitionistic Logic ⇕ Swift Programming
53. Natural Deduction in Intuitionistic Logic ⇕ (Simply) Typed 
 Lambda Calculus Curry-Howard Correspondence
54. Curry-Howard Correspondence Intuitionistic Logic Swift Programming Proposition Type Proof Program → Introduction Function / Closure Modus Ponens Function Application Axiom Global Variable Assumption Free Variable Discharged Assumption Bound Variable
55. Intuitionistic Logic
 Interpreting the meaning of formula by assigning truth value for each possible world
56. Possible World in Intuitionistic Logic A 0 B 0 A 1 B 0 A 1 B 1
57. Inheritance of truth value A 0 B 0 A 1 B 0 A 1 B 0 A = 1 will be 
 inherited to future (Never becomes A = 0) New Theorem
58. Inheritance of truth value A 0 ¬A 0 A 0 ¬A 1 A 0 ¬A 1 If ¬A = 1, A = 0 from now & future (Never becomes A = 1) inherit
59. Inheritance of truth value A 0 ¬A 0 A 0 ¬A 1 A 0 ¬A 1 If ¬A = 1, A = 0 from now & future (Never becomes A = 1) JOIFSJU A 0 ¬A 0 A ∨ ¬A
60. Inheritance of truth value A → B 1 A 0 B 0 A → B 1 A 1 B 1 A → B 1 A 1 B 1 inherit If A = 1, B = 1 
 can also be obtained Never becomes
 A = 1, B = 0
61. Inheritance of truth value "
    
    
    ͕ಘΒΕΔͱɺ
 #
    
    ΋ࣗಈతʹಘΒΕΔ A 0 B 0 A 1 B 0 A 1 B 1 A 0 B 1
62. Kripke Semantics • Kripke Frame l Ordered set of possible world 
 e.g. → → • Kripke Model l Assigning inheriting truth value 
 for every possible world on the Frame • Tautology in Intuitionistic Logic
 … For any frame and for any valuation (= for any model), 
 formula is always true "
    
    
    ͕ಘΒΕΔͱɺ
 #
    
    ΋ࣗಈతʹಘΒΕΔ
63. Classical Logic ⊂ Intuitionistic Logic Minimal Intuitionistic Classical A ∨ ¬A ⊥ → A → , ∧ , ∨ , ¬, ⊥ Formulas using A → A ∨ B A ∧ B → A Law of
 Contradiction Law of 
 Excluded Middle ⋮ NOTE: Doesn’t mean Intuitionistic Logic owns Law of Excluded Middle ”directly” (See next slide)
64. Glivenko’s Theorem: Classical to Intuitionistic Embedding Intuitionistic Classical A ∨ ¬A ¬¬(A ∨ ¬A) ¬¬ Double
 Negation
 Translation Law of
 Excluded Middle Double-negated
 Excluded Middle
65. ((A → B) → A) → A A ∨ ¬A ¬¬A → A ¬(A ∧ B) → (¬A ∨ ¬B) (A → B) → (¬A ∨ B) (¬B → ¬A) → (A → B) Law of Excluded Middle Double Negation Elimination (One of)
 Law of Contraposition (One of) De Morgan’s Law Material Implication Peirce’s Law NOTE: Converse
 is tautology Tautologies that can’t be implemented in Swift
66. ¬¬(((A → B) → A) → A) ¬¬(A ∨ ¬A) ¬¬(¬¬A → A) ¬¬(¬(A ∧ B) → (¬A ∨ ¬B)) ¬¬((A → B) → (¬A ∨ B)) ¬¬((¬B → ¬A) → (A → B)) Tautologies in Intuitionistic Logic Adding double-negation will hold in 
 Intuitionistic Logic!
67. ¬¬((A → B) → A) → ¬¬A ¬¬(A ∨ ¬A) ¬¬¬¬A → ¬¬A ¬¬¬(A ∧ B) → ¬¬(¬A ∨ ¬B) ¬¬(A → B) → ¬¬(¬A ∨ B) ¬¬(¬B → ¬A) → ¬¬(A → B) Tautologies in Intuitionistic Logic Using helper rule ¬¬(A → B) ¬¬A → ¬¬B
68. /// `¬¬(A ∨ ¬A)` (Law of excluded middle in Intuitionistic Logic) func excludedMiddle_IL<A>() -> Not<Not<Either<A, Not<A>>>> { Not<Not<Either<A, Not<A>>>> { notEither in let notA: Not<A> = Not { a in notEither.f(.left(a)) } let either: Either<A, Not<A>> = .right(notA) return notEither.f(either) } }
69. /// `¬¬¬¬A ===> ¬¬A` (Double negation elimination in IL) func doubleNegationElim_IL<A>( _ notNotNotNotA: Not<Not<Not<Not<A>>>> ) -> Not<Not<A>> { Not<Not<A>> { notA in notNotNotNotA.f( Not<Not<Not<A>>> { notNotA in notNotA.f(notA) } ) } }
70. /// `¬¬¬(A ∧ B) ===> ¬¬(¬A ∨ ¬B)` (De-Morgan's Law in IL) func deMorgan4_IL<A, B>(_ notNotNotAB: Not<Not<Not<(A, B)>>>) -> Not<Not<Either<Not<A>, Not<B>>>> { Not<Not<Either<Not<A>, Not<B>>>> { (notEither: Not<Either<Not<A>, Not<B>>>) in let notNotAB = Not<Not<(A, B)>> { notAB in let notB = Not<B> { b in let notA = Not<A> { a in notAB.f((a, b)) } let either: Either<Not<A>, Not<B>> = .left(notA) return notEither.f(either) } let either: Either<Not<A>, Not<B>> = .right(notB) return notEither.f(either) } return notNotNotAB.f(notNotAB) } }
71. /// `¬¬((A → B) → A) → ¬¬A` (Peirce's Law in IL) func peirceLaw_IL<A, B>() -> (Not<Not<((A) -> B) -> A>>) -> Not<Not<A>> { { notNotF in Not<Not<A>> { notA in let notABA = Not<((A) -> B) -> A> { aba in let ab: (A) -> B = { a in absurd(notElim(a, notA)) } let a = aba(ab) return notA.f(a) } return notNotF.f(notABA) } } }
72. Peirce’s Law → Call with Current Continuation ¬¬(A → B) ¬¬A → ¬¬B ((A → ¬¬B) → ¬¬A) → ¬¬A Here, are used to gain ¬¬(A → B) A → ¬¬B ¬¬(((A → B) → A) → A) Peirce’s Law
73. /// Continuation. typealias Cont<R, A> = (@escaping (A) -> R) -> R /// /// Call with Current Continuation. /// - Peirce (classical): `((A → B) → A) → A` /// - CallCC (intuitionistic): `((A → M<B>) → M<A>) → M<A>` /// /// - Note: `callCC` is like control operators e.g. `goto`, `return`, `throw`. /// func callCC<A, B, R>( _ f: @escaping (_ exit: @escaping (A) -> Cont<R, B>) -> Cont<R, A> ) -> Cont<R, A> { { outer in f { a in { _ in outer(a) } }(outer) } }
74. /// - DoubleNegationElim (classical): `((A → ⊥) → ⊥) ===> A` /// - DoubleNegationElim (intuitionistic): `((A → M<⊥>) → M<⊥>) ===> M<A>` func doubleNegationElim_callCC<R, A>( _ doubleNegation: @escaping ( _ neg: @escaping (A) -> Cont<R, Never> ) -> Cont<R, Never> ) -> Cont<R, A> { callCC { exit -> Cont<R, A> in flatMap(doubleNegation(exit), absurd) } }
76. Recap •Syntax and Semantics •Tautology as “always true” formula •Formal System: Axioms and Inference Rules •Intuitionistic Logic 㱻 Swift Programming (Curry-Howard) •Writing Law of Excluded Middle in Swift (Glivenko) •Learning Logic will help understand Swift’s type (system)
77. Sample Code
 http://github.com/inamiy/SwiftAndLogic
78. Gracias! Yasuhiro Inami @inamiy