septiembre 2021 – Página 4

Pruebas de que la función espejo de los árboles binarios es involutiva

PorJosé A. Alonso 12 septiembre 20218 septiembre 2021

El árbol correspondiente a

/ \

2 4

/ \

1 5

se puede representar por el término

   nodo 3 (nodo 2 (hoja 1) (hoja 5)) (hoja 4)

1	nodo 3 (nodo 2 (hoja 1) (hoja 5)) (hoja 4)

usado el tipo de dato arbol definido por

   inductive arbol (α : Type) : Type
   | hoja : α → arbol
   | nodo : α → arbol → arbol → arbol

inductive arbol (α : Type) : Type

| hoja : α → arbol

| nodo : α → arbol → arbol → arbol

La imagen especular del árbol anterior es

/ \

4 2

/ \

5 1

cuyo término es

   nodo 3 (hoja 4) (nodo 2 (hoja 5) (hoja 1))

1	nodo 3 (hoja 4) (nodo 2 (hoja 5) (hoja 1))

La definición de la función que calcula la imagen especular es

   def espejo : arbol α → arbol α
   | (hoja x)     := hoja x
   | (nodo x i d) := nodo x (espejo d) (espejo i)

def espejo : arbol α → arbol α

| (hoja x) := hoja x

| (nodo x i d) := nodo x (espejo d) (espejo i)

Demostrar que la función espejo es involutiva; es decir,

   espejo (espejo a) = a

1	espejo (espejo a) = a

Para ello, completar la siguiente teoría de Lean:

import tactic

variable  {α : Type}

inductive arbol (α : Type) : Type
| hoja : α → arbol
| nodo : α → arbol → arbol → arbol

namespace arbol

variables (a i d : arbol α)
variable  (x : α)

def espejo : arbol α → arbol α
| (hoja x)     := hoja x
| (nodo x i d) := nodo x (espejo d) (espejo i)

example :
  espejo (espejo a) = a :=
sorry

end arbol

import tactic

variable {α : Type}

inductive arbol (α : Type) : Type

| hoja : α → arbol

| nodo : α → arbol → arbol → arbol

namespace arbol

variables (a i d : arbol α)

variable (x : α)

def espejo : arbol α → arbol α

| (hoja x) := hoja x

| (nodo x i d) := nodo x (espejo d) (espejo i)

example :

espejo (espejo a) = a :=

sorry

end arbol

[expand title=»Soluciones con Lean»]

import tactic

variable  {α : Type}

inductive arbol (α : Type) : Type
| hoja : α → arbol
| nodo : α → arbol → arbol → arbol

namespace arbol

variables (a i d : arbol α)
variable  (x : α)

def espejo : arbol α → arbol α
| (hoja x)     := hoja x
| (nodo x i d) := nodo x (espejo d) (espejo i)

@[simp]
lemma espejo_1 :
  espejo (hoja x) = hoja x :=
espejo.equations._eqn_1 x

@[simp]
lemma espejo_2 :
  espejo (nodo x i d) = nodo x (espejo d) (espejo i) :=
espejo.equations._eqn_2 x i d

-- 1ª demostración
example :
  espejo (espejo a) = a :=
begin
  induction a with x x i d Hi Hd,
  { rw espejo_1,
    rw espejo_1, },
  { rw espejo_2,
    rw espejo_2,
    rw Hi,
    rw Hd, },
end

-- 2ª demostración
example :
  espejo (espejo a) = a :=
begin
  induction a with x x i d Hi Hd,
  { calc espejo (espejo (hoja x))
         = espejo (hoja x)
             : congr_arg espejo (espejo_1 x)
     ... = hoja x
             : espejo_1 x, },
  { calc espejo (espejo (nodo x i d))
         = espejo (nodo x (espejo d) (espejo i))
             : congr_arg espejo (espejo_2 i d x)
     ... = nodo x (espejo (espejo i)) (espejo (espejo d))
             : espejo_2 (espejo d) (espejo i) x
     ... = nodo x i (espejo (espejo d))
             : congr_arg2 (nodo x) Hi rfl
     ... = nodo x i d
             : congr_arg2 (nodo x) rfl Hd, },
end

-- 3ª demostración
example :
  espejo (espejo a) = a :=
begin
  induction a with x x i d Hi Hd,
  { calc espejo (espejo (hoja x))
         = espejo (hoja x)
             : congr_arg espejo (espejo_1 x)
     ... = hoja x
             : by rw espejo_1, },
  { calc espejo (espejo (nodo x i d))
         = espejo (nodo x (espejo d) (espejo i))
             : congr_arg espejo (espejo_2 i d x)
     ... = nodo x (espejo (espejo i)) (espejo (espejo d))
             : by rw espejo_2
     ... = nodo x i (espejo (espejo d))
             : by rw Hi
     ... = nodo x i d
             : by rw Hd, },
end

-- 4ª demostración
example :
  espejo (espejo a) = a :=
begin
  induction a with x x i d Hi Hd,
  { calc espejo (espejo (hoja x))
         = espejo (hoja x)
             : by simp
     ... = hoja x
             : by simp },
  { calc espejo (espejo (nodo x i d))
         = espejo (nodo x (espejo d) (espejo i))
             : by simp
     ... = nodo x (espejo (espejo i)) (espejo (espejo d))
             : by simp
     ... = nodo x i (espejo (espejo d))
             : by simp [Hi]
     ... = nodo x i d
             : by simp [Hd], },
end

-- 5ª demostración
example :
  espejo (espejo a) = a :=
begin
  induction a with _ x i d Hi Hd,
  { simp, },
  { simp [Hi, Hd], },
end

-- 6ª demostración
example :
  espejo (espejo a) = a :=
by induction a ; simp [*]

-- 7ª demostración
example :
  espejo (espejo a) = a :=
arbol.rec_on a
  ( assume x,
    calc espejo (espejo (hoja x))
         = espejo (hoja x)
             : congr_arg espejo (espejo_1 x)
     ... = hoja x
             : espejo_1 x)
  ( assume x i d,
    assume Hi : espejo (espejo i) = i,
    assume Hd : espejo (espejo d) = d,
    calc espejo (espejo (nodo x i d))
         = espejo (nodo x (espejo d) (espejo i))
             : congr_arg espejo (espejo_2 i d x)
     ... = nodo x (espejo (espejo i)) (espejo (espejo d))
             : by rw espejo_2
     ... = nodo x i (espejo (espejo d))
             : by rw Hi
     ... = nodo x i d
             : by rw Hd )

-- 8ª demostración
example :
  espejo (espejo a) = a :=
arbol.rec_on a
  (λ x, by simp )
  (λ x i d Hi Hd, by simp [Hi,Hd])

-- 9ª demostración
lemma espejo_espejo :
  ∀ a : arbol α, espejo (espejo a) = a
| (hoja x)     := by simp
| (nodo x i d) := by simp [espejo_espejo i, espejo_espejo d]

end arbol

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

import tactic

variable {α : Type}

inductive arbol (α : Type) : Type

| hoja : α → arbol

| nodo : α → arbol → arbol → arbol

namespace arbol

variables (a i d : arbol α)

variable (x : α)

def espejo : arbol α → arbol α

| (hoja x) := hoja x

| (nodo x i d) := nodo x (espejo d) (espejo i)

@[simp]

lemma espejo_1 :

espejo (hoja x) = hoja x :=

espejo.equations._eqn_1 x

@[simp]

lemma espejo_2 :

espejo (nodo x i d) = nodo x (espejo d) (espejo i) :=

espejo.equations._eqn_2 x i d

-- 1ª demostración

example :

espejo (espejo a) = a :=

begin

induction a with x x i d Hi Hd,

{ rw espejo_1,

rw espejo_1, },

{ rw espejo_2,

rw espejo_2,

rw Hi,

rw Hd, },

end

-- 2ª demostración

example :

espejo (espejo a) = a :=

begin

induction a with x x i d Hi Hd,

{ calc espejo (espejo (hoja x))

= espejo (hoja x)

: congr_arg espejo (espejo_1 x)

... = hoja x

: espejo_1 x, },

{ calc espejo (espejo (nodo x i d))

= espejo (nodo x (espejo d) (espejo i))

: congr_arg espejo (espejo_2 i d x)

... = nodo x (espejo (espejo i)) (espejo (espejo d))

: espejo_2 (espejo d) (espejo i) x

... = nodo x i (espejo (espejo d))

: congr_arg2 (nodo x) Hi rfl

... = nodo x i d

: congr_arg2 (nodo x) rfl Hd, },

end

-- 3ª demostración

example :

espejo (espejo a) = a :=

begin

induction a with x x i d Hi Hd,

{ calc espejo (espejo (hoja x))

= espejo (hoja x)

: congr_arg espejo (espejo_1 x)

... = hoja x

: by rw espejo_1, },

{ calc espejo (espejo (nodo x i d))

= espejo (nodo x (espejo d) (espejo i))

: congr_arg espejo (espejo_2 i d x)

... = nodo x (espejo (espejo i)) (espejo (espejo d))

: by rw espejo_2

... = nodo x i (espejo (espejo d))

: by rw Hi

... = nodo x i d

: by rw Hd, },

end

-- 4ª demostración

example :

espejo (espejo a) = a :=

begin

induction a with x x i d Hi Hd,

{ calc espejo (espejo (hoja x))

= espejo (hoja x)

: by simp

... = hoja x

: by simp },

{ calc espejo (espejo (nodo x i d))

= espejo (nodo x (espejo d) (espejo i))

: by simp

... = nodo x (espejo (espejo i)) (espejo (espejo d))

: by simp

... = nodo x i (espejo (espejo d))

: by simp [Hi]

... = nodo x i d

: by simp [Hd], },

end

-- 5ª demostración

example :

espejo (espejo a) = a :=

begin

induction a with _ x i d Hi Hd,

{ simp, },

{ simp [Hi, Hd], },

end

-- 6ª demostración

example :

espejo (espejo a) = a :=

by induction a ; simp [*]

-- 7ª demostración

example :

espejo (espejo a) = a :=

arbol.rec_on a

( assume x,

calc espejo (espejo (hoja x))

= espejo (hoja x)

: congr_arg espejo (espejo_1 x)

... = hoja x

: espejo_1 x)

( assume x i d,

assume Hi : espejo (espejo i) = i,

assume Hd : espejo (espejo d) = d,

calc espejo (espejo (nodo x i d))

= espejo (nodo x (espejo d) (espejo i))

: congr_arg espejo (espejo_2 i d x)

... = nodo x (espejo (espejo i)) (espejo (espejo d))

: by rw espejo_2

... = nodo x i (espejo (espejo d))

: by rw Hi

... = nodo x i d

: by rw Hd )

-- 8ª demostración

example :

espejo (espejo a) = a :=

arbol.rec_on a

(λ x, by simp )

(λ x i d Hi Hd, by simp [Hi,Hd])

-- 9ª demostración

lemma espejo_espejo :

∀ a : arbol α, espejo (espejo a) = a

| (hoja x) := by simp

| (nodo x i d) := by simp [espejo_espejo i, espejo_espejo d]

end arbol

Se puede interactuar con la prueba anterior en esta sesión con Lean.

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="lean"> y otra con </pre>
[/expand]

[expand title=»Soluciones con Isabelle/HOL»]

theory Pruebas_de_que_la_funcion_espejo_de_los_arboles_binarios_es_involutiva
imports Main
begin

datatype 'a arbol = hoja "'a"
                  | nodo "'a" "'a arbol" "'a arbol"

fun espejo :: "'a arbol ⇒ 'a arbol" where
  "espejo (hoja x)     = (hoja x)"
| "espejo (nodo x i d) = (nodo x (espejo d) (espejo i))"

(* 1ª demostración *)
lemma
  fixes a :: "'b arbol"
  shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
  fix x
  show "?P (hoja x)"
    by (simp only: espejo.simps(1))
next
  fix x
  fix i assume h1: "?P i"
  fix d assume h2: "?P d"
  show "?P (nodo x i d)"
  proof -
    have "espejo (espejo (nodo x i d)) =
          espejo (nodo x (espejo d) (espejo i))"
      by (simp only: espejo.simps(2))
    also have "… = nodo x (espejo (espejo i)) (espejo (espejo d))"
      by (simp only: espejo.simps(2))
    also have "… = nodo x i d"
      by (simp only: h1 h2)
    finally show ?thesis
      by this
 qed
qed

(* 2ª demostración *)
lemma
  fixes a :: "'b arbol"
  shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
  fix x
  show "?P (hoja x)"  by simp
next
  fix x
  fix i assume h1: "?P i"
  fix d assume h2: "?P d"
  show "?P (nodo x i d)"
  proof -
    have "espejo (espejo (nodo x i d)) =
          espejo (nodo x (espejo d) (espejo i))" by simp
    also have "… = nodo x (espejo (espejo i)) (espejo (espejo d))"
      by simp
    also have "… = nodo x i d" using h1 h2 by simp
    finally show ?thesis .
 qed
qed

(* 3ª demostración *)
lemma
  "espejo (espejo a ) = a"
by (induct a) simp_all

end

theory Pruebas_de_que_la_funcion_espejo_de_los_arboles_binarios_es_involutiva

imports Main

begin

datatype 'a arbol = hoja "'a"

| nodo "'a" "'a arbol" "'a arbol"

fun espejo :: "'a arbol ⇒ 'a arbol" where

"espejo (hoja x) = (hoja x)"

| "espejo (nodo x i d) = (nodo x (espejo d) (espejo i))"

(* 1ª demostración *)

lemma

fixes a :: "'b arbol"

shows "espejo (espejo a) = a" (is "?P a")

proof (induct a)

fix x

show "?P (hoja x)"

by (simp only: espejo.simps(1))

fix x

fix i assume h1: "?P i"

fix d assume h2: "?P d"

show "?P (nodo x i d)"

proof -

have "espejo (espejo (nodo x i d)) =

espejo (nodo x (espejo d) (espejo i))"

by (simp only: espejo.simps(2))

also have "… = nodo x (espejo (espejo i)) (espejo (espejo d))"

by (simp only: espejo.simps(2))

also have "… = nodo x i d"

by (simp only: h1 h2)

finally show ?thesis

by this

qed

(* 2ª demostración *)

lemma

fixes a :: "'b arbol"

shows "espejo (espejo a) = a" (is "?P a")

proof (induct a)

fix x

show "?P (hoja x)" by simp

fix x

fix i assume h1: "?P i"

fix d assume h2: "?P d"

show "?P (nodo x i d)"

proof -

have "espejo (espejo (nodo x i d)) =

espejo (nodo x (espejo d) (espejo i))" by simp

also have "… = nodo x (espejo (espejo i)) (espejo (espejo d))"

by simp

also have "… = nodo x i d" using h1 h2 by simp

finally show ?thesis .

qed

(* 3ª demostración *)

lemma

"espejo (espejo a ) = a"

by (induct a) simp_all

end

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="isar"> y otra con </pre>
[/expand]

Pruebas de equivalencia de definiciones de inversa

PorJosé A. Alonso 11 septiembre 20217 septiembre 2021

En Lean, está definida la función

   reverse : list α → list α

1	reverse : list α → list α

tal que (reverse xs) es la lista obtenida invirtiendo el orden de los elementos de xs. Por ejemplo,

   reverse  [3,2,5,1] = [1,5,2,3]

1	reverse [3,2,5,1] = [1,5,2,3]

Su definición es

   def reverse_core : list α → list α → list α
   | []     r := r
   | (a::l) r := reverse_core l (a::r)

   def reverse : list α → list α :=
   λ l, reverse_core l []

def reverse_core : list α → list α → list α

| [] r := r

| (a::l) r := reverse_core l (a::r)

def reverse : list α → list α :=

λ l, reverse_core l []

Una definición alternativa es

   def inversa : list α → list α
   | []        := []
   | (x :: xs) := inversa xs ++ [x]

def inversa : list α → list α

| [] := []

| (x :: xs) := inversa xs ++ [x]

Demostrar que las dos definiciones son equivalentes; es decir,

   reverse xs = inversa xs

1	reverse xs = inversa xs

Para ello, completar la siguiente teoría de Lean:

import data.list.basic
open list

variable  {α : Type*}
variable  (x : α)
variables (xs ys : list α)

def inversa : list α → list α
| []        := []
| (x :: xs) := inversa xs ++ [x]

example : reverse xs = inversa xs :=
sorry

import data.list.basic

open list

variable {α : Type*}

variable (x : α)

variables (xs ys : list α)

def inversa : list α → list α

| [] := []

| (x :: xs) := inversa xs ++ [x]

example : reverse xs = inversa xs :=

sorry

[expand title=»Soluciones con Lean»]

import data.list.basic
open list

variable  {α : Type*}
variable  (x : α)
variables (xs ys : list α)

-- Definición y reglas de simplificación de inversa
-- ================================================

def inversa : list α → list α
| []        := []
| (x :: xs) := inversa xs ++ [x]

@[simp]
lemma inversa_nil :
  inversa ([] : list α) = [] :=
rfl

@[simp]
lemma inversa_cons :
  inversa (x :: xs) = inversa xs ++ [x] :=
rfl

-- Reglas de simplificación de reverse_core
-- ========================================

@[simp]
lemma reverse_core_nil :
  reverse_core [] ys = ys :=
rfl

@[simp]
lemma reverse_core_cons :
  reverse_core (x :: xs) ys = reverse_core xs (x :: ys) :=
rfl

-- Lema auxiliar: reverse_core xs ys = (inversa xs) ++ ys
-- ======================================================

-- 1ª demostración del lema auxiliar
example :
  reverse_core xs ys = (inversa xs) ++ ys :=
begin
  induction xs with a as HI generalizing ys,
  { calc reverse_core [] ys
         = ys                        : reverse_core_nil ys
     ... = [] ++ ys                  : (nil_append ys).symm
     ... = inversa [] ++ ys          : congr_arg2 (++) inversa_nil.symm rfl, },
  { calc reverse_core (a :: as) ys
         = reverse_core as (a :: ys) : reverse_core_cons a as ys
     ... = inversa as ++ (a :: ys)   : (HI (a :: ys))
     ... = inversa as ++ ([a] ++ ys) : congr_arg2 (++) rfl singleton_append
     ... = (inversa as ++ [a]) ++ ys : (append_assoc (inversa as) [a] ys).symm
     ... = inversa (a :: as) ++ ys   : congr_arg2 (++) (inversa_cons a as).symm rfl},
end

-- 2ª demostración del lema auxiliar
example :
  reverse_core xs ys = (inversa xs) ++ ys :=
begin
  induction xs with a as HI generalizing ys,
  { calc reverse_core [] ys
         = ys                        : by rw reverse_core_nil
     ... = [] ++ ys                  : by rw nil_append
     ... = inversa [] ++ ys          : by rw inversa_nil },
  { calc reverse_core (a :: as) ys
         = reverse_core as (a :: ys) : by rw reverse_core_cons
     ... = inversa as ++ (a :: ys)   : by rw (HI (a :: ys))
     ... = inversa as ++ ([a] ++ ys) : by rw singleton_append
     ... = (inversa as ++ [a]) ++ ys : by rw append_assoc
     ... = inversa (a :: as) ++ ys   : by rw inversa_cons },
end

-- 3ª demostración del lema auxiliar
example :
  reverse_core xs ys = (inversa xs) ++ ys :=
begin
  induction xs with a as HI generalizing ys,
  { calc reverse_core [] ys
         = ys                        : rfl
     ... = [] ++ ys                  : rfl
     ... = inversa [] ++ ys          : rfl },
  { calc reverse_core (a :: as) ys
         = reverse_core as (a :: ys) : rfl
     ... = inversa as ++ (a :: ys)   : (HI (a :: ys))
     ... = inversa as ++ ([a] ++ ys) : rfl
     ... = (inversa as ++ [a]) ++ ys : by rw append_assoc
     ... = inversa (a :: as) ++ ys   : rfl },
end

-- 3ª demostración del lema auxiliar
example :
  reverse_core xs ys = (inversa xs) ++ ys :=
begin
  induction xs with a as HI generalizing ys,
  { calc reverse_core [] ys
         = ys                        : by simp
     ... = [] ++ ys                  : by simp
     ... = inversa [] ++ ys          : by simp },
  { calc reverse_core (a :: as) ys
         = reverse_core as (a :: ys) : by simp
     ... = inversa as ++ (a :: ys)   : (HI (a :: ys))
     ... = inversa as ++ ([a] ++ ys) : by simp
     ... = (inversa as ++ [a]) ++ ys : by simp
     ... = inversa (a :: as) ++ ys   : by simp },
end

-- 4ª demostración del lema auxiliar
example :
  reverse_core xs ys = (inversa xs) ++ ys :=
begin
  induction xs with a as HI generalizing ys,
  { by simp, },
  { calc reverse_core (a :: as) ys
         = reverse_core as (a :: ys) : by simp
     ... = inversa as ++ (a :: ys)   : (HI (a :: ys))
     ... = inversa (a :: as) ++ ys   : by simp },
end

-- 5ª demostración del lema auxiliar
example :
  reverse_core xs ys = (inversa xs) ++ ys :=
begin
  induction xs with a as HI generalizing ys,
  { simp, },
  { simp [HI (a :: ys)], },
end

-- 6ª demostración del lema auxiliar
example :
  reverse_core xs ys = (inversa xs) ++ ys :=
by induction xs generalizing ys ; simp [*]

-- 7ª demostración del lema auxiliar
example :
  reverse_core xs ys = (inversa xs) ++ ys :=
begin
  induction xs with a as HI generalizing ys,
  { rw reverse_core_nil,
    rw inversa_nil,
    rw nil_append, },
  { rw reverse_core_cons,
    rw (HI (a :: ys)),
    rw inversa_cons,
    rw append_assoc,
    rw singleton_append, },
end

-- 8ª demostración  del lema auxiliar
@[simp]
lemma inversa_equiv :
  ∀ xs : list α, ∀ ys, reverse_core xs ys = (inversa xs) ++ ys
| []         := by simp
| (a :: as)  := by simp [inversa_equiv as]

-- Demostraciones del lema principal
-- =================================

-- 1ª demostración
example : reverse xs = inversa xs :=
calc reverse xs
     = reverse_core xs [] : rfl
 ... = inversa xs ++ []   : by rw inversa_equiv
 ... = inversa xs         : by rw append_nil

-- 2ª demostración
example : reverse xs = inversa xs :=
by simp [inversa_equiv, reverse]

-- 3ª demostración
example : reverse xs = inversa xs :=
by simp [reverse]

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

import data.list.basic

open list

variable {α : Type*}

variable (x : α)

variables (xs ys : list α)

-- Definición y reglas de simplificación de inversa

-- ================================================

def inversa : list α → list α

| [] := []

| (x :: xs) := inversa xs ++ [x]

@[simp]

lemma inversa_nil :

inversa ([] : list α) = [] :=

rfl

@[simp]

lemma inversa_cons :

inversa (x :: xs) = inversa xs ++ [x] :=

rfl

-- Reglas de simplificación de reverse_core

-- ========================================

@[simp]

lemma reverse_core_nil :

reverse_core [] ys = ys :=

rfl

@[simp]

lemma reverse_core_cons :

reverse_core (x :: xs) ys = reverse_core xs (x :: ys) :=

rfl

-- Lema auxiliar: reverse_core xs ys = (inversa xs) ++ ys

-- ======================================================

-- 1ª demostración del lema auxiliar

example :

reverse_core xs ys = (inversa xs) ++ ys :=

begin

induction xs with a as HI generalizing ys,

{ calc reverse_core [] ys

= ys : reverse_core_nil ys

... = [] ++ ys : (nil_append ys).symm

... = inversa [] ++ ys : congr_arg2 (++) inversa_nil.symm rfl, },

{ calc reverse_core (a :: as) ys

= reverse_core as (a :: ys) : reverse_core_cons a as ys

... = inversa as ++ (a :: ys) : (HI (a :: ys))

... = inversa as ++ ([a] ++ ys) : congr_arg2 (++) rfl singleton_append

... = (inversa as ++ [a]) ++ ys : (append_assoc (inversa as) [a] ys).symm

... = inversa (a :: as) ++ ys : congr_arg2 (++) (inversa_cons a as).symm rfl},

end

-- 2ª demostración del lema auxiliar

example :

reverse_core xs ys = (inversa xs) ++ ys :=

begin

induction xs with a as HI generalizing ys,

{ calc reverse_core [] ys

= ys : by rw reverse_core_nil

... = [] ++ ys : by rw nil_append

... = inversa [] ++ ys : by rw inversa_nil },

{ calc reverse_core (a :: as) ys

= reverse_core as (a :: ys) : by rw reverse_core_cons

... = inversa as ++ (a :: ys) : by rw (HI (a :: ys))

... = inversa as ++ ([a] ++ ys) : by rw singleton_append

... = (inversa as ++ [a]) ++ ys : by rw append_assoc

... = inversa (a :: as) ++ ys : by rw inversa_cons },

end

-- 3ª demostración del lema auxiliar

example :

reverse_core xs ys = (inversa xs) ++ ys :=

begin

induction xs with a as HI generalizing ys,

{ calc reverse_core [] ys

= ys : rfl

... = [] ++ ys : rfl

... = inversa [] ++ ys : rfl },

{ calc reverse_core (a :: as) ys

= reverse_core as (a :: ys) : rfl

... = inversa as ++ (a :: ys) : (HI (a :: ys))

... = inversa as ++ ([a] ++ ys) : rfl

... = (inversa as ++ [a]) ++ ys : by rw append_assoc

... = inversa (a :: as) ++ ys : rfl },

end

-- 3ª demostración del lema auxiliar

example :

reverse_core xs ys = (inversa xs) ++ ys :=

begin

induction xs with a as HI generalizing ys,

{ calc reverse_core [] ys

= ys : by simp

... = [] ++ ys : by simp

... = inversa [] ++ ys : by simp },

{ calc reverse_core (a :: as) ys

= reverse_core as (a :: ys) : by simp

... = inversa as ++ (a :: ys) : (HI (a :: ys))

... = inversa as ++ ([a] ++ ys) : by simp

... = (inversa as ++ [a]) ++ ys : by simp

... = inversa (a :: as) ++ ys : by simp },

end

-- 4ª demostración del lema auxiliar

example :

reverse_core xs ys = (inversa xs) ++ ys :=

begin

induction xs with a as HI generalizing ys,

{ by simp, },

{ calc reverse_core (a :: as) ys

= reverse_core as (a :: ys) : by simp

... = inversa as ++ (a :: ys) : (HI (a :: ys))

... = inversa (a :: as) ++ ys : by simp },

end

-- 5ª demostración del lema auxiliar

example :

reverse_core xs ys = (inversa xs) ++ ys :=

begin

induction xs with a as HI generalizing ys,

{ simp, },

{ simp [HI (a :: ys)], },

end

-- 6ª demostración del lema auxiliar

example :

reverse_core xs ys = (inversa xs) ++ ys :=

by induction xs generalizing ys ; simp [*]

-- 7ª demostración del lema auxiliar

example :

reverse_core xs ys = (inversa xs) ++ ys :=

begin

induction xs with a as HI generalizing ys,

{ rw reverse_core_nil,

rw inversa_nil,

rw nil_append, },

{ rw reverse_core_cons,

rw (HI (a :: ys)),

rw inversa_cons,

rw append_assoc,

rw singleton_append, },

end

-- 8ª demostración del lema auxiliar

@[simp]

lemma inversa_equiv :

∀ xs : list α, ∀ ys, reverse_core xs ys = (inversa xs) ++ ys

| [] := by simp

| (a :: as) := by simp [inversa_equiv as]

-- Demostraciones del lema principal

-- =================================

-- 1ª demostración

example : reverse xs = inversa xs :=

calc reverse xs

= reverse_core xs [] : rfl

... = inversa xs ++ [] : by rw inversa_equiv

... = inversa xs : by rw append_nil

-- 2ª demostración

example : reverse xs = inversa xs :=

by simp [inversa_equiv, reverse]

-- 3ª demostración

example : reverse xs = inversa xs :=

by simp [reverse]

Se puede interactuar con la prueba anterior en esta sesión con Lean.

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="lean"> y otra con </pre>
[/expand]

[expand title=»Soluciones con Isabelle/HOL»]

theory Pruebas_de_equivalencia_de_definiciones_de_inversa
imports Main
begin

(* Definición alternativa *)
(* ====================== *)

fun inversa_aux :: "'a list ⇒ 'a list ⇒ 'a list" where
  "inversa_aux [] ys     = ys"
| "inversa_aux (x#xs) ys = inversa_aux xs (x#ys)"

fun inversa :: "'a list ⇒ 'a list" where
  "inversa xs = inversa_aux xs []"

(* Lema auxiliar: inversa_aux xs ys = (rev xs) @ ys *)
(* ================================================ *)

(* 1ª demostración del lema auxiliar *)
lemma
  "inversa_aux xs ys = (rev xs) @ ys"
proof (induct xs arbitrary: ys)
  fix ys :: "'a list"
  have "inversa_aux [] ys = ys"
    by (simp only: inversa_aux.simps(1))
  also have "… = [] @ ys"
    by (simp only: append.simps(1))
  also have "… = rev [] @ ys"
    by (simp only: rev.simps(1))
  finally show "inversa_aux [] ys = rev [] @ ys"
    by this
next
  fix a ::'a and xs :: "'a list"
  assume HI: "⋀ys. inversa_aux xs ys = rev xs@ys"
  show "⋀ys. inversa_aux (a#xs) ys = rev (a#xs)@ys"
  proof -
    fix ys
    have "inversa_aux (a#xs) ys = inversa_aux xs (a#ys)"
      by (simp only: inversa_aux.simps(2))
    also have "… = rev xs@(a#ys)"
      by (simp only: HI)
    also have "… = rev xs @ ([a] @ ys)"
      by (simp only: append.simps)
    also have "… = (rev xs @ [a]) @ ys"
      by (simp only: append_assoc)
    also have "… = rev (a # xs) @ ys"
      by (simp only: rev.simps(2))
    finally show "inversa_aux (a#xs) ys = rev (a#xs)@ys"
      by this
  qed
qed

(* 2ª demostración del lema auxiliar *)
lemma
  "inversa_aux xs ys = (rev xs) @ ys"
proof (induct xs arbitrary: ys)
  fix ys :: "'a list"
  have "inversa_aux [] ys = ys" by simp
  also have "… = [] @ ys" by simp
  also have "… = rev [] @ ys" by simp
  finally show "inversa_aux [] ys = rev [] @ ys" .
next
  fix a ::'a and xs :: "'a list"
  assume HI: "⋀ys. inversa_aux xs ys = rev xs@ys"
  show "⋀ys. inversa_aux (a#xs) ys = rev (a#xs)@ys"
  proof -
    fix ys
    have "inversa_aux (a#xs) ys = inversa_aux xs (a#ys)" by simp
    also have "… = rev xs@(a#ys)" using HI by simp
    also have "… = rev xs @ ([a] @ ys)" by simp
    also have "… = (rev xs @ [a]) @ ys" by simp
    also have "… = rev (a # xs) @ ys" by simp
    finally show "inversa_aux (a#xs) ys = rev (a#xs)@ys" .
  qed
qed

(* 3ª demostración del lema auxiliar *)
lemma
  "inversa_aux xs ys = (rev xs) @ ys"
proof (induct xs arbitrary: ys)
  fix ys :: "'a list"
  show "inversa_aux [] ys = rev [] @ ys" by simp
next
  fix a ::'a and xs :: "'a list"
  assume HI: "⋀ys. inversa_aux xs ys = rev xs@ys"
  show "⋀ys. inversa_aux (a#xs) ys = rev (a#xs)@ys"
  proof -
    fix ys
    have "inversa_aux (a#xs) ys = rev xs@(a#ys)" using HI by simp
    also have "… = rev (a # xs) @ ys" by simp
    finally show "inversa_aux (a#xs) ys = rev (a#xs)@ys" .
  qed
qed

(* 4ª demostración del lema auxiliar *)
lemma
  "inversa_aux xs ys = (rev xs) @ ys"
proof (induct xs arbitrary: ys)
  show "⋀ys. inversa_aux [] ys = rev [] @ ys" by simp
next
  fix a ::'a and xs :: "'a list"
  assume "⋀ys. inversa_aux xs ys = rev xs@ys"
  then show "⋀ys. inversa_aux (a#xs) ys = rev (a#xs)@ys" by simp
qed

(* 5ª demostración del lema auxiliar *)
lemma
  "inversa_aux xs ys = (rev xs) @ ys"
proof (induct xs arbitrary: ys)
  case Nil
  then show ?case by simp
next
  case (Cons a xs)
  then show ?case by simp
qed

(* 6ª demostración del lema auxiliar *)
lemma inversa_equiv:
  "inversa_aux xs ys = (rev xs) @ ys"
by (induct xs arbitrary: ys) simp_all

(* Demostraciones del lema principal *)
(* ================================= *)

(* 1ª demostración *)
lemma "inversa xs = rev xs"
proof -
  have "inversa xs = inversa_aux xs []"
    by (rule inversa.simps)
  also have "… = (rev xs) @ []"
    by (rule inversa_equiv)
  also have "… = rev xs"
    by (rule append.right_neutral)
  finally show "inversa xs = rev xs"
    by this
qed

(* 2ª demostración *)
lemma "inversa xs = rev xs"
proof -
  have "inversa xs = inversa_aux xs []"  by simp
  also have "… = (rev xs) @ []" by (rule inversa_equiv)
  also have "… = rev xs" by simp
  finally show "inversa xs = rev xs" .
qed

(* 3ª demostración *)
lemma "inversa xs = rev xs"
by (simp add: inversa_equiv)

end

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

theory Pruebas_de_equivalencia_de_definiciones_de_inversa

imports Main

begin

(* Definición alternativa *)

(* ====================== *)

fun inversa_aux :: "'a list ⇒ 'a list ⇒ 'a list" where

"inversa_aux [] ys = ys"

| "inversa_aux (x#xs) ys = inversa_aux xs (x#ys)"

fun inversa :: "'a list ⇒ 'a list" where

"inversa xs = inversa_aux xs []"

(* Lema auxiliar: inversa_aux xs ys = (rev xs) @ ys *)

(* ================================================ *)

(* 1ª demostración del lema auxiliar *)

lemma

"inversa_aux xs ys = (rev xs) @ ys"

proof (induct xs arbitrary: ys)

fix ys :: "'a list"

have "inversa_aux [] ys = ys"

by (simp only: inversa_aux.simps(1))

also have "… = [] @ ys"

by (simp only: append.simps(1))

also have "… = rev [] @ ys"

by (simp only: rev.simps(1))

finally show "inversa_aux [] ys = rev [] @ ys"

by this

fix a ::'a and xs :: "'a list"

assume HI: "⋀ys. inversa_aux xs ys = rev xs@ys"

show "⋀ys. inversa_aux (a#xs) ys = rev (a#xs)@ys"

proof -

fix ys

have "inversa_aux (a#xs) ys = inversa_aux xs (a#ys)"

by (simp only: inversa_aux.simps(2))

also have "… = rev xs@(a#ys)"

by (simp only: HI)

also have "… = rev xs @ ([a] @ ys)"

by (simp only: append.simps)

also have "… = (rev xs @ [a]) @ ys"

by (simp only: append_assoc)

also have "… = rev (a # xs) @ ys"

by (simp only: rev.simps(2))

finally show "inversa_aux (a#xs) ys = rev (a#xs)@ys"

by this

qed

(* 2ª demostración del lema auxiliar *)

lemma

"inversa_aux xs ys = (rev xs) @ ys"

proof (induct xs arbitrary: ys)

fix ys :: "'a list"

have "inversa_aux [] ys = ys" by simp

also have "… = [] @ ys" by simp

also have "… = rev [] @ ys" by simp

finally show "inversa_aux [] ys = rev [] @ ys" .

fix a ::'a and xs :: "'a list"

assume HI: "⋀ys. inversa_aux xs ys = rev xs@ys"

show "⋀ys. inversa_aux (a#xs) ys = rev (a#xs)@ys"

proof -

fix ys

have "inversa_aux (a#xs) ys = inversa_aux xs (a#ys)" by simp

also have "… = rev xs@(a#ys)" using HI by simp

also have "… = rev xs @ ([a] @ ys)" by simp

also have "… = (rev xs @ [a]) @ ys" by simp

also have "… = rev (a # xs) @ ys" by simp

finally show "inversa_aux (a#xs) ys = rev (a#xs)@ys" .

qed

(* 3ª demostración del lema auxiliar *)

lemma

"inversa_aux xs ys = (rev xs) @ ys"

proof (induct xs arbitrary: ys)

fix ys :: "'a list"

show "inversa_aux [] ys = rev [] @ ys" by simp

fix a ::'a and xs :: "'a list"

assume HI: "⋀ys. inversa_aux xs ys = rev xs@ys"

show "⋀ys. inversa_aux (a#xs) ys = rev (a#xs)@ys"

proof -

fix ys

have "inversa_aux (a#xs) ys = rev xs@(a#ys)" using HI by simp

also have "… = rev (a # xs) @ ys" by simp

finally show "inversa_aux (a#xs) ys = rev (a#xs)@ys" .

qed

(* 4ª demostración del lema auxiliar *)

lemma

"inversa_aux xs ys = (rev xs) @ ys"

proof (induct xs arbitrary: ys)

show "⋀ys. inversa_aux [] ys = rev [] @ ys" by simp

fix a ::'a and xs :: "'a list"

assume "⋀ys. inversa_aux xs ys = rev xs@ys"

then show "⋀ys. inversa_aux (a#xs) ys = rev (a#xs)@ys" by simp

qed

(* 5ª demostración del lema auxiliar *)

lemma

"inversa_aux xs ys = (rev xs) @ ys"

proof (induct xs arbitrary: ys)

case Nil

then show ?case by simp

case (Cons a xs)

then show ?case by simp

qed

(* 6ª demostración del lema auxiliar *)

lemma inversa_equiv:

"inversa_aux xs ys = (rev xs) @ ys"

by (induct xs arbitrary: ys) simp_all

(* Demostraciones del lema principal *)

(* ================================= *)

(* 1ª demostración *)

lemma "inversa xs = rev xs"

proof -

have "inversa xs = inversa_aux xs []"

by (rule inversa.simps)

also have "… = (rev xs) @ []"

by (rule inversa_equiv)

also have "… = rev xs"

by (rule append.right_neutral)

finally show "inversa xs = rev xs"

by this

qed

(* 2ª demostración *)

lemma "inversa xs = rev xs"

proof -

have "inversa xs = inversa_aux xs []" by simp

also have "… = (rev xs) @ []" by (rule inversa_equiv)

also have "… = rev xs" by simp

finally show "inversa xs = rev xs" .

qed

(* 3ª demostración *)

lemma "inversa xs = rev xs"

by (simp add: inversa_equiv)

end

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="isar"> y otra con </pre>
[/expand]

Pruebas de take n xs ++ drop n xs = xs

PorJosé A. Alonso 10 septiembre 20216 septiembre 2021

En Lean están definidas las funciones

   take : nat → list α → nat
   drop : nat → list α → nat
   (++) : list α → list α → list α

take : nat → list α → nat

drop : nat → list α → nat

(++) : list α → list α → list α

tales que

(take n xs) es la lista formada por los n primeros elementos de xs. Por ejemplo,

     take 2 [3,5,1,9,7] = [3,5]

1	take 2 [3,5,1,9,7] = [3,5]

(drop n xs) es la lista formada eliminando los n primeros elementos de xs. Por ejemplo,

     drop 2 [3,5,1,9,7] = [1,9,7]

1	drop 2 [3,5,1,9,7] = [1,9,7]

(xs ++ ys) es la lista obtenida concatenando xs e ys. Por ejemplo.

     [3,5] ++ [1,9,7] = [3,5,1,9,7]

1	[3,5] ++ [1,9,7] = [3,5,1,9,7]

Dichas funciones están caracterizadas por los siguientes lemas:

   take_zero   : take 0 xs = []
   take_nil    : take n [] = []
   take_cons   : take (succ n) (x :: xs) = x :: take n xs
   drop_zero   : drop 0 xs = xs
   drop_nil    : drop n [] = []
   drop_cons   : drop (succ n) (x :: xs) = drop n xs := rfl
   nil_append  : [] ++ ys = ys
   cons_append : (x :: xs) ++ y = x :: (xs ++ ys)

take_zero : take 0 xs = []

take_nil : take n [] = []

take_cons : take (succ n) (x :: xs) = x :: take n xs

drop_zero : drop 0 xs = xs

drop_nil : drop n [] = []

drop_cons : drop (succ n) (x :: xs) = drop n xs := rfl

nil_append : [] ++ ys = ys

cons_append : (x :: xs) ++ y = x :: (xs ++ ys)

Demostrar que

   take n xs ++ drop n xs = xs

1	take n xs ++ drop n xs = xs

Para ello, completar la siguiente teoría de Lean:

import data.list.basic
import tactic
open list nat

variable {α : Type}
variable (x : α)
variable (xs : list α)
variable (n : ℕ)

lemma drop_zero : drop 0 xs = xs := rfl
lemma drop_cons : drop (succ n) (x :: xs) = drop n xs := rfl

example :
  take n xs ++ drop n xs = xs :=
sorry

import data.list.basic

import tactic

open list nat

variable {α : Type}

variable (x : α)

variable (xs : list α)

variable (n : ℕ)

lemma drop_zero : drop 0 xs = xs := rfl

lemma drop_cons : drop (succ n) (x :: xs) = drop n xs := rfl

example :

take n xs ++ drop n xs = xs :=

sorry

[expand title=»Soluciones con Lean»]

import data.list.basic
import tactic
open list
open nat

variable {α : Type}
variable (n : ℕ)
variable (x : α)
variable (xs : list α)

lemma drop_zero : drop 0 xs = xs := rfl
lemma drop_cons : drop (succ n) (x :: xs) = drop n xs := rfl

-- 1ª demostración
example :
  take n xs ++ drop n xs = xs :=
begin
  induction n with m HI1 generalizing xs,
  { rw take_zero,
    rw drop_zero,
    rw nil_append, },
  { induction xs with a as HI2,
    { rw take_nil,
      rw drop_nil,
      rw nil_append, },
    { rw take_cons,
      rw drop_cons,
      rw cons_append,
      rw (HI1 as), }, },
end

-- 2ª demostración
example :
  take n xs ++ drop n xs = xs :=
begin
  induction n with m HI1 generalizing xs,
  { calc take 0 xs ++ drop 0 xs
         = [] ++ drop 0 xs        : by rw take_zero
     ... = [] ++ xs               : by rw drop_zero
     ... = xs                     : by rw nil_append, },
  { induction xs with a as HI2,
    { calc take (succ m) [] ++ drop (succ m) []
           = ([] : list α) ++ drop (succ m) [] : by rw take_nil
       ... = [] ++ []                          : by rw drop_nil
       ... = []                                : by rw nil_append, },
    { calc take (succ m) (a :: as) ++ drop (succ m) (a :: as)
           = (a :: take m as) ++ drop (succ m) (a :: as) : by rw take_cons
       ... = (a :: take m as) ++ drop m as               : by rw drop_cons
       ... = a :: (take m as ++ drop m as)               : by rw cons_append
       ... = a :: as                                     : by rw (HI1 as), }, },
end

-- 3ª demostración
example :
  take n xs ++ drop n xs = xs :=
begin
  induction n with m HI1 generalizing xs,
  { simp, },
  { induction xs with a as HI2,
    { simp, },
    { simp [HI1 as], }, },
end

-- 4ª demostración
lemma conc_take_drop_1 :
  ∀ (n : ℕ) (xs : list α), take n xs ++ drop n xs = xs
| 0 xs := by calc
    take 0 xs ++ drop 0 xs
        = [] ++ drop 0 xs   : by rw take_zero
    ... = [] ++ xs          : by rw drop_zero
    ... = xs                : by rw nil_append
| (succ m) [] := by calc
    take (succ m) [] ++ drop (succ m) []
        = ([] : list α) ++ drop (succ m) [] : by rw take_nil
    ... = [] ++ []                          : by rw drop_nil
    ... = []                                : by rw nil_append
| (succ m) (a :: as) := by calc
    take (succ m) (a :: as) ++ drop (succ m) (a :: as)
        = (a :: take m as) ++ drop (succ m) (a :: as)    : by rw take_cons
    ... = (a :: take m as) ++ drop m as                  : by rw drop_cons
    ... = a :: (take m as ++ drop m as)                  : by rw cons_append
    ... = a :: as                                        : by rw conc_take_drop_1

-- 5ª demostración
lemma conc_take_drop_2 :
  ∀ (n : ℕ) (xs : list α), take n xs ++ drop n xs = xs
| 0        xs        := by simp
| (succ m) []        := by simp
| (succ m) (a :: as) := by simp [conc_take_drop_2]

-- 6ª demostración
lemma conc_take_drop_3 :
  ∀ (n : ℕ) (xs : list α), take n xs ++ drop n xs = xs
| 0        xs        := rfl
| (succ m) []        := rfl
| (succ m) (a :: as) := congr_arg (cons a) (conc_take_drop_3 m as)

-- 7ª demostración
example : take n xs ++ drop n xs = xs :=
-- by library_search
take_append_drop n xs

-- 8ª demostración
example : take n xs ++ drop n xs = xs :=
by simp

100

101

102

103

104

105

import data.list.basic

import tactic

open list

open nat

variable {α : Type}

variable (n : ℕ)

variable (x : α)

variable (xs : list α)

lemma drop_zero : drop 0 xs = xs := rfl

lemma drop_cons : drop (succ n) (x :: xs) = drop n xs := rfl

-- 1ª demostración

example :

take n xs ++ drop n xs = xs :=

begin

induction n with m HI1 generalizing xs,

{ rw take_zero,

rw drop_zero,

rw nil_append, },

{ induction xs with a as HI2,

{ rw take_nil,

rw drop_nil,

rw nil_append, },

{ rw take_cons,

rw drop_cons,

rw cons_append,

rw (HI1 as), }, },

end

-- 2ª demostración

example :

take n xs ++ drop n xs = xs :=

begin

induction n with m HI1 generalizing xs,

{ calc take 0 xs ++ drop 0 xs

= [] ++ drop 0 xs : by rw take_zero

... = [] ++ xs : by rw drop_zero

... = xs : by rw nil_append, },

{ induction xs with a as HI2,

{ calc take (succ m) [] ++ drop (succ m) []

= ([] : list α) ++ drop (succ m) [] : by rw take_nil

... = [] ++ [] : by rw drop_nil

... = [] : by rw nil_append, },

{ calc take (succ m) (a :: as) ++ drop (succ m) (a :: as)

= (a :: take m as) ++ drop (succ m) (a :: as) : by rw take_cons

... = (a :: take m as) ++ drop m as : by rw drop_cons

... = a :: (take m as ++ drop m as) : by rw cons_append

... = a :: as : by rw (HI1 as), }, },

end

-- 3ª demostración

example :

take n xs ++ drop n xs = xs :=

begin

induction n with m HI1 generalizing xs,

{ simp, },

{ induction xs with a as HI2,

{ simp, },

{ simp [HI1 as], }, },

end

-- 4ª demostración

lemma conc_take_drop_1 :

∀ (n : ℕ) (xs : list α), take n xs ++ drop n xs = xs

| 0 xs := by calc

take 0 xs ++ drop 0 xs

= [] ++ drop 0 xs : by rw take_zero

... = [] ++ xs : by rw drop_zero

... = xs : by rw nil_append

| (succ m) [] := by calc

take (succ m) [] ++ drop (succ m) []

= ([] : list α) ++ drop (succ m) [] : by rw take_nil

... = [] ++ [] : by rw drop_nil

... = [] : by rw nil_append

| (succ m) (a :: as) := by calc

take (succ m) (a :: as) ++ drop (succ m) (a :: as)

= (a :: take m as) ++ drop (succ m) (a :: as) : by rw take_cons

... = (a :: take m as) ++ drop m as : by rw drop_cons

... = a :: (take m as ++ drop m as) : by rw cons_append

... = a :: as : by rw conc_take_drop_1

-- 5ª demostración

lemma conc_take_drop_2 :

∀ (n : ℕ) (xs : list α), take n xs ++ drop n xs = xs

| 0 xs := by simp

| (succ m) [] := by simp

| (succ m) (a :: as) := by simp [conc_take_drop_2]

-- 6ª demostración

lemma conc_take_drop_3 :

∀ (n : ℕ) (xs : list α), take n xs ++ drop n xs = xs

| 0 xs := rfl

| (succ m) [] := rfl

| (succ m) (a :: as) := congr_arg (cons a) (conc_take_drop_3 m as)

-- 7ª demostración

example : take n xs ++ drop n xs = xs :=

-- by library_search

take_append_drop n xs

-- 8ª demostración

example : take n xs ++ drop n xs = xs :=

by simp

Se puede interactuar con la prueba anterior en esta sesión con Lean.

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="lean"> y otra con </pre>
[/expand]

[expand title=»Soluciones con Isabelle/HOL»]

theory "Pruebas_de_take_n_xs_++_drop_n_xs_Ig_xs"
imports Main
begin

fun take' :: "nat ⇒ 'a list ⇒ 'a list" where
  "take' n []           = []"
| "take' 0 xs           = []"
| "take' (Suc n) (x#xs) = x # (take' n xs)"

fun drop' :: "nat ⇒ 'a list ⇒ 'a list" where
  "drop' n []           = []"
| "drop' 0 xs           = xs"
| "drop' (Suc n) (x#xs) = drop' n xs"

(* 1ª demostración *)
lemma "take' n xs @ drop' n xs = xs"
proof (induct rule: take'.induct)
  fix n
  have "take' n [] @ drop' n [] = [] @ drop' n []"
    by (simp only: take'.simps(1))
  also have "… = drop' n []"
    by (simp only: append.simps(1))
  also have "… = []"
    by (simp only: drop'.simps(1))
  finally show "take' n [] @ drop' n [] = []"
    by this
next
  fix x :: 'a and xs :: "'a list"
  have "take' 0 (x#xs) @ drop' 0 (x#xs) =
        [] @ drop' 0 (x#xs)"
    by (simp only: take'.simps(2))
  also have "… = drop' 0 (x#xs)"
    by  (simp only: append.simps(1))
  also have "… = x # xs"
    by  (simp only: drop'.simps(2))
  finally show "take' 0 (x#xs) @ drop' 0 (x#xs) = x#xs"
    by this
next
  fix n :: nat and x :: 'a and xs :: "'a list"
  assume HI: "take' n xs @ drop' n xs = xs"
  have "take' (Suc n) (x # xs) @ drop' (Suc n) (x # xs) =
        (x # (take' n xs)) @ drop' n xs"
    by (simp only: take'.simps(3)
                   drop'.simps(3))
  also have "… = x # (take' n xs @ drop' n xs)"
    by (simp only: append.simps(2))
  also have "… = x#xs"
    by (simp only: HI)
  finally show "take' (Suc n) (x#xs) @ drop' (Suc n) (x#xs) =
                x#xs"
    by this
qed

(* 2ª demostración *)
lemma "take' n xs @ drop' n xs = xs"
proof (induct rule: take'.induct)
case (1 n)
  then show ?case by simp
next
  case (2 x xs)
  then show ?case by simp
next
  case (3 n x xs)
  then show ?case by simp
qed

(* 3ª demostración *)
lemma "take' n xs @ drop' n xs = xs"
by (induct rule: take'.induct) simp_all

end

theory "Pruebas_de_take_n_xs_++_drop_n_xs_Ig_xs"

imports Main

begin

fun take' :: "nat ⇒ 'a list ⇒ 'a list" where

"take' n [] = []"

| "take' 0 xs = []"

| "take' (Suc n) (x#xs) = x # (take' n xs)"

fun drop' :: "nat ⇒ 'a list ⇒ 'a list" where

"drop' n [] = []"

| "drop' 0 xs = xs"

| "drop' (Suc n) (x#xs) = drop' n xs"

(* 1ª demostración *)

lemma "take' n xs @ drop' n xs = xs"

proof (induct rule: take'.induct)

fix n

have "take' n [] @ drop' n [] = [] @ drop' n []"

by (simp only: take'.simps(1))

also have "… = drop' n []"

by (simp only: append.simps(1))

also have "… = []"

by (simp only: drop'.simps(1))

finally show "take' n [] @ drop' n [] = []"

by this

fix x :: 'a and xs :: "'a list"

have "take' 0 (x#xs) @ drop' 0 (x#xs) =

[] @ drop' 0 (x#xs)"

by (simp only: take'.simps(2))

also have "… = drop' 0 (x#xs)"

by (simp only: append.simps(1))

also have "… = x # xs"

by (simp only: drop'.simps(2))

finally show "take' 0 (x#xs) @ drop' 0 (x#xs) = x#xs"

by this

fix n :: nat and x :: 'a and xs :: "'a list"

assume HI: "take' n xs @ drop' n xs = xs"

have "take' (Suc n) (x # xs) @ drop' (Suc n) (x # xs) =

(x # (take' n xs)) @ drop' n xs"

by (simp only: take'.simps(3)

drop'.simps(3))

also have "… = x # (take' n xs @ drop' n xs)"

by (simp only: append.simps(2))

also have "… = x#xs"

by (simp only: HI)

finally show "take' (Suc n) (x#xs) @ drop' (Suc n) (x#xs) =

x#xs"

by this

qed

(* 2ª demostración *)

lemma "take' n xs @ drop' n xs = xs"

proof (induct rule: take'.induct)

case (1 n)

then show ?case by simp

case (2 x xs)

then show ?case by simp

case (3 n x xs)

then show ?case by simp

qed

(* 3ª demostración *)

lemma "take' n xs @ drop' n xs = xs"

by (induct rule: take'.induct) simp_all

end

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="isar"> y otra con </pre>
[/expand]

Pruebas de length (xs ++ ys) = length xs + length ys

PorJosé A. Alonso 9 septiembre 20215 septiembre 2021

En Lean están definidas las funciones

   length : list α → nat
   (++)   : list α → list α → list α

1 2	length : list α → nat (++) : list α → list α → list α

tales que

(length xs) es la longitud de xs. Por ejemplo,

     length [2,3,5,3] = 4

1	length [2,3,5,3] = 4

(xs ++ ys) es la lista obtenida concatenando xs e ys. Por ejemplo.

     [1,2] ++ [2,3,5,3] = [1,2,2,3,5,3]

1	[1,2] ++ [2,3,5,3] = [1,2,2,3,5,3]

Dichas funciones están caracterizadas por los siguientes lemas:

   length_nil  : length [] = 0
   length_cons : length (x :: xs) = length xs + 1
   nil_append  : [] ++ ys = ys
   cons_append : (x :: xs) ++ y = x :: (xs ++ ys)

length_nil : length [] = 0

length_cons : length (x :: xs) = length xs + 1

nil_append : [] ++ ys = ys

cons_append : (x :: xs) ++ y = x :: (xs ++ ys)

Demostrar que

   length (xs ++ ys) = length xs + length ys

1	length (xs ++ ys) = length xs + length ys

Para ello, completar la siguiente teoría de Lean:

import tactic
open list

variable  {α : Type}
variable  (x : α)
variables (xs ys zs : list α)

lemma length_nil  : length ([] : list α) = 0 := rfl

example :
  length (xs ++ ys) = length xs + length ys :=
sorry

import tactic

open list

variable {α : Type}

variable (x : α)

variables (xs ys zs : list α)

lemma length_nil : length ([] : list α) = 0 := rfl

example :

length (xs ++ ys) = length xs + length ys :=

sorry

[expand title=»Soluciones con Lean»]

import tactic
open list

variable  {α : Type}
variable  (x : α)
variables (xs ys zs : list α)

lemma length_nil  : length ([] : list α) = 0 := rfl

-- 1ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
begin
  induction xs with a as HI,
  { rw nil_append,
    rw length_nil,
    rw zero_add, },
  { rw cons_append,
    rw length_cons,
    rw HI,
    rw length_cons,
    rw add_assoc,
    rw add_comm (length ys),
    rw add_assoc, },
end

-- 2ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
begin
  induction xs with a as HI,
  { rw nil_append,
    rw length_nil,
    rw zero_add, },
  { rw cons_append,
    rw length_cons,
    rw HI,
    rw length_cons,
    -- library_search,
    exact add_right_comm (length as) (length ys) 1 },
end

-- 3ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
begin
  induction xs with a as HI,
  { rw nil_append,
    rw length_nil,
    rw zero_add, },
  { rw cons_append,
    rw length_cons,
    rw HI,
    rw length_cons,
    -- by hint,
    linarith, },
end

-- 4ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
begin
  induction xs with a as HI,
  { simp, },
  { simp [HI],
    linarith, },
end

-- 5ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
begin
  induction xs with a as HI,
  { simp, },
  { finish [HI],},
end

-- 6ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
by induction xs ; finish [*]

-- 7ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
begin
  induction xs with a as HI,
  { calc length ([] ++ ys)
         = length ys                    : congr_arg length (nil_append ys)
     ... = 0 + length ys                : (zero_add (length ys)).symm
     ... = length [] + length ys        : congr_arg2 (+) length_nil.symm rfl, },
  { calc length ((a :: as) ++ ys)
         = length (a :: (as ++ ys))     : congr_arg length (cons_append a as ys)
     ... = length (as ++ ys) + 1        : length_cons a (as ++ ys)
     ... = (length as + length ys) + 1  : congr_arg2 (+) HI rfl
     ... = (length as + 1) + length ys  : add_right_comm (length as) (length ys) 1
     ... = length (a :: as) + length ys : congr_arg2 (+) (length_cons a as).symm rfl, },
end

-- 8ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
begin
  induction xs with a as HI,
  { calc length ([] ++ ys)
         = length ys                    : by rw nil_append
     ... = 0 + length ys                : (zero_add (length ys)).symm
     ... = length [] + length ys        : by rw length_nil },
  { calc length ((a :: as) ++ ys)
         = length (a :: (as ++ ys))     : by rw cons_append
     ... = length (as ++ ys) + 1        : by rw length_cons
     ... = (length as + length ys) + 1  : by rw HI
     ... = (length as + 1) + length ys  : add_right_comm (length as) (length ys) 1
     ... = length (a :: as) + length ys : by rw length_cons, },
end

-- 9ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
list.rec_on xs
  ( show length ([] ++ ys) = length [] + length ys, from
      calc length ([] ++ ys)
           = length ys                    : by rw nil_append
       ... = 0 + length ys                : by exact (zero_add (length ys)).symm
       ... = length [] + length ys        : by rw length_nil )
  ( assume a as,
    assume HI : length (as ++ ys) = length as + length ys,
    show length ((a :: as) ++ ys) = length (a :: as) + length ys, from
      calc length ((a :: as) ++ ys)
           = length (a :: (as ++ ys))     : by rw cons_append
       ... = length (as ++ ys) + 1        : by rw length_cons
       ... = (length as + length ys) + 1  : by rw HI
       ... = (length as + 1) + length ys  : by exact add_right_comm (length as) (length ys) 1
       ... = length (a :: as) + length ys : by rw length_cons)

-- 10ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
list.rec_on xs
  ( by simp)
  ( λ a as HI, by simp [HI, add_right_comm])

-- 11ª demostración
lemma longitud_conc_1 :
  ∀ xs, length (xs ++ ys) = length xs + length ys
| [] := by calc
    length ([] ++ ys)
        = length ys                    : by rw nil_append
    ... = 0 + length ys                : by rw zero_add
    ... = length [] + length ys        : by rw length_nil
| (a :: as) := by calc
    length ((a :: as) ++ ys)
        = length (a :: (as ++ ys))     : by rw cons_append
    ... = length (as ++ ys) + 1        : by rw length_cons
    ... = (length as + length ys) + 1  : by rw longitud_conc_1
    ... = (length as + 1) + length ys  : by exact add_right_comm (length as) (length ys) 1
    ... = length (a :: as) + length ys : by rw length_cons

-- 12ª demostración
lemma longitud_conc_2 :
  ∀ xs, length (xs ++ ys) = length xs + length ys
| []        := by simp
| (a :: as) := by simp [longitud_conc_2 as, add_right_comm]

-- 13ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
-- by library_search
length_append xs ys

-- 14ª demostración
example :
  length (xs ++ ys) = length xs + length ys :=
by simp

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

import tactic

open list

variable {α : Type}

variable (x : α)

variables (xs ys zs : list α)

lemma length_nil : length ([] : list α) = 0 := rfl

-- 1ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

begin

induction xs with a as HI,

{ rw nil_append,

rw length_nil,

rw zero_add, },

{ rw cons_append,

rw length_cons,

rw HI,

rw length_cons,

rw add_assoc,

rw add_comm (length ys),

rw add_assoc, },

end

-- 2ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

begin

induction xs with a as HI,

{ rw nil_append,

rw length_nil,

rw zero_add, },

{ rw cons_append,

rw length_cons,

rw HI,

rw length_cons,

-- library_search,

exact add_right_comm (length as) (length ys) 1 },

end

-- 3ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

begin

induction xs with a as HI,

{ rw nil_append,

rw length_nil,

rw zero_add, },

{ rw cons_append,

rw length_cons,

rw HI,

rw length_cons,

-- by hint,

linarith, },

end

-- 4ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

begin

induction xs with a as HI,

{ simp, },

{ simp [HI],

linarith, },

end

-- 5ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

begin

induction xs with a as HI,

{ simp, },

{ finish [HI],},

end

-- 6ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

by induction xs ; finish [*]

-- 7ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

begin

induction xs with a as HI,

{ calc length ([] ++ ys)

= length ys : congr_arg length (nil_append ys)

... = 0 + length ys : (zero_add (length ys)).symm

... = length [] + length ys : congr_arg2 (+) length_nil.symm rfl, },

{ calc length ((a :: as) ++ ys)

= length (a :: (as ++ ys)) : congr_arg length (cons_append a as ys)

... = length (as ++ ys) + 1 : length_cons a (as ++ ys)

... = (length as + length ys) + 1 : congr_arg2 (+) HI rfl

... = (length as + 1) + length ys : add_right_comm (length as) (length ys) 1

... = length (a :: as) + length ys : congr_arg2 (+) (length_cons a as).symm rfl, },

end

-- 8ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

begin

induction xs with a as HI,

{ calc length ([] ++ ys)

= length ys : by rw nil_append

... = 0 + length ys : (zero_add (length ys)).symm

... = length [] + length ys : by rw length_nil },

{ calc length ((a :: as) ++ ys)

= length (a :: (as ++ ys)) : by rw cons_append

... = length (as ++ ys) + 1 : by rw length_cons

... = (length as + length ys) + 1 : by rw HI

... = (length as + 1) + length ys : add_right_comm (length as) (length ys) 1

... = length (a :: as) + length ys : by rw length_cons, },

end

-- 9ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

list.rec_on xs

( show length ([] ++ ys) = length [] + length ys, from

calc length ([] ++ ys)

= length ys : by rw nil_append

... = 0 + length ys : by exact (zero_add (length ys)).symm

... = length [] + length ys : by rw length_nil )

( assume a as,

assume HI : length (as ++ ys) = length as + length ys,

show length ((a :: as) ++ ys) = length (a :: as) + length ys, from

calc length ((a :: as) ++ ys)

= length (a :: (as ++ ys)) : by rw cons_append

... = length (as ++ ys) + 1 : by rw length_cons

... = (length as + length ys) + 1 : by rw HI

... = (length as + 1) + length ys : by exact add_right_comm (length as) (length ys) 1

... = length (a :: as) + length ys : by rw length_cons)

-- 10ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

list.rec_on xs

( by simp)

( λ a as HI, by simp [HI, add_right_comm])

-- 11ª demostración

lemma longitud_conc_1 :

∀ xs, length (xs ++ ys) = length xs + length ys

| [] := by calc

length ([] ++ ys)

= length ys : by rw nil_append

... = 0 + length ys : by rw zero_add

... = length [] + length ys : by rw length_nil

| (a :: as) := by calc

length ((a :: as) ++ ys)

= length (a :: (as ++ ys)) : by rw cons_append

... = length (as ++ ys) + 1 : by rw length_cons

... = (length as + length ys) + 1 : by rw longitud_conc_1

... = (length as + 1) + length ys : by exact add_right_comm (length as) (length ys) 1

... = length (a :: as) + length ys : by rw length_cons

-- 12ª demostración

lemma longitud_conc_2 :

∀ xs, length (xs ++ ys) = length xs + length ys

| [] := by simp

| (a :: as) := by simp [longitud_conc_2 as, add_right_comm]

-- 13ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

-- by library_search

length_append xs ys

-- 14ª demostración

example :

length (xs ++ ys) = length xs + length ys :=

by simp

Se puede interactuar con la prueba anterior en esta sesión con Lean.

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="lean"> y otra con </pre>
[/expand]

[expand title=»Soluciones con Isabelle/HOL»]

theory "Pruebas_de_length(xs_++_ys)_Ig_length_xs+length_ys"
imports Main
begin

(* 1ª demostración *)
lemma "length (xs @ ys) = length xs + length ys"
proof (induct xs)
  have "length ([] @ ys) = length ys"
    by (simp only: append_Nil)
  also have "… = 0 + length ys"
    by (rule add_0 [symmetric])
  also have "… = length [] + length ys"
    by (simp only: list.size(3))
  finally show "length ([] @ ys) = length [] + length ys"
    by this
next
  fix x xs
  assume HI : "length (xs @ ys) = length xs + length ys"
  have "length ((x # xs) @ ys) =
        length (x # (xs @ ys))"
    by (simp only: append_Cons)
  also have "… = length (xs @ ys) + 1"
    by (simp only: list.size(4))
  also have "… = (length xs + length ys) + 1"
    by (simp only: HI)
  also have "… = (length xs + 1) + length ys"
    by (simp only: add.assoc add.commute)
  also have "… = length (x # xs) + length ys"
    by (simp only: list.size(4))
  then show "length ((x # xs) @ ys) = length (x # xs) + length ys"
    by simp
qed

(* 2ª demostración *)
lemma "length (xs @ ys) = length xs + length ys"
proof (induct xs)
  show "length ([] @ ys) = length [] + length ys"
    by simp
next
  fix x xs
  assume "length (xs @ ys) = length xs + length ys"
  then show "length ((x # xs) @ ys) = length (x # xs) + length ys"
    by simp
qed

(* 3ª demostración *)
lemma "length (xs @ ys) = length xs + length ys"
proof (induct xs)
  case Nil
  then show ?case by simp
next
  case (Cons a xs)
  then show ?case by simp
qed

(* 4ª demostración *)
lemma "length (xs @ ys) = length xs + length ys"
by (induct xs) simp_all

(* 5ª demostración *)
lemma "length (xs @ ys) = length xs + length ys"
by (fact length_append)

end

theory "Pruebas_de_length(xs_++_ys)_Ig_length_xs+length_ys"

imports Main

begin

(* 1ª demostración *)

lemma "length (xs @ ys) = length xs + length ys"

proof (induct xs)

have "length ([] @ ys) = length ys"

by (simp only: append_Nil)

also have "… = 0 + length ys"

by (rule add_0 [symmetric])

also have "… = length [] + length ys"

by (simp only: list.size(3))

finally show "length ([] @ ys) = length [] + length ys"

by this

fix x xs

assume HI : "length (xs @ ys) = length xs + length ys"

have "length ((x # xs) @ ys) =

length (x # (xs @ ys))"

by (simp only: append_Cons)

also have "… = length (xs @ ys) + 1"

by (simp only: list.size(4))

also have "… = (length xs + length ys) + 1"

by (simp only: HI)

also have "… = (length xs + 1) + length ys"

by (simp only: add.assoc add.commute)

also have "… = length (x # xs) + length ys"

by (simp only: list.size(4))

then show "length ((x # xs) @ ys) = length (x # xs) + length ys"

by simp

qed

(* 2ª demostración *)

lemma "length (xs @ ys) = length xs + length ys"

proof (induct xs)

show "length ([] @ ys) = length [] + length ys"

by simp

fix x xs

assume "length (xs @ ys) = length xs + length ys"

then show "length ((x # xs) @ ys) = length (x # xs) + length ys"

by simp

qed

(* 3ª demostración *)

lemma "length (xs @ ys) = length xs + length ys"

proof (induct xs)

case Nil

then show ?case by simp

case (Cons a xs)

then show ?case by simp

qed

(* 4ª demostración *)

lemma "length (xs @ ys) = length xs + length ys"

by (induct xs) simp_all

(* 5ª demostración *)

lemma "length (xs @ ys) = length xs + length ys"

by (fact length_append)

end

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="isar"> y otra con </pre>
[/expand]

Asociatividad de la concatenación de listas

PorJosé A. Alonso 8 septiembre 20218 septiembre 2021

En Lean la operación de concatenación de listas se representa por (++) y está caracterizada por los siguientes lemas

   nil_append  : [] ++ ys = ys
   cons_append : (x :: xs) ++ y = x :: (xs ++ ys)

1 2	nil_append : [] ++ ys = ys cons_append : (x :: xs) ++ y = x :: (xs ++ ys)

Demostrar que la concatenación es asociativa; es decir,

   xs ++ (ys ++ zs) = (xs ++ ys) ++ zs

1	xs ++ (ys ++ zs) = (xs ++ ys) ++ zs

Para ello, completar la siguiente teoría de Lean:

import data.list.basic
import tactic
open list

variable  {α : Type}
variable  (x : α)
variables (xs ys zs : list α)

example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
sorry

import data.list.basic

import tactic

open list

variable {α : Type}

variable (x : α)

variables (xs ys zs : list α)

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

sorry

[expand title=»Soluciones con Lean»]

import data.list.basic
import tactic
open list

variable  {α : Type}
variable  (x : α)
variables (xs ys zs : list α)

-- 1ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
begin
  induction xs with a as HI,
  { calc [] ++ (ys ++ zs)
         = ys ++ zs                : append.equations._eqn_1 (ys ++ zs)
     ... = ([] ++ ys) ++ zs        : congr_arg2 (++) (append.equations._eqn_1 ys) rfl, },
  { calc (a :: as) ++ (ys ++ zs)
         = a :: (as ++ (ys ++ zs)) : append.equations._eqn_2 a as (ys ++ zs)
     ... = a :: ((as ++ ys) ++ zs) : congr_arg2 (::) rfl HI
     ... = (a :: (as ++ ys)) ++ zs : (append.equations._eqn_2 a (as ++ ys) zs).symm
     ... = ((a :: as) ++ ys) ++ zs : congr_arg2 (++) (append.equations._eqn_2 a as ys).symm rfl, },
end

-- 2ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
begin
  induction xs with a as HI,
  { calc [] ++ (ys ++ zs)
         = ys ++ zs                : nil_append (ys ++ zs)
     ... = ([] ++ ys) ++ zs        : congr_arg2 (++) (nil_append ys) rfl, },
  { calc (a :: as) ++ (ys ++ zs)
         = a :: (as ++ (ys ++ zs)) : cons_append a as (ys ++ zs)
     ... = a :: ((as ++ ys) ++ zs) : congr_arg2 (::) rfl HI
     ... = (a :: (as ++ ys)) ++ zs : (cons_append a (as ++ ys) zs).symm
     ... = ((a :: as) ++ ys) ++ zs : congr_arg2 (++) (cons_append a as ys).symm rfl, },
end

-- 3ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
begin
  induction xs with a as HI,
  { calc [] ++ (ys ++ zs)
         = ys ++ zs                : by rw nil_append
     ... = ([] ++ ys) ++ zs        : by rw nil_append, },
  { calc (a :: as) ++ (ys ++ zs)
         = a :: (as ++ (ys ++ zs)) : by rw cons_append
     ... = a :: ((as ++ ys) ++ zs) : by rw HI
     ... = (a :: (as ++ ys)) ++ zs : by rw cons_append
     ... = ((a :: as) ++ ys) ++ zs : by rw ← cons_append, },
end

-- 4ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
begin
  induction xs with a as HI,
  { calc [] ++ (ys ++ zs)
         = ys ++ zs                : rfl
     ... = ([] ++ ys) ++ zs        : rfl, },
  { calc (a :: as) ++ (ys ++ zs)
         = a :: (as ++ (ys ++ zs)) : rfl
     ... = a :: ((as ++ ys) ++ zs) : by rw HI
     ... = (a :: (as ++ ys)) ++ zs : rfl
     ... = ((a :: as) ++ ys) ++ zs : rfl, },
end

-- 5ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
begin
  induction xs with a as HI,
  { calc [] ++ (ys ++ zs)
         = ys ++ zs                : by simp
     ... = ([] ++ ys) ++ zs        : by simp, },
  { calc (a :: as) ++ (ys ++ zs)
         = a :: (as ++ (ys ++ zs)) : by simp
     ... = a :: ((as ++ ys) ++ zs) : congr_arg (cons a) HI
     ... = (a :: (as ++ ys)) ++ zs : by simp
     ... = ((a :: as) ++ ys) ++ zs : by simp, },
end

-- 6ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
begin
  induction xs with a as HI,
  { by simp, },
  { by exact (cons_inj a).mpr HI, },
end

-- 7ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
begin
  induction xs with a as HI,
  { rw nil_append,
    rw nil_append, },
  { rw cons_append,
    rw HI,
    rw cons_append,
    rw cons_append, },
end

-- 8ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
list.rec_on xs
  ( show [] ++ (ys ++ zs) = ([] ++ ys) ++ zs,
      from calc
        [] ++ (ys ++ zs)
            = ys ++ zs         : by rw nil_append
        ... = ([] ++ ys) ++ zs : by rw nil_append )
  ( assume a as,
    assume HI : as ++ (ys ++ zs) = (as ++ ys) ++ zs,
    show (a :: as) ++ (ys  ++ zs) = ((a :: as) ++ ys) ++ zs,
      from calc
        (a :: as) ++ (ys ++ zs)
            = a :: (as ++ (ys ++ zs)) : by rw cons_append
        ... = a :: ((as ++ ys) ++ zs) : by rw HI
        ... = (a :: (as ++ ys)) ++ zs : by rw cons_append
        ... = ((a :: as) ++ ys) ++ zs : by rw ← cons_append)

-- 9ª demostración
example :
  xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=
list.rec_on xs
  (by simp)
  (by simp [*])

-- 10ª demostración
lemma conc_asoc_1 :
  ∀ xs, xs ++ (ys ++ zs) = (xs ++ ys) ++ zs
| [] := by calc
    [] ++ (ys ++ zs)
        = ys ++ zs         : by rw nil_append
    ... = ([] ++ ys) ++ zs : by rw nil_append
| (a :: as) := by calc
    (a :: as) ++ (ys ++ zs)
        = a :: (as ++ (ys ++ zs)) : by rw cons_append
    ... = a :: ((as ++ ys) ++ zs) : by rw conc_asoc_1
    ... = (a :: (as ++ ys)) ++ zs : by rw cons_append
    ... = ((a :: as) ++ ys) ++ zs : by rw ← cons_append

-- 11ª demostración
example :
  (xs ++ ys) ++ zs = xs ++ (ys ++ zs) :=
-- by library_search
append_assoc xs ys zs

-- 12ª demostración
example :
  (xs ++ ys) ++ zs = xs ++ (ys ++ zs) :=
by induction xs ; simp [*]

-- 13ª demostración
example :
  (xs ++ ys) ++ zs = xs ++ (ys ++ zs) :=
by simp

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

import data.list.basic

import tactic

open list

variable {α : Type}

variable (x : α)

variables (xs ys zs : list α)

-- 1ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

begin

induction xs with a as HI,

{ calc [] ++ (ys ++ zs)

= ys ++ zs : append.equations._eqn_1 (ys ++ zs)

... = ([] ++ ys) ++ zs : congr_arg2 (++) (append.equations._eqn_1 ys) rfl, },

{ calc (a :: as) ++ (ys ++ zs)

= a :: (as ++ (ys ++ zs)) : append.equations._eqn_2 a as (ys ++ zs)

... = a :: ((as ++ ys) ++ zs) : congr_arg2 (::) rfl HI

... = (a :: (as ++ ys)) ++ zs : (append.equations._eqn_2 a (as ++ ys) zs).symm

... = ((a :: as) ++ ys) ++ zs : congr_arg2 (++) (append.equations._eqn_2 a as ys).symm rfl, },

end

-- 2ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

begin

induction xs with a as HI,

{ calc [] ++ (ys ++ zs)

= ys ++ zs : nil_append (ys ++ zs)

... = ([] ++ ys) ++ zs : congr_arg2 (++) (nil_append ys) rfl, },

{ calc (a :: as) ++ (ys ++ zs)

= a :: (as ++ (ys ++ zs)) : cons_append a as (ys ++ zs)

... = a :: ((as ++ ys) ++ zs) : congr_arg2 (::) rfl HI

... = (a :: (as ++ ys)) ++ zs : (cons_append a (as ++ ys) zs).symm

... = ((a :: as) ++ ys) ++ zs : congr_arg2 (++) (cons_append a as ys).symm rfl, },

end

-- 3ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

begin

induction xs with a as HI,

{ calc [] ++ (ys ++ zs)

= ys ++ zs : by rw nil_append

... = ([] ++ ys) ++ zs : by rw nil_append, },

{ calc (a :: as) ++ (ys ++ zs)

= a :: (as ++ (ys ++ zs)) : by rw cons_append

... = a :: ((as ++ ys) ++ zs) : by rw HI

... = (a :: (as ++ ys)) ++ zs : by rw cons_append

... = ((a :: as) ++ ys) ++ zs : by rw ← cons_append, },

end

-- 4ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

begin

induction xs with a as HI,

{ calc [] ++ (ys ++ zs)

= ys ++ zs : rfl

... = ([] ++ ys) ++ zs : rfl, },

{ calc (a :: as) ++ (ys ++ zs)

= a :: (as ++ (ys ++ zs)) : rfl

... = a :: ((as ++ ys) ++ zs) : by rw HI

... = (a :: (as ++ ys)) ++ zs : rfl

... = ((a :: as) ++ ys) ++ zs : rfl, },

end

-- 5ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

begin

induction xs with a as HI,

{ calc [] ++ (ys ++ zs)

= ys ++ zs : by simp

... = ([] ++ ys) ++ zs : by simp, },

{ calc (a :: as) ++ (ys ++ zs)

= a :: (as ++ (ys ++ zs)) : by simp

... = a :: ((as ++ ys) ++ zs) : congr_arg (cons a) HI

... = (a :: (as ++ ys)) ++ zs : by simp

... = ((a :: as) ++ ys) ++ zs : by simp, },

end

-- 6ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

begin

induction xs with a as HI,

{ by simp, },

{ by exact (cons_inj a).mpr HI, },

end

-- 7ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

begin

induction xs with a as HI,

{ rw nil_append,

rw nil_append, },

{ rw cons_append,

rw HI,

rw cons_append,

rw cons_append, },

end

-- 8ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

list.rec_on xs

( show [] ++ (ys ++ zs) = ([] ++ ys) ++ zs,

from calc

[] ++ (ys ++ zs)

= ys ++ zs : by rw nil_append

... = ([] ++ ys) ++ zs : by rw nil_append )

( assume a as,

assume HI : as ++ (ys ++ zs) = (as ++ ys) ++ zs,

show (a :: as) ++ (ys ++ zs) = ((a :: as) ++ ys) ++ zs,

from calc

(a :: as) ++ (ys ++ zs)

= a :: (as ++ (ys ++ zs)) : by rw cons_append

... = a :: ((as ++ ys) ++ zs) : by rw HI

... = (a :: (as ++ ys)) ++ zs : by rw cons_append

... = ((a :: as) ++ ys) ++ zs : by rw ← cons_append)

-- 9ª demostración

example :

xs ++ (ys ++ zs) = (xs ++ ys) ++ zs :=

list.rec_on xs

(by simp)

(by simp [*])

-- 10ª demostración

lemma conc_asoc_1 :

∀ xs, xs ++ (ys ++ zs) = (xs ++ ys) ++ zs

| [] := by calc

[] ++ (ys ++ zs)

= ys ++ zs : by rw nil_append

... = ([] ++ ys) ++ zs : by rw nil_append

| (a :: as) := by calc

(a :: as) ++ (ys ++ zs)

= a :: (as ++ (ys ++ zs)) : by rw cons_append

... = a :: ((as ++ ys) ++ zs) : by rw conc_asoc_1

... = (a :: (as ++ ys)) ++ zs : by rw cons_append

... = ((a :: as) ++ ys) ++ zs : by rw ← cons_append

-- 11ª demostración

example :

(xs ++ ys) ++ zs = xs ++ (ys ++ zs) :=

-- by library_search

append_assoc xs ys zs

-- 12ª demostración

example :

(xs ++ ys) ++ zs = xs ++ (ys ++ zs) :=

by induction xs ; simp [*]

-- 13ª demostración

example :

(xs ++ ys) ++ zs = xs ++ (ys ++ zs) :=

by simp

Se puede interactuar con la prueba anterior en esta sesión con Lean.

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="lean"> y otra con </pre>
[/expand]

[expand title=»Soluciones con Isabelle/HOL»]

theory Asociatividad_de_la_concatenacion_de_listas
imports Main
begin

(* 1ª demostración *)
lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"
proof (induct xs)
  have "[] @ (ys @ zs) = ys @ zs"
    by (simp only: append_Nil)
  also have "… = ([] @ ys) @ zs"
    by (simp only: append_Nil)
  finally show "[] @ (ys @ zs) = ([] @ ys) @ zs"
    by this
next
  fix x xs
  assume HI : "xs @ (ys @ zs) = (xs @ ys) @ zs"
  have "(x # xs) @ (ys @ zs) = x # (xs @ (ys @ zs))"
    by (simp only: append_Cons)
  also have "… = x # ((xs @ ys) @ zs)"
    by (simp only: HI)
  also have "… = (x # (xs @ ys)) @ zs"
    by (simp only: append_Cons)
  also have "… = ((x # xs) @ ys) @ zs"
    by (simp only: append_Cons)
  finally show "(x # xs) @ (ys @ zs) = ((x # xs) @ ys) @ zs"
    by this
qed

(* 2ª demostración *)
lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"
proof (induct xs)
  have "[] @ (ys @ zs) = ys @ zs" by simp
  also have "… = ([] @ ys) @ zs" by simp
  finally show "[] @ (ys @ zs) = ([] @ ys) @ zs" .
next
  fix x xs
  assume HI : "xs @ (ys @ zs) = (xs @ ys) @ zs"
  have "(x # xs) @ (ys @ zs) = x # (xs @ (ys @ zs))" by simp
  also have "… = x # ((xs @ ys) @ zs)" by simp
  also have "… = (x # (xs @ ys)) @ zs" by simp
  also have "… = ((x # xs) @ ys) @ zs" by simp
  finally show "(x # xs) @ (ys @ zs) = ((x # xs) @ ys) @ zs" .
qed

(* 3ª demostración *)
lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"
proof (induct xs)
  show "[] @ (ys @ zs) = ([] @ ys) @ zs" by simp
next
  fix x xs
  assume "xs @ (ys @ zs) = (xs @ ys) @ zs"
  then show "(x # xs) @ (ys @ zs) = ((x # xs) @ ys) @ zs" by simp
qed

(* 4ª demostración *)
lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"
proof (induct xs)
  case Nil
  then show ?case by simp
next
  case (Cons a xs)
  then show ?case by simp
qed

(* 5ª demostración *)
lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"
  by (rule append_assoc [symmetric])

(* 6ª demostración *)
lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"
  by (induct xs) simp_all

(* 7ª demostración *)
lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"
  by simp

end

theory Asociatividad_de_la_concatenacion_de_listas

imports Main

begin

(* 1ª demostración *)

lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"

proof (induct xs)

have "[] @ (ys @ zs) = ys @ zs"

by (simp only: append_Nil)

also have "… = ([] @ ys) @ zs"

by (simp only: append_Nil)

finally show "[] @ (ys @ zs) = ([] @ ys) @ zs"

by this

fix x xs

assume HI : "xs @ (ys @ zs) = (xs @ ys) @ zs"

have "(x # xs) @ (ys @ zs) = x # (xs @ (ys @ zs))"

by (simp only: append_Cons)

also have "… = x # ((xs @ ys) @ zs)"

by (simp only: HI)

also have "… = (x # (xs @ ys)) @ zs"

by (simp only: append_Cons)

also have "… = ((x # xs) @ ys) @ zs"

by (simp only: append_Cons)

finally show "(x # xs) @ (ys @ zs) = ((x # xs) @ ys) @ zs"

by this

qed

(* 2ª demostración *)

lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"

proof (induct xs)

have "[] @ (ys @ zs) = ys @ zs" by simp

also have "… = ([] @ ys) @ zs" by simp

finally show "[] @ (ys @ zs) = ([] @ ys) @ zs" .

fix x xs

assume HI : "xs @ (ys @ zs) = (xs @ ys) @ zs"

have "(x # xs) @ (ys @ zs) = x # (xs @ (ys @ zs))" by simp

also have "… = x # ((xs @ ys) @ zs)" by simp

also have "… = (x # (xs @ ys)) @ zs" by simp

also have "… = ((x # xs) @ ys) @ zs" by simp

finally show "(x # xs) @ (ys @ zs) = ((x # xs) @ ys) @ zs" .

qed

(* 3ª demostración *)

lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"

proof (induct xs)

show "[] @ (ys @ zs) = ([] @ ys) @ zs" by simp

fix x xs

assume "xs @ (ys @ zs) = (xs @ ys) @ zs"

then show "(x # xs) @ (ys @ zs) = ((x # xs) @ ys) @ zs" by simp

qed

(* 4ª demostración *)

lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"

proof (induct xs)

case Nil

then show ?case by simp

case (Cons a xs)

then show ?case by simp

qed

(* 5ª demostración *)

lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"

by (rule append_assoc [symmetric])

(* 6ª demostración *)

lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"

by (induct xs) simp_all

(* 7ª demostración *)

lemma "xs @ (ys @ zs) = (xs @ ys) @ zs"

by simp

end

En los comentarios se pueden escribir otras soluciones, escribiendo el código entre una línea con <pre lang="isar"> y otra con </pre>
[/expand]