IH.conjunct1 – Calculemus

Las funciones de extracción no están acotadas

PorJosé A. Alonso 30 agosto 202125 agosto 2021

Para extraer una subsucesión se aplica una función de extracción que conserva el orden; por ejemplo, la subsucesión

   uₒ, u₂, u₄, u₆, ...

1	uₒ, u₂, u₄, u₆, ...

se ha obtenido con la función de extracción φ tal que φ(n) = 2*n.

En Lean, se puede definir que φ es una función de extracción por

   def extraccion (φ : ℕ → ℕ) :=
     ∀ n m, n < m → φ n < φ m

1 2	def extraccion (φ : ℕ → ℕ) := ∀ n m, n < m → φ n < φ m

Demostrar que las funciones de extracción no está acotadas; es decir, que si φ es una función de extracción, entonces

    ∀ N N', ∃ n ≥ N', φ n ≥ N

1	∀ N N', ∃ n ≥ N', φ n ≥ N

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

import tactic
open nat

variable {φ : ℕ → ℕ}

def extraccion (φ : ℕ → ℕ) :=
  ∀ n m, n < m → φ n < φ m

example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
sorry

import tactic

open nat

variable {φ : ℕ → ℕ}

def extraccion (φ : ℕ → ℕ) :=

∀ n m, n < m → φ n < φ m

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

sorry

[expand title=»Soluciones con Lean»]

import tactic
open nat

variable {φ : ℕ → ℕ}

def extraccion (φ : ℕ → ℕ) :=
  ∀ n m, n < m → φ n < φ m

lemma aux
  (h : extraccion φ)
  : ∀ n, n ≤ φ n :=
begin
  intro n,
  induction n with m HI,
  { exact nat.zero_le (φ 0), },
  { apply nat.succ_le_of_lt,
    calc m ≤ φ m        : HI
       ... < φ (succ m) : h m (m+1) (lt_add_one m), },
end

-- 1ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
begin
  intros N N',
  let n := max N N',
  use n,
  split,
  { exact le_max_right N N', },
  { calc N ≤ n   : le_max_left N N'
       ... ≤ φ n : aux h n, },
end

-- 2ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
begin
  intros N N',
  let n := max N N',
  use n,
  split,
  { exact le_max_right N N', },
  { exact le_trans (le_max_left N N')
                   (aux h n), },
end

-- 3ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
begin
  intros N N',
  use max N N',
  split,
  { exact le_max_right N N', },
  { exact le_trans (le_max_left N N')
                   (aux h (max N N')), },
end

-- 4ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
begin
  intros N N',
  use max N N',
  exact ⟨le_max_right N N',
         le_trans (le_max_left N N')
                  (aux h (max N N'))⟩,
end

-- 5ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
λ N N',
  ⟨max N N', ⟨le_max_right N N',
              le_trans (le_max_left N N')
                       (aux h (max N N'))⟩⟩

-- 6ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
assume N N',
let n := max N N' in
have h1 : n ≥ N',
  from le_max_right N N',
show ∃ n ≥ N', φ n ≥ N, from
exists.intro n
  (exists.intro h1
    (show φ n ≥ N, from
       calc N ≤ n   : le_max_left N N'
          ... ≤ φ n : aux h n))

-- 7ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
assume N N',
let n := max N N' in
have h1 : n ≥ N',
  from le_max_right N N',
show ∃ n ≥ N', φ n ≥ N, from
⟨n, h1, calc N ≤ n   : le_max_left N N'
          ...  ≤ φ n : aux h n⟩

-- 8ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
assume N N',
let n := max N N' in
have h1 : n ≥ N',
  from le_max_right N N',
show ∃ n ≥ N', φ n ≥ N, from
⟨n, h1, le_trans (le_max_left N N')
                 (aux h (max N N'))⟩

-- 9ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
assume N N',
let n := max N N' in
have h1 : n ≥ N',
  from le_max_right N N',
⟨n, h1, le_trans (le_max_left N N')
                 (aux h n)⟩

-- 10ª demostración
example
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
assume N N',
⟨max N N', le_max_right N N',
           le_trans (le_max_left N N')
                    (aux h (max N N'))⟩

-- 11ª demostración
lemma extraccion_mye
  (h : extraccion φ)
  : ∀ N N', ∃ n ≥ N', φ n ≥ N :=
λ N N',
  ⟨max N N', le_max_right N N',
             le_trans (le_max_left N N')
             (aux h (max N N'))⟩

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

import tactic

open nat

variable {φ : ℕ → ℕ}

def extraccion (φ : ℕ → ℕ) :=

∀ n m, n < m → φ n < φ m

lemma aux

(h : extraccion φ)

: ∀ n, n ≤ φ n :=

begin

intro n,

induction n with m HI,

{ exact nat.zero_le (φ 0), },

{ apply nat.succ_le_of_lt,

calc m ≤ φ m : HI

... < φ (succ m) : h m (m+1) (lt_add_one m), },

end

-- 1ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

begin

intros N N',

let n := max N N',

use n,

split,

{ exact le_max_right N N', },

{ calc N ≤ n : le_max_left N N'

... ≤ φ n : aux h n, },

end

-- 2ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

begin

intros N N',

let n := max N N',

use n,

split,

{ exact le_max_right N N', },

{ exact le_trans (le_max_left N N')

(aux h n), },

end

-- 3ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

begin

intros N N',

use max N N',

split,

{ exact le_max_right N N', },

{ exact le_trans (le_max_left N N')

(aux h (max N N')), },

end

-- 4ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

begin

intros N N',

use max N N',

exact ⟨le_max_right N N',

le_trans (le_max_left N N')

(aux h (max N N'))⟩,

end

-- 5ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

λ N N',

⟨max N N', ⟨le_max_right N N',

le_trans (le_max_left N N')

(aux h (max N N'))⟩⟩

-- 6ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

assume N N',

let n := max N N' in

have h1 : n ≥ N',

from le_max_right N N',

show ∃ n ≥ N', φ n ≥ N, from

exists.intro n

(exists.intro h1

(show φ n ≥ N, from

calc N ≤ n : le_max_left N N'

... ≤ φ n : aux h n))

-- 7ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

assume N N',

let n := max N N' in

have h1 : n ≥ N',

from le_max_right N N',

show ∃ n ≥ N', φ n ≥ N, from

⟨n, h1, calc N ≤ n : le_max_left N N'

... ≤ φ n : aux h n⟩

-- 8ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

assume N N',

let n := max N N' in

have h1 : n ≥ N',

from le_max_right N N',

show ∃ n ≥ N', φ n ≥ N, from

⟨n, h1, le_trans (le_max_left N N')

(aux h (max N N'))⟩

-- 9ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

assume N N',

let n := max N N' in

have h1 : n ≥ N',

from le_max_right N N',

⟨n, h1, le_trans (le_max_left N N')

(aux h n)⟩

-- 10ª demostración

example

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

assume N N',

⟨max N N', le_max_right N N',

le_trans (le_max_left N N')

(aux h (max N N'))⟩

-- 11ª demostración

lemma extraccion_mye

(h : extraccion φ)

: ∀ N N', ∃ n ≥ N', φ n ≥ N :=

λ N N',

⟨max N N', le_max_right N N',

le_trans (le_max_left N N')

(aux h (max N N'))⟩

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 Las_funciones_de_extraccion_no_estan_acotadas
imports Main
begin

definition extraccion :: "(nat ⇒ nat) ⇒ bool" where
  "extraccion φ ⟷ (∀ n m. n < m ⟶ φ n < φ m)"

(* En la demostración se usará el siguiente lema *)
lemma aux :
  assumes "extraccion φ"
  shows   "n ≤ φ n"
proof (induct n)
  show "0 ≤ φ 0"
    by simp
next
  fix n
  assume HI : "n ≤ φ n"
  also have "φ n < φ (Suc n)"
    using assms extraccion_def by blast
  finally show "Suc n ≤ φ (Suc n)"
    by simp
qed

(* 1ª demostración *)
lemma
  assumes "extraccion φ"
  shows   "∀ N N'. ∃ k ≥ N'. φ k ≥ N"
proof (intro allI)
  fix N N' :: nat
  let ?k = "max N N'"
  have "max N N' ≤ ?k"
    by (rule le_refl)
  then have hk : "N ≤ ?k ∧ N' ≤ ?k"
    by (simp only: max.bounded_iff)
  then have "?k ≥ N'"
    by (rule conjunct2)
  moreover
  have "N ≤ φ ?k"
  proof -
    have "N ≤ ?k"
      using hk by (rule conjunct1)
    also have "… ≤ φ ?k"
      using assms by (rule aux)
    finally show "N ≤ φ ?k"
      by this
  qed
  ultimately have "?k ≥ N' ∧ φ ?k ≥ N"
    by (rule conjI)
  then show "∃k ≥ N'. φ k ≥ N"
    by (rule exI)
qed

(* 2ª demostración *)
lemma
  assumes "extraccion φ"
  shows   "∀ N N'. ∃ k ≥ N'. φ k ≥ N"
proof (intro allI)
  fix N N' :: nat
  let ?k = "max N N'"
  have "?k ≥ N'"
    by simp
  moreover
  have "N ≤ φ ?k"
  proof -
    have "N ≤ ?k"
      by simp
    also have "… ≤ φ ?k"
      using assms by (rule aux)
    finally show "N ≤ φ ?k"
      by this
  qed
  ultimately show "∃k ≥ N'. φ k ≥ N"
    by blast
qed

end

theory Las_funciones_de_extraccion_no_estan_acotadas

imports Main

begin

definition extraccion :: "(nat ⇒ nat) ⇒ bool" where

"extraccion φ ⟷ (∀ n m. n < m ⟶ φ n < φ m)"

(* En la demostración se usará el siguiente lema *)

lemma aux :

assumes "extraccion φ"

shows "n ≤ φ n"

proof (induct n)

show "0 ≤ φ 0"

by simp

fix n

assume HI : "n ≤ φ n"

also have "φ n < φ (Suc n)"

using assms extraccion_def by blast

finally show "Suc n ≤ φ (Suc n)"

by simp

qed

(* 1ª demostración *)

lemma

assumes "extraccion φ"

shows "∀ N N'. ∃ k ≥ N'. φ k ≥ N"

proof (intro allI)

fix N N' :: nat

let ?k = "max N N'"

have "max N N' ≤ ?k"

by (rule le_refl)

then have hk : "N ≤ ?k ∧ N' ≤ ?k"

by (simp only: max.bounded_iff)

then have "?k ≥ N'"

by (rule conjunct2)

moreover

have "N ≤ φ ?k"

proof -

have "N ≤ ?k"

using hk by (rule conjunct1)

also have "… ≤ φ ?k"

using assms by (rule aux)

finally show "N ≤ φ ?k"

by this

qed

ultimately have "?k ≥ N' ∧ φ ?k ≥ N"

by (rule conjI)

then show "∃k ≥ N'. φ k ≥ N"

by (rule exI)

qed

(* 2ª demostración *)

lemma

assumes "extraccion φ"

shows "∀ N N'. ∃ k ≥ N'. φ k ≥ N"

proof (intro allI)

fix N N' :: nat

let ?k = "max N N'"

have "?k ≥ N'"

by simp

moreover

have "N ≤ φ ?k"

proof -

have "N ≤ ?k"

by simp

also have "… ≤ φ ?k"

using assms by (rule aux)

finally show "N ≤ φ ?k"

by this

qed

ultimately show "∃k ≥ N'. φ k ≥ N"

by blast

qed

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]

Las particiones definen relaciones reflexivas

PorJosé A. Alonso 25 agosto 202119 agosto 2021

Cada familia de conjuntos P define una relación de forma que dos elementos están relacionados si algún conjunto de P contiene a ambos elementos. Se puede definir en Lean por

   def relacion (P : set (set X)) (x y : X) :=
     ∃ A ∈ P, x ∈ A ∧ y ∈ A

1 2	def relacion (P : set (set X)) (x y : X) := ∃ A ∈ P, x ∈ A ∧ y ∈ A

Una familia de subconjuntos de X es una partición de X si cada elemento de X pertenece a un único conjunto de P y todos los elementos de P son no vacíos. Se puede definir en Lean por

   def particion (P : set (set X)) : Prop :=
     (∀ x, (∃ B ∈ P, x ∈ B ∧ ∀ C ∈ P, x ∈ C → B = C)) ∧ ∅ ∉ P

1 2	def particion (P : set (set X)) : Prop := (∀ x, (∃ B ∈ P, x ∈ B ∧ ∀ C ∈ P, x ∈ C → B = C)) ∧ ∅ ∉ P

Demostrar que si P es una partición de X, entonces la relación definida por P es reflexiva.

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

import tactic

variable {X : Type}
variable (P : set (set X))

def relacion (P : set (set X)) (x y : X) :=
  ∃ A ∈ P, x ∈ A ∧ y ∈ A

def particion (P : set (set X)) : Prop :=
  (∀ x, (∃ B ∈ P, x ∈ B ∧ ∀ C ∈ P, x ∈ C → B = C)) ∧ ∅ ∉ P

example
  (h : particion P)
  : reflexive (relacion P) :=
sorry

import tactic

variable {X : Type}

variable (P : set (set X))

def relacion (P : set (set X)) (x y : X) :=

∃ A ∈ P, x ∈ A ∧ y ∈ A

def particion (P : set (set X)) : Prop :=

(∀ x, (∃ B ∈ P, x ∈ B ∧ ∀ C ∈ P, x ∈ C → B = C)) ∧ ∅ ∉ P

example

(h : particion P)

: reflexive (relacion P) :=

sorry

[expand title=»Soluciones con Lean»]

import tactic

variable {X : Type}
variable (P : set (set X))

def relacion (P : set (set X)) (x y : X) :=
  ∃ A ∈ P, x ∈ A ∧ y ∈ A

def particion (P : set (set X)) : Prop :=
  (∀ x, (∃ B ∈ P, x ∈ B ∧ ∀ C ∈ P, x ∈ C → B = C)) ∧ ∅ ∉ P

-- 1ª demostración
example
  (h : particion P)
  : reflexive (relacion P) :=
begin
  unfold reflexive,
  intro x,
  unfold relacion,
  unfold particion at h,
  replace h : ∃ A ∈ P, x ∈ A ∧ ∀ B ∈ P, x ∈ B → A = B := h.1 x,
  rcases h with ⟨A, hAP, hxA, -⟩,
  use A,
  repeat { split },
  { exact hAP, },
  { exact hxA, },
  { exact hxA, },
end

-- 2ª demostración
example
  (h : particion P)
  : reflexive (relacion P) :=
begin
  intro x,
  replace h : ∃ A ∈ P, x ∈ A ∧ ∀ B ∈ P, x ∈ B → A = B := h.1 x,
  rcases h with ⟨A, hAP, hxA, -⟩,
  use A,
  repeat { split } ; assumption,
end

-- 3ª demostración
example
  (h : particion P)
  : reflexive (relacion P) :=
begin
  intro x,
  rcases (h.1 x) with ⟨A, hAP, hxA, -⟩,
  use A,
  repeat { split } ; assumption,
end

-- 4ª demostración
example
  (h : particion P)
  : reflexive (relacion P) :=
begin
  intro x,
  rcases (h.1 x) with ⟨A, hAP, hxA, -⟩,
  use [A, ⟨hAP, hxA, hxA⟩],
end

import tactic

variable {X : Type}

variable (P : set (set X))

def relacion (P : set (set X)) (x y : X) :=

∃ A ∈ P, x ∈ A ∧ y ∈ A

def particion (P : set (set X)) : Prop :=

(∀ x, (∃ B ∈ P, x ∈ B ∧ ∀ C ∈ P, x ∈ C → B = C)) ∧ ∅ ∉ P

-- 1ª demostración

example

(h : particion P)

: reflexive (relacion P) :=

begin

unfold reflexive,

intro x,

unfold relacion,

unfold particion at h,

replace h : ∃ A ∈ P, x ∈ A ∧ ∀ B ∈ P, x ∈ B → A = B := h.1 x,

rcases h with ⟨A, hAP, hxA, -⟩,

use A,

repeat { split },

{ exact hAP, },

{ exact hxA, },

end

-- 2ª demostración

example

(h : particion P)

: reflexive (relacion P) :=

begin

intro x,

replace h : ∃ A ∈ P, x ∈ A ∧ ∀ B ∈ P, x ∈ B → A = B := h.1 x,

rcases h with ⟨A, hAP, hxA, -⟩,

use A,

repeat { split } ; assumption,

end

-- 3ª demostración

example

(h : particion P)

: reflexive (relacion P) :=

begin

intro x,

rcases (h.1 x) with ⟨A, hAP, hxA, -⟩,

use A,

repeat { split } ; assumption,

end

-- 4ª demostración

example

(h : particion P)

: reflexive (relacion P) :=

begin

intro x,

rcases (h.1 x) with ⟨A, hAP, hxA, -⟩,

use [A, ⟨hAP, hxA, hxA⟩],

end

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 Las_particiones_definen_relaciones_reflexivas
imports Main
begin

definition relacion :: "('a set) set ⇒ 'a ⇒ 'a ⇒ bool" where
  "relacion P x y ⟷ (∃A∈P. x ∈ A ∧ y ∈ A)"

definition particion :: "('a set) set ⇒ bool" where
  "particion P ⟷ (∀x. (∃B∈P. x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C))) ∧ {} ∉ P"

ru(* 1ª demostración *)
lemma
  assumes "particion P"
  shows   "reflp (relacion P)"
proof (rule reflpI)
  fix x
  have "(∀x. (∃B∈P. x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C))) ∧ {} ∉ P"
    using assms by (unfold particion_def)
  then have "∀x. (∃B∈P. x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C))"
    by (rule conjunct1)
  then have "∃B∈P. x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C)"
    by (rule allE)
  then obtain B where "B ∈ P ∧ (x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C))"
    by (rule someI2_bex)
  then obtain B where "(B ∈ P ∧ x ∈ B) ∧ (∀C∈P. x ∈ C ⟶ B = C)"
    by (simp only: conj_assoc)
  then have "B ∈ P ∧ x ∈ B"
    by (rule conjunct1)
  then have "x ∈ B"
    by (rule conjunct2)
  then have "x ∈ B ∧ x ∈ B"
    using ‹x ∈ B› by (rule conjI)
  moreover have "B ∈ P"
    using ‹B ∈ P ∧ x ∈ B› by (rule conjunct1)
  ultimately have "∃B∈P. x ∈ B ∧ x ∈ B"
    by (rule bexI)
  then show "relacion P x x"
    by (unfold relacion_def)
qed

(* 2ª demostración *)
lemma
  assumes "particion P"
  shows   "reflp (relacion P)"
proof (rule reflpI)
  fix x
  obtain A where "A ∈ P ∧ x ∈ A"
    using assms particion_def
    by metis
  then show "relacion P x x"
    using relacion_def
    by metis
qed

(* 3ª demostración *)
lemma
  assumes "particion P"
  shows   "reflp (relacion P)"
  using assms particion_def relacion_def
  by (metis reflp_def)

end

theory Las_particiones_definen_relaciones_reflexivas

imports Main

begin

definition relacion :: "('a set) set ⇒ 'a ⇒ 'a ⇒ bool" where

"relacion P x y ⟷ (∃A∈P. x ∈ A ∧ y ∈ A)"

definition particion :: "('a set) set ⇒ bool" where

"particion P ⟷ (∀x. (∃B∈P. x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C))) ∧ {} ∉ P"

ru(* 1ª demostración *)

lemma

assumes "particion P"

shows "reflp (relacion P)"

proof (rule reflpI)

fix x

have "(∀x. (∃B∈P. x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C))) ∧ {} ∉ P"

using assms by (unfold particion_def)

then have "∀x. (∃B∈P. x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C))"

by (rule conjunct1)

then have "∃B∈P. x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C)"

by (rule allE)

then obtain B where "B ∈ P ∧ (x ∈ B ∧ (∀C∈P. x ∈ C ⟶ B = C))"

by (rule someI2_bex)

then obtain B where "(B ∈ P ∧ x ∈ B) ∧ (∀C∈P. x ∈ C ⟶ B = C)"

by (simp only: conj_assoc)

then have "B ∈ P ∧ x ∈ B"

by (rule conjunct1)

then have "x ∈ B"

by (rule conjunct2)

then have "x ∈ B ∧ x ∈ B"

using ‹x ∈ B› by (rule conjI)

moreover have "B ∈ P"

using ‹B ∈ P ∧ x ∈ B› by (rule conjunct1)

ultimately have "∃B∈P. x ∈ B ∧ x ∈ B"

by (rule bexI)

then show "relacion P x x"

by (unfold relacion_def)

qed

(* 2ª demostración *)

lemma

assumes "particion P"

shows "reflp (relacion P)"

proof (rule reflpI)

fix x

obtain A where "A ∈ P ∧ x ∈ A"

using assms particion_def

by metis

then show "relacion P x x"

using relacion_def

by metis

qed

(* 3ª demostración *)

lemma

assumes "particion P"

shows "reflp (relacion P)"

using assms particion_def relacion_def

by (metis reflp_def)

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]