Artículos

2.2.1: Ejercicios 2.2

2.2.1: Ejercicios 2.2


We are searching data for your request:

Forums and discussions:
Manuals and reference books:
Data from registers:
Wait the end of the search in all databases.
Upon completion, a link will appear to access the found materials.

En los ejercicios ( PageIndex {1} ) - ( PageIndex {12} ), se definen los vectores de fila y columna ( vec {u} ) y ( vec {v} ). Encuentre el producto ( vec {u} vec {v} ), donde sea posible.

Ejercicio ( PageIndex {1} )

( vec {u} = left [ begin {array} {cc} {1} & {- 4} end {array} right] quad vec {v} = left [ begin {array } {c} {- 2} {5} end {matriz} derecha] )

Respuesta

(-22)

Ejercicio ( PageIndex {2} )

( vec {u} = left [ begin {array} {cc} {2} & {3} end {array} right] quad vec {v} = left [ begin {array} {c} {7} {- 4} end {matriz} derecha] )

Respuesta

(2)

Ejercicio ( PageIndex {3} )

( vec {u} = left [ begin {array} {cc} {1} & {- 1} end {array} right] quad vec {v} = left [ begin {array } {c} {3} {3} end {matriz} derecha] )

Respuesta

(0)

Ejercicio ( PageIndex {4} )

( vec {u} = left [ begin {array} {cc} {0.6} & {0.8} end {array} right] quad vec {v} = left [ begin {array} {c} {0.6} {0.8} end {matriz} derecha] )

Respuesta

(1)

Ejercicio ( PageIndex {5} )

( vec {u} = left [ begin {array} {ccc} {1} & {2} & {- 1} end {array} right] quad vec {v} = left [ begin {array} {c} {2} {1} {- 1} end {array} right] )

Respuesta

(5)

Ejercicio ( PageIndex {6} )

( vec {u} = left [ begin {array} {ccc} {3} & {2} & {- 2} end {array} right] quad vec {v} = left [ begin {array} {c} {- 1} {0} {9} end {array} right] )

Respuesta

(-21)

Ejercicio ( PageIndex {7} )

( vec {u} = left [ begin {array} {ccc} {8} & {- 4} & {3} end {array} right] quad vec {v} = left [ begin {array} {c} {2} {4} {5} end {array} right] )

Respuesta

(15)

Ejercicio ( PageIndex {8} )

( vec {u} = left [ begin {array} {ccc} {- 3} & {6} & {1} end {array} right] quad vec {v} = left [ begin {array} {c} {1} {- 1} {1} end {array} right] )

Respuesta

(-8)

Ejercicio ( PageIndex {9} )

( vec {u} = left [ begin {array} {cccc} {1} & {2} & {3} & {4} end {array} right] quad vec {v} = left [ begin {array} {c} {1} {- 1} {1} {- 1} end {array} right] )

Respuesta

(-2)

Ejercicio ( PageIndex {10} )

( vec {u} = left [ begin {array} {cccc} {6} & {2} & {- 1} & {2} end {array} right] quad vec {v} = left [ begin {array} {c} {3} {2} {9} {5} end {array} right] )

Respuesta

(23)

Ejercicio ( PageIndex {11} )

( vec {u} = left [ begin {array} {ccc} {1} & {2} & {3} end {array} right] quad vec {v} = left [ comenzar {matriz} {c} {3} {2} end {matriz} derecha] )

Respuesta

Imposible.

Ejercicio ( PageIndex {12} )

( vec {u} = left [ begin {array} {cc} {2} & {- 5} end {array} right] quad vec {v} = left [ begin {array } {c} {1} {1} {1} end {matriz} derecha] )

Respuesta

Imposible.

En los ejercicios ( PageIndex {13} ) - ( PageIndex {27} ), se definen las matrices (A ) y (B ).

  1. Da las dimensiones de (A ) y (B ). Si las dimensiones coinciden correctamente, proporcione las dimensiones de (AB ) y (BA ).
  2. Encuentra los productos (AB ) y (BA ), si es posible.

Ejercicio ( PageIndex {13} )

(A = left [ begin {array} {cc} {1} & {2} {- 1} & {4} end {array} right] ) (B = left [ begin {array} {cc} {2} & {5} {3} & {- 1} end {array} right] )

Respuesta

(AB = left [ begin {array} {cc} {8} & {3} {10} & {- 9} end {array} right] )

(BA = left [ begin {array} {cc} {- 3} & {24} {4} & {2} end {array} right] )

Ejercicio ( PageIndex {14} )

(A = left [ begin {array} {cc} {3} & {7} {2} & {5} end {array} right] ) (B = left [ begin {matriz} {cc} {1} & {- 1} {3} & {- 3} end {matriz} derecha] )

Respuesta

(AB = left [ begin {array} {cc} {24} & {- 24} {17} & {- 17} end {array} right] )

(BA = left [ begin {array} {cc} {1} & {2} {3} & {6} end {array} right] )

Ejercicio ( PageIndex {15} )

(A = left [ begin {array} {cc} {3} & {- 1} {2} & {2} end {array} right] ) (B = left [ begin {array} {ccc} {1} & {0} & {7} {4} & {2} & {9} end {array} right] )

Respuesta

(AB = left [ begin {array} {ccc} {- 1} & {- 2} & {12} {10} & {4} & {32} end {array} right] )

(BA ) no es posible.

Ejercicio ( PageIndex {16} )

(A = left [ begin {array} {cc} {0} & {1} {1} & {- 1} {- 2} & {- 4} end {array} right ] ) (B = left [ begin {array} {cc} {- 2} & {0} {3} & {8} end {array} right] )

Respuesta

(AB = left [ begin {array} {cc} {3} & {8} {- 5} & {- 8} {- 8} & {- 32} end {array} derecho])

(BA ) no es posible.

Ejercicio ( PageIndex {17} )

(A = left [ begin {array} {ccc} {9} & {4} & {3} {9} & {- 5} & {9} end {array} right] ) (B = left [ begin {array} {cc} {- 2} & {5} {- 2} & {- 1} end {array} right] )

Respuesta

(AB ) no es posible.

(BA = left [ begin {array} {ccc} {27} & {- 33} & {39} {- 27} & {- 3} & {- 15} end {array} right ] )

Ejercicio ( PageIndex {18} )

(A = left [ begin {array} {cc} {- 2} & {- 1} {9} & {- 5} {3} & {- 1} end {array} right] ) (B = left [ begin {array} {ccc} {- 5} & {6} & {- 4} {0} & {6} & {- 3} end {array }derecho])

Respuesta

(AB = left [ begin {array} {ccc} {10} & {- 18} & {11} {- 45} & {24} & {- 21} {- 15} & { 12} & {- 9} end {matriz} derecha] )

(BA = left [ begin {array} {cc} {52} & {- 21} {45} & {- 27} end {array} right] )

Ejercicio ( PageIndex {19} )

(A = left [ begin {array} {cc} {2} & {6} {6} & {2} {5} & {- 1} end {array} right] ) (B = left [ begin {array} {ccc} {- 4} & {5} & {0} {- 4} & {4} & {- 4} end {array} right ] )

Respuesta

(AB = left [ begin {array} {ccc} {- 32} & {34} & {- 24} {- 32} & {38} & {- 8} {- 16} & {21} & {4} end {array} right] )

(BA = left [ begin {array} {cc} {22} & {- 14} {- 4} & {- 12} end {array} right] )

Ejercicio ( PageIndex {20} )

(A = left [ begin {array} {cc} {- 5} & {2} {- 5} & {- 2} {- 5} & {- 4} end {array} right] ) (B = left [ begin {array} {ccc} {0} & {- 5} & {6} {- 5} & {- 3} & {- 1} end {matriz} derecha] )

Respuesta

(AB = left [ begin {array} {ccc} {- 10} & {19} & {- 32} {10} & {31} & {- 28} {20} & {37 } & {- 26} end {matriz} derecha] )

(BA = left [ begin {array} {cc} {- 5} & {- 14} {45} & {0} end {array} right] )

Ejercicio ( PageIndex {21} )

(A = left [ begin {array} {cc} {8} & {- 2} {4} & {5} {2} & {- 5} end {array} right] ) (B = left [ begin {array} {ccc} {- 5} & {1} & {- 5} {8} & {3} & {- 2} end {array} derecho])

Respuesta

(AB = left [ begin {array} {ccc} {- 56} & {2} & {- 36} {20} & {19} & {- 30} {- 50} & { -13} & {0} end {array} right] )

(BA = left [ begin {array} {cc} {- 46} & {40} {72} & {9} end {array} right] )

Ejercicio ( PageIndex {22} )

(A = left [ begin {array} {cc} {1} & {4} {7} & {6} end {array} right] ) (B = left [ begin {array} {cccc} {1} & {- 1} & {- 5} & {5} {- 2} & {1} & {3} & {- 5} end {array} right] )

Respuesta

(AB = left [ begin {array} {cccc} {- 7} & {3} & {7} & {- 15} {- 5} & {- 1} & {- 17} & { 5} end {matriz} derecha] )

(BA ) no es posible.

Ejercicio ( PageIndex {23} )

(A = left [ begin {array} {cc} {- 1} & {5} {6} & {7} end {array} right] ) (B = left [ begin {array} {cccc} {5} & {- 3} & {- 4} & {- 4} {- 2} & {- 5} & {- 5} & {- 1} end {array }derecho])

Respuesta

(AB = left [ begin {array} {cccc} {- 15} & {- 22} & {- 21} & {- 1} {16} & {- 53} & {- 59} & {-31} end {matriz} derecha] )

(BA ) no es posible.

Ejercicio ( PageIndex {24} )

(A = left [ begin {array} {ccc} {- 1} & {2} & {1} {- 1} & {2} & {- 1} {0} & {0 } & {- 2} end {array} right] ) (B = left [ begin {array} {ccc} {0} & {0} & {- 2} {1} & { 2} & {- 1} {1} & {0} & {0} end {array} right] )

Respuesta

(AB = left [ begin {array} {ccc} {3} & {4} & {0} {1} & {4} & {0} {- 2} & {0} & {0} end {array} right] )

(BA = left [ begin {array} {ccc} {0} & {0} & {4} {- 3} & {6} & {1} {- 1} & {2} & {1} end {array} right] )

Ejercicio ( PageIndex {25} )

(A = left [ begin {array} {ccc} {- 1} & {1} & {1} {- 1} & {- 1} & {- 2} {1} & { 1} & {- 2} end {array} right] ) (B = left [ begin {array} {ccc} {- 2} & {- 2} & {- 2} {0 } & {- 2} & {0} {- 2} & {0} & {2} end {array} right] )

Respuesta

(AB = left [ begin {array} {ccc} {0} & {0} & {4} {6} & {4} & {- 2} {2} & {- 4} & {- 6} end {matriz} derecha] )

(BA = left [ begin {array} {ccc} {2} & {- 2} & {6} {2} & {2} & {4} {4} & {0} & {-6} end {matriz} derecha] )

Ejercicio ( PageIndex {26} )

(A = left [ begin {array} {ccc} {- 4} & {3} & {3} {- 5} & {- 1} & {- 5} {- 5} & {0} & {- 1} end {array} right] ) (B = left [ begin {array} {ccc} {0} & {5} & {0} {- 5} & {- 4} & {3} {5} & {- 4} & {3} end {array} right] )

Respuesta

(AB = left [ begin {array} {ccc} {0} & {- 44} & {18} {- 20} & {- 1} & {- 18} {- 5} & {-21} y {- 3} end {matriz} derecha] )

(BA = left [ begin {array} {ccc} {- 25} & {- 5} & {- 25} {25} & {- 11} & {2} {- 15} & {19} & {32} end {array} right] )

Ejercicio ( PageIndex {27} )

(A = left [ begin {array} {ccc} {- 4} & {- 1} & {3} {2} & {- 3} & {5} {1} & {5 } & {3} end {array} right] ) (B = left [ begin {array} {ccc} {- 2} & {4} & {3} {- 1} & { 1} & {- 1} {4} & {0} & {2} end {array} right] )

Respuesta

(AB = left [ begin {array} {ccc} {21} & {- 17} & {- 5} {19} & {5} & {19} {5} & {9} & {4} end {matriz} derecha] )

(BA = left [ begin {array} {ccc} {19} & {5} & {23} {5} & {- 7} & {- 1} {- 14} & {6 } & {18} end {array} right] )

En los ejercicios ( PageIndex {28} ) - ( PageIndex {33} ), un diagonal Se dan una matriz (D ) y una matriz (A ). Encuentre los productos (DA ) y (AD ), cuando sea posible.

Ejercicio ( PageIndex {28} )

(D = left [ begin {array} {cc} {3} & {0} {0} & {- 1} end {array} right] ) (A = left [ begin {array} {cc} {2} & {4} {6} & {8} end {array} right] )

Respuesta

(DA = left [ begin {array} {cc} {6} & {- 4} {18} & {- 8} end {array} right] )

(AD = left [ begin {array} {cc} {6} & {12} {- 6} & {- 8} end {array} right] )

Ejercicio ( PageIndex {29} )

(D = left [ begin {array} {cc} {4} & {0} {0} & {- 3} end {array} right] ) (A = left [ begin {array} {cc} {1} & {2} {1} & {2} end {array} right] )

Respuesta

(DA = left [ begin {array} {cc} {4} & {- 6} {4} & {- 6} end {array} right] )

(AD = left [ begin {array} {cc} {4} & {8} {- 3} & {- 6} end {array} right] )

Ejercicio ( PageIndex {30} )

(D = left [ begin {array} {ccc} {- 1} & {0} & {0} {0} & {2} & {0} {0} & {0} & {3} end {matriz} right] ) (A = left [ begin {matriz} {ccc} {1} & {2} & {3} {4} & {5} & { 6} {7} & {8} & {9} end {array} right] )

Respuesta

(DA = left [ begin {array} {ccc} {- 1} & {4} & {9} {- 4} & {10} & {18} {- 7} & {16 } & {27} end {array} right] )

(AD = left [ begin {array} {ccc} {- 1} & {- 2} & {- 3} {8} & {10} & {12} {21} & {24 } & {27} end {array} right] )

Ejercicio ( PageIndex {31} )

(D = left [ begin {array} {ccc} {1} & {1} & {1} {2} & {2} & {2} {- 3} & {- 3} & {- 3} end {array} right] ) (A = left [ begin {array} {ccc} {2} & {0} & {0} {0} & {- 3 } & {0} {0} & {0} & {5} end {array} right] )

Respuesta

(DA = left [ begin {array} {ccc} {2} & {2} & {2} {- 6} & {- 6} & {- 6} {- 15} & { -15} & {- 15} end {matriz} derecha] )

(AD = left [ begin {array} {ccc} {2} & {- 3} & {5} {4} & {- 6} & {10} {- 6} & {9 } & {- 15} end {matriz} derecha] )

Ejercicio ( PageIndex {32} )

(D = left [ begin {array} {cc} {d_ {1}} & {0} {0} & {d_ {2}} end {array} right] ) (A = left [ begin {array} {cc} {a} & {b} {c} & {d} end {array} right] )

Respuesta

(DA = left [ begin {array} {cc} {d_ {1} a} & {d_ {1} b} {d_ {2} c} & {d_ {2} d} end { matriz} derecha] )

(AD = left [ begin {array} {cc} {d_ {1} a} & {d_ {2} b} {d_ {1} c} & {d_ {2} d} end { matriz} derecha] )

Ejercicio ( PageIndex {33} )

(D = left [ begin {array} {ccc} {d_ {1}} & {0} & {0} {0} & {d_ {2}} & {0} {0} & {0} & {d_ {3}} end {array} right] ) (A = left [ begin {array} {ccc} {a} & {b} & {c} { d} & {e} & {f} {g} & {h} & ​​{i} end {array} right] )

Respuesta

(DA = left [ begin {array} {ccc} {d_ {1} a} & {d_ {1} b} & {d_ {1} c} {d_ {2} d} & {d_ {2} e} & {d_ {2} f} {d_ {3} g} & {d_ {3} h} & {d_ {3} i} end {array} right] )

(AD = left [ begin {array} {ccc} {d_ {1} a} & {d_ {2} b} & {d_ {3} c} {d_ {1} d} & {d_ {2} e} & {d_ {3} f} {d_ {1} g} & {d_ {2} h} & {d_ {3} i} end {array} right] )

En los ejercicios ( PageIndex {34} ) - ( PageIndex {39} ), se dan una matriz (A ) y un vector ( vec {x} ). Encuentra el producto (A vec {x} ).

Ejercicio ( PageIndex {34} )

(A = left [ begin {array} {cc} {2} & {3} {1} & {- 1} end {array} right] ), ( vec {x} = left [ begin {array} {c} {4} {9} end {array} right] )

Respuesta

(A vec {x} = left [ begin {array} {c} {35} {- 5} end {array} right] )

Ejercicio ( PageIndex {35} )

(A = left [ begin {array} {cc} {- 1} & {4} {7} & {3} end {array} right] ), ( vec {x} = left [ begin {array} {c} {2} {- 1} end {array} right] )

Respuesta

(A vec {x} = left [ begin {array} {c} {- 6} {11} end {array} right] )

Ejercicio ( PageIndex {36} )

(A = left [ begin {array} {ccc} {2} & {0} & {3} {1} & {1} & {1} {3} & {- 1} & {2} end {matriz} derecha] ), ( vec {x} = left [ begin {matriz} {c} {1} {4} {2} end {matriz }derecho])

Respuesta

(A vec {x} = left [ begin {array} {c} {8} {7} {3} end {array} right] )

Ejercicio ( PageIndex {37} )

(A = left [ begin {array} {ccc} {- 2} & {0} & {3} {1} & {1} & {- 2} {4} & {2} & {- 1} end {matriz} right] ), ( vec {x} = left [ begin {matriz} {c} {4} {3} {1} end {matriz} derecha] )

Respuesta

(A vec {x} = left [ begin {array} {c} {- 5} {5} {21} end {array} right] )

Ejercicio ( PageIndex {38} )

(A = left [ begin {array} {cc} {2} & {- 1} {4} & {3} end {array} right] ), ( vec {x} = left [ begin {array} {c} {x_ {1}} {x_ {2}} end {array} right] )

Respuesta

(A vec {x} = left [ begin {array} {c} {2x_ {1} -x_ {2}} {4x_ {1} + 3x_ {2}} end {array} derecho])

Ejercicio ( PageIndex {39} )

(A = left [ begin {array} {ccc} {1} & {2} & {3} {1} & {0} & {2} {2} & {3} & { 1} end {matriz} derecha] ), ( vec {x} = left [ begin {matriz} {c} {x_ {1}} {x_ {2}} {x_ {3}} end {matriz} derecha] )

Respuesta

(A vec {x} left [ begin {array} {c} {x_ {1} + 2x_ {2} + 3x_ {3}} {x_ {1} + 2x_ {3}} {2x_ {1} + 3x_ {2} + x_ {3}} end {matriz} right] )

Ejercicio ( PageIndex {40} )

Sea (A = left [ begin {array} {cc} {0} & {1} {1} & {0} end {array} right] ). Encuentra (A ^ {2} ) y (A ^ {3} ).

Respuesta

(A ^ {2} = left [ begin {array} {cc} {1} & {0} {0} & {1} end {array} right] ); (A ^ {3} = left [ begin {array} {cc} {0} & {1} {1} & {0} end {array} right] )

Ejercicio ( PageIndex {41} )

Sea (A = left [ begin {array} {cc} {2} & {0} {0} & {3} end {array} right] ). Encuentra (A ^ {2} ) y (A ^ {3} ).

Respuesta

(A ^ {2} = left [ begin {array} {cc} {4} & {0} {0} & {9} end {array} right] ); (A ^ {3} = left [ begin {array} {cc} {8} & {0} {0} & {27} end {array} right] )

Ejercicio ( PageIndex {42} )

Sea (A = left [ begin {array} {ccc} {- 1} & {0} & {0} {0} & {3} & {0} {0} & {0} & {5} end {matriz} derecha] ). Encuentra (A ^ {2} ) y (A ^ {3} ).

Respuesta

(A ^ {2} = left [ begin {array} {ccc} {1} & {0} & {0} {0} & {9} & {0} {0} & { 0} & {25} end {array} right] ); (A ^ {3} = left [ begin {array} {ccc} {- 1} & {0} & {0} {0} & {27} & {0} {0} & {0} & {125} end {array} right] )

Ejercicio ( PageIndex {43} )

Deje (A = left [ begin {array} {ccc} {0} & {1} & {0} {0} & {0} & {1} {1} & {0} & {0} end {array} right] ). Encuentra (A ^ {2} ) y (A ^ {3} ).

Respuesta

(A ^ {2} = left [ begin {array} {ccc} {0} & {0} & {1} {1} & {0} & {0} {0} & { 1} & {0} end {array} right] ); (A ^ {3} = left [ begin {array} {ccc} {1} & {0} & {0} {0} & {1} & {0} {0} & { 0} & {1} end {array} right] )

Ejercicio ( PageIndex {44} )

Deje (A = left [ begin {array} {ccc} {0} & {0} & {1} {0} & {0} & {0} {0} & {1} & {0} end {matriz} right] ). Encuentra (A ^ {2} ) y (A ^ {3} ).

Respuesta

(A ^ {2} = left [ begin {array} {ccc} {0} & {1} & {0} {0} & {0} & {0} {0} & { 0} & {0} end {array} right] ); (A ^ {3} = left [ begin {array} {ccc} {0} & {0} & {0} {0} & {0} & {0} {0} & { 0} & {0} end {array} right] )

Ejercicio ( PageIndex {45} )

En el texto, declaramos que ((A + B) ^ {2} neq A ^ {2} + 2AB + B ^ {2} ). Investigamos esa afirmación aquí.

  1. Deje (A = left [ begin {array} {cc} {5} & {3} {- 3} & {- 2} end {array} right] ) y deje (B = left [ begin {array} {cc} {- 5} & {- 5} {- 2} & {1} end {array} right] ). Calcule (A + B ).
  2. Encuentra ((A + B) ^ {2} ) usando tu respuesta de (a).
  3. Calcule (A ^ {2} + 2AB + B ^ {2} ).
  4. ¿Son iguales los resultados de (a) y (b)?
  5. Expande con cuidado la expresión ((A + B) ^ {2} = (A + B) (A + B) ) y muestra por qué esto no es igual a (A ^ {2} + 2AB + B ^ {2 } ).
Respuesta
  1. ( left [ begin {array} {cc} {0} & {- 2} {- 5} & {- 1} end {array} right] )
  2. ( left [ begin {array} {cc} {10} & {2} {5} & {11} end {array} right] )
  3. ( left [ begin {array} {cc} {- 11} & {- 15} {37} & {32} end {array} right] )
  4. No
  5. ((A + B) (A + B) = AA + AB + BA + BB = A ^ {2} + AB + BA + B ^ {2} )

Ejercicio 2.2.1 en Análisis de Terence Tao Inducción Prueba de adición Ley asociativa Números naturales

La proposición 2.2.5 y también el ejercicio 2.2.1 de Análisis de Terence Tao son los siguientes:

Muestre para cualquier número natural $ a, b, c $, tenemos $ (a + b) + c = a + (b + c) $ la regla asociativa

La prueba debe usar inducción.

Definición: + n = n $ para $ n $ es un número natural ($ también es un número natural)

Definición de adición: $ (n ++) + m = (n + m) ++ $ donde $ n ++ $ es incremento en n

Así que mi humilde intento es (ya que no soy muy bueno en matemáticas ...)

Para caso = $ y si arreglamos $ a $ y $ b $ e incrementamos $ c $

(1) Queremos mostrar: $ (a + b) +0 = a + (b + 0) $.

El lado izquierdo es $ (a + b) +0 = a + b $ usando Lema 2.2.2 y ver $ (a + b) $ como una entidad | El lado derecho es $ a + (b + 0) = a + b $ también usando Lema 2.2.2 en el hecho de que $ (b + 0) = b $

(2) Utilice la inducción para demostrar que para el caso $ n $ esto es cierto

Para caso = $ 1 $ : Mostrar $ (a + b) +1 = a + (b + 1) $

El lado izquierdo es $ (a + b) +1 = (a + b) ++ $ por definición de incremento de Números naturales si vemos $ (a + b) $ como una entidad y $ (a + b) + 1 $ es un incremento de $ 1 $

El lado derecho es $ a + (b + 1) = a + (b ++) dfrac <=> (a + b) ++ $

Para caso = $ 2 $ : Mostrar $ (a + b) +2 = a + (b + 2) $

El lado izquierdo es $ (a + b) +2 = ((a + b) ++) ++ $ por definición de incremento de Números naturales si vemos $ (a + b) $ como una entidad y $ (a + b ) + 2 $ son incrementos de $ 2 $

El lado derecho es $ a + (b + 2) = a + (b + 1) ++ = (a + b + 1) ++ = (a + b ++) ++ = ((a + b) ++) ++ $ si sigue aplicando Lema 2.2.3

Para caso = $ n $ : Mostrar $ (a + b) + n = a + (b + n) $

El lado izquierdo es $ (a + b) + n = (((a + b) ++) ++) cdots) ++ $ por definición de incremento de Números Naturales si vemos $ (a + b) $ como un entidad y $ (a + b) + n $ es $ n $ incrementos de ella donde hay $ n $ signos de + $

El lado derecho es $ a + (b + n) = a + (b + (n-1) ++) = a + (b + n-1) ++ = a + (b + (n-2) ++) ++ = a + ((b + (n-2)) ++) ++ = cdots = ((((a + b) ++) ++) cdots) ++ $ si sigue aplicando Lema 2.2.3, y hay $ n $ signos de + $

Entonces sabemos por caso = $ n $ esto es también Cierto

(3) Ahora solo necesitamos mostrarnos caso = $ n + 1 $ es Cierto para completar la inducción.

Mostramos: $ (a + b) + n + 1 = a + (b + n + 1) $ Por:

Lado izquierdo $ (a + b) + n + 1 = (a + b) + (n ++) = (a + b + n) ++ $ Usando Lema 2.2.3

Lado derecho $ a + (b + n + 1) = a + (b + (n ++)) = a + ((b + n) ++) = (a + b + n) ++ $ Seguir aplicando * Lema 2.2.3 **

Así $ (a + b) + n + 1 = (a + b + n) ++ = a + (b + n + 1) $

Así la prueba está completa.

** ¿Alguien podría ayudarme a verificar si lo anterior es una prueba rigurosa de la regla asociativa para números naturales? **


EJERCICIOS 2.2 & quot1. ¿Cuál de los siguientes subconjuntos de R & quot está abierto? ¿cerrado? ¿ninguno de los dos? Demuestre su respuesta. (a) (x: 0 x & lt 2> CR (b) (x: x = 2 para algunos k eN o = 0) C R X CR2 y = x (g) y (h) C R & quot (i) x | x 1> C R & quot (G) x || xl1> C R & quot (k) el conjunto de números racionales, QCR Xr (c) X- (d) 1 X- 10 (1I) X: | x 1 o C R2 (e) CR2 (m) Ø (el conjunto vacío) X (f) xy 0 R2 y 2. Sea ser una secuencia de puntos en R & quot. Para i = 1, ... , n, sea xki la coordenada i-ésima del vector x. Demuestre que xk a si y solo si xki ai para todo i = 1,. n 3. Suponga que (x> es una secuencia de puntos (vectores) en R & quot que convergen a a. (a) Demuestre que | x todo. (Sugerencia: consulte el ejercicio 1.2.17.) (b) Demuestre que si be R & quot es cualquier vector, luego b xk b a.

Necesito ayuda para la prueba de la pregunta 2. ¡Muchas gracias!

help_outline

Transcripción de imágenescerrar

EJERCICIOS 2.2 & quot1. ¿Cuál de los siguientes subconjuntos de R & quot está abierto? ¿cerrado? ¿ninguno de los dos? Demuestre su respuesta. (a) (x: 0 x & lt 2> CR (b) (x: x = 2 para algunos k eN o = 0) C R X CR2 y = x (g) y (h) C R & quot (i) x | x 1> C R & quot (G) x || xl1> C R & quot (k) el conjunto de números racionales, QCR Xr (c) X- (d) 1 X- 10 (1I) X: | x 1 o C R2 (e) CR2 (m) Ø (el conjunto vacío) X (f) xy 0 R2 y 2. Sea ser una secuencia de puntos en R & quot. Para i = 1, ... , n, sea xki la coordenada i-ésima del vector x. Demuestre que xk a si y solo si xki ai para todo i = 1,. n 3. Suponga que (x> es una secuencia de puntos (vectores) en R & quot que convergen a a. (a) Demuestre que | x todo. (Sugerencia: consulte el ejercicio 1.2.17.) (b) Demuestre que si be R & quot es cualquier vector, luego b xk b a.


Paquete pyspark¶

Configuración para una aplicación Spark. Se utiliza para establecer varios parámetros de Spark como pares clave-valor.

La mayoría de las veces, crearía un objeto SparkConf con SparkConf (), que también cargará valores de las propiedades del sistema Spark. * Java. En este caso, cualquier parámetro que establezca directamente en el objeto SparkConf tiene prioridad sobre las propiedades del sistema.

Para las pruebas unitarias, también puede llamar a SparkConf (falso) para omitir la carga de configuraciones externas y obtener la misma configuración sin importar cuáles sean las propiedades del sistema.

Todos los métodos de establecimiento de esta clase admiten el encadenamiento. Por ejemplo, puede escribir conf.setMaster ("local"). SetAppName ("Mi aplicación").

Una vez que se pasa un objeto SparkConf a Spark, se clona y el usuario ya no puede modificarlo.

¿Esta configuración contiene una clave determinada?

Obtenga el valor configurado para alguna clave, o devuelva un valor predeterminado de lo contrario.

Obtenga todos los valores como una lista de pares clave-valor.

Establezca una propiedad de configuración.

Establezca varios parámetros, pasados ​​como una lista de pares clave-valor.

Parámetros:pares - lista de pares clave-valor para establecer
setAppName ( valor ) [fuente] ¶

Establezca una variable de entorno para pasarla a los ejecutores.

Establezca una propiedad de configuración, si aún no lo ha hecho.

Establezca la URL maestra a la que conectarse.

Establece la ruta donde Spark está instalado en los nodos trabajadores.

Devuelve una versión imprimible de la configuración, como una lista de pares clave = valor, uno por línea.

clase pyspark. SparkContext ( master = Ninguno, appName = Ninguno, sparkHome = Ninguno, pyFiles = Ninguno, medio ambiente = Ninguno, batchSize = 0, serializador = PickleSerializer (), conf = Ninguno, puerta de enlace = Ninguno, jsc = Ninguno, profiler_cls = & ltclass 'pyspark.profiler.BasicProfiler' & gt ) [fuente] ¶

Punto de entrada principal para la funcionalidad Spark. Un SparkContext representa la conexión a un clúster de Spark y se puede usar para crear RDD y variables de difusión en ese clúster.

PACKAGE_EXTENSIONS = ('.zip', '.egg', '.jar')¶ acumulador ( valor, acum_param = Ninguno ) [fuente] ¶

Cree un acumulador con el valor inicial dado, utilizando un objeto auxiliar AccumulatorParam dado para definir cómo agregar valores del tipo de datos, si se proporciona. Los AccumulatorParams predeterminados se utilizan para números enteros y de punto flotante si no proporciona uno. Para otros tipos, se puede utilizar un AccumulatorParam personalizado.

Agregue un archivo para descargar con este trabajo de Spark en cada nodo. La ruta pasada puede ser un archivo local, un archivo en HDFS (u otros sistemas de archivos compatibles con Hadoop) o un URI HTTP, HTTPS o FTP.

Para acceder al archivo en trabajos de Spark, use L con el nombre del archivo para encontrar su ubicación de descarga.

Se puede proporcionar un directorio si la opción recursiva se establece en True. Actualmente, los directorios solo son compatibles con los sistemas de archivos compatibles con Hadoop.

Agregue una dependencia .py o .zip para todas las tareas que se ejecutarán en este SparkContext en el futuro. La ruta pasada puede ser un archivo local, un archivo en HDFS (u otros sistemas de archivos compatibles con Hadoop) o un URI HTTP, HTTPS o FTP.

Un identificador único para la aplicación Spark. Su formato depende de la implementación del planificador.

  • en el caso de una aplicación Spark local, algo como "local-1433865536131"
  • en el caso de YARN, algo como "application_1433865536131_34483"

Lea un directorio de archivos binarios de HDFS, un sistema de archivos local (disponible en todos los nodos) o cualquier URI del sistema de archivos compatible con Hadoop como una matriz de bytes. Cada archivo se lee como un solo registro y se devuelve en un par clave-valor, donde la clave es la ruta de cada archivo, el valor es el contenido de cada archivo.

Se prefieren archivos pequeños, también se permiten archivos grandes, pero pueden causar un mal rendimiento.

Cargue datos desde un archivo binario plano, asumiendo que cada registro es un conjunto de números con el formato numérico especificado (consulte ByteBuffer) y el número de bytes por registro es constante.

  • sendero - Directorio para los archivos de datos de entrada
  • recordLength - La longitud a la que se van a dividir los registros

Transmita una variable de solo lectura al clúster, devolviendo una L objeto para leerlo en funciones distribuidas. La variable se enviará a cada clúster solo una vez.

Cancele todos los trabajos que se hayan programado o estén en ejecución.

Cancelar trabajos activos para el grupo especificado. Consulte SparkContext.setJobGroup para obtener más información.

Número mínimo predeterminado de particiones para RDD de Hadoop cuando no lo proporciona el usuario

Nivel predeterminado de paralelismo para usar cuando no lo indique el usuario (por ejemplo, para reducir tareas)

Volcar las estadísticas del perfil en la ruta del directorio

Cree un RDD que no tenga particiones ni elementos.

getConf () [fuente] ¶ getLocalProperty ( clave ) [fuente] ¶

Obtenga una propiedad local establecida en este hilo, o nula si falta. Ver setLocalProperty

Obtenga o cree una instancia de SparkContext y regístrelo como un objeto singleton.

Parámetros:conf - SparkConf (opcional)
hadoopFile ( sendero, inputFormatClass, keyClass, valueClass, keyConverter = Ninguno, valueConverter = Ninguno, conf = Ninguno, batchSize = 0 ) [fuente] ¶

Lea un "antiguo" Hadoop InputFormat con clave arbitraria y clase de valor de HDFS, un sistema de archivos local (disponible en todos los nodos) o cualquier URI del sistema de archivos compatible con Hadoop. El mecanismo es el mismo que para sc.sequenceFile.

Una configuración de Hadoop se puede pasar como un dictado de Python. Esto se convertirá en una configuración en Java.

  • sendero - ruta al archivo Hadoop
  • inputFormatClass - nombre de clase completo de Hadoop InputFormat (por ejemplo, "org.apache.hadoop.mapred.TextInputFormat")
  • keyClass - nombre de clase completo de la clave Clase de escritura (por ejemplo, "org.apache.hadoop.io.Text")
  • valueClass - nombre de clase totalmente calificado de valor Clase de escritura (por ejemplo, "org.apache.hadoop.io.LongWritable")
  • keyConverter - (Ninguno por defecto)
  • valueConverter - (Ninguno por defecto)
  • conf - Configuración de Hadoop, pasada como un dictado (Ninguno por defecto)
  • tamaño del lote - El número de objetos Python representados como un solo objeto Java. (predeterminado 0, elija batchSize automáticamente)

Leer un "antiguo" Hadoop InputFormat con clave arbitraria y clase de valor, de una configuración arbitraria de Hadoop, que se pasa como un dictado de Python. Esto se convertirá en una configuración en Java. El mecanismo es el mismo que para sc.sequenceFile.

  • inputFormatClass - nombre de clase completo de Hadoop InputFormat (por ejemplo, "org.apache.hadoop.mapred.TextInputFormat")
  • keyClass - nombre de clase completo de la clave Clase de escritura (por ejemplo, "org.apache.hadoop.io.Text")
  • valueClass - nombre de clase totalmente calificado de valor Clase de escritura (por ejemplo, "org.apache.hadoop.io.LongWritable")
  • keyConverter - (Ninguno por defecto)
  • valueConverter - (Ninguno por defecto)
  • conf - Configuración de Hadoop, pasada como un dictado (Ninguno por defecto)
  • tamaño del lote - El número de objetos Python representados como un solo objeto Java. (predeterminado 0, elija batchSize automáticamente)

Lea una "nueva API" Hadoop InputFormat con clave arbitraria y clase de valor de HDFS, un sistema de archivos local (disponible en todos los nodos) o cualquier URI del sistema de archivos compatible con Hadoop. El mecanismo es el mismo que para sc.sequenceFile.

Una configuración de Hadoop se puede pasar como un dictado de Python. Esto se convertirá en una configuración en Java

  • sendero - ruta al archivo Hadoop
  • inputFormatClass - nombre de clase completo de Hadoop InputFormat (por ejemplo, "org.apache.hadoop.mapreduce.lib.input.TextInputFormat")
  • keyClass - nombre de clase completo de la clave Clase de escritura (por ejemplo, "org.apache.hadoop.io.Text")
  • valueClass - nombre de clase totalmente calificado de valor Clase de escritura (por ejemplo, "org.apache.hadoop.io.LongWritable")
  • keyConverter - (Ninguno por defecto)
  • valueConverter - (Ninguno por defecto)
  • conf - Configuración de Hadoop, pasada como un dictado (Ninguno por defecto)
  • tamaño del lote - El número de objetos Python representados como un solo objeto Java. (predeterminado 0, elija batchSize automáticamente)

Leer una "nueva API" Hadoop InputFormat con clave arbitraria y clase de valor, de una configuración arbitraria de Hadoop, que se pasa como un dictado de Python. Esto se convertirá en una configuración en Java. El mecanismo es el mismo que para sc.sequenceFile.

  • inputFormatClass - nombre de clase completo de Hadoop InputFormat (por ejemplo, "org.apache.hadoop.mapreduce.lib.input.TextInputFormat")
  • keyClass - nombre de clase completo de la clave Clase de escritura (por ejemplo, "org.apache.hadoop.io.Text")
  • valueClass - nombre de clase totalmente calificado de valor Clase de escritura (por ejemplo, "org.apache.hadoop.io.LongWritable")
  • keyConverter - (Ninguno por defecto)
  • valueConverter - (Ninguno por defecto)
  • conf - Configuración de Hadoop, pasada como un dictado (Ninguno por defecto)
  • tamaño del lote - El número de objetos Python representados como un solo objeto Java. (predeterminado 0, elija batchSize automáticamente)

Distribuya una colección de Python local para formar un RDD. Se recomienda utilizar xrange si la entrada representa un rango de rendimiento.

Cargue un RDD previamente guardado usando el método RDD.saveAsPickleFile.

Cree un nuevo RDD de int que contenga elementos de principio a fin (exclusivo), aumentando paso a paso cada elemento. Se puede llamar de la misma forma que la función range () incorporada de Python. Si se llama con un solo argumento, el argumento se interpreta como final y el inicio se establece en 0.

  • comienzo - el valor inicial
  • fin - el valor final (exclusivo)
  • paso - el paso incremental (predeterminado: 1)
  • numSlices - el número de particiones del nuevo RDD

Ejecuta la función de partición dada en el conjunto de particiones especificado, devolviendo el resultado como una matriz de elementos.

Si no se especifica "particiones", se ejecutará en todas las particiones.

Lea un SequenceFile de Hadoop con una clave y un valor arbitrarios Clase de escritura de HDFS, un sistema de archivos local (disponible en todos los nodos) o cualquier URI del sistema de archivos compatible con Hadoop. El mecanismo es el siguiente:

  1. Un RDD de Java se crea a partir de SequenceFile u otro InputFormat, y las clases de clave y valor Writable
  2. La serialización se intenta mediante el decapado con pirolita
  3. Si esto falla, la alternativa es llamar a "toString" en cada clave y el valor se usa para deserializar los objetos en escabeche en el lado de Python
  • sendero - ruta al archivo sequnce
  • keyClass - nombre de clase completo de la clave Clase de escritura (por ejemplo, "org.apache.hadoop.io.Text")
  • valueClass - nombre de clase totalmente calificado de valor Clase de escritura (por ejemplo, "org.apache.hadoop.io.LongWritable")
  • keyConverter
  • valueConverter
  • minSplits - divisiones mínimas en el conjunto de datos (mínimo predeterminado (2, sc.defaultParallelism))
  • tamaño del lote - El número de objetos Python representados como un solo objeto Java. (predeterminado 0, elija batchSize automáticamente)

Establezca el directorio en el que se marcarán los RDD. El directorio debe ser una ruta HDFS si se ejecuta en un clúster.

setJobGroup ( Identificación del grupo, descripción, interruptOnCancel = Falso ) [fuente] ¶

Asigna una ID de grupo a todos los trabajos iniciados por este hilo hasta que la ID de grupo se establezca en un valor diferente o se borre.

A menudo, una unidad de ejecución en una aplicación consta de varias acciones o trabajos de Spark. Los programadores de aplicaciones pueden usar este método para agrupar todos esos trabajos y dar una descripción de grupo. Una vez configurada, la interfaz de usuario web de Spark asociará dichos trabajos con este grupo.

La aplicación puede usar SparkContext.cancelJobGroup para cancelar todos los trabajos en ejecución en este grupo.

Si interruptOnCancel se establece en true para el grupo de trabajos, la cancelación del trabajo dará lugar a que se llame a Thread.interrupt () en los subprocesos ejecutores del trabajo. Esto es útil para ayudar a garantizar que las tareas se detengan realmente de manera oportuna, pero está desactivado de forma predeterminada debido a HDFS-1208, donde HDFS puede responder a Thread.interrupt () marcando los nodos como muertos.

Establezca una propiedad local que afecte a los trabajos enviados desde este hilo, como el grupo de programadores de ferias de Spark.

Controla nuestro logLevel. Esto anula cualquier configuración de registro definida por el usuario. Los niveles de registro válidos incluyen: ALL, DEBUG, ERROR, FATAL, INFO, OFF, TRACE, WARN

Establezca una propiedad del sistema Java, como spark.executor.memory. Esto debe invocarse antes de crear una instancia de SparkContext.

Imprima las estadísticas del perfil en stdout

Obtenga SPARK_USER para el usuario que ejecuta SparkContext.

Devuelve la época en la que se inició Spark Context.

Cierre SparkContext.

Archivo de texto ( nombre, minPartitions = Ninguno, use_unicode = Verdadero ) [fuente] ¶

Lea un archivo de texto de HDFS, un sistema de archivos local (disponible en todos los nodos) o cualquier URI del sistema de archivos compatible con Hadoop y devuélvalo como un RDD de cadenas.

Si use_unicode es False, las cadenas se mantendrán como str (codificadas como utf-8), que es más rápido y más pequeño que unicode. (Agregado en Spark 1.2)

Devuelve la URL de la instancia de SparkUI iniciada por este SparkContext

Cree la unión de una lista de RDD.

Esto admite uniones () de RDD con diferentes formatos serializados, aunque esto obliga a reservarlos utilizando el serializador predeterminado:

La versión de Spark en la que se ejecuta esta aplicación.

WholeTextFiles ( sendero, minPartitions = Ninguno, use_unicode = Verdadero ) [fuente] ¶

Lea un directorio de archivos de texto de HDFS, un sistema de archivos local (disponible en todos los nodos) o cualquier URI del sistema de archivos compatible con Hadoop. Cada archivo se lee como un solo registro y se devuelve en un par clave-valor, donde la clave es la ruta de cada archivo, el valor es el contenido de cada archivo.

Si use_unicode es False, las cadenas se mantendrán como str (codificadas como utf-8), que es más rápido y más pequeño que unicode. (Agregado en Spark 1.2)

Por ejemplo, si tiene los siguientes archivos:

Haga rdd = sparkContext.wholeTextFiles ("hdfs: // a-hdfs-path"), luego rdd contiene:

Se prefieren los archivos pequeños, ya que cada archivo se cargará completamente en la memoria.

SparkFiles contiene solo métodos de clase que los usuarios no deben crear instancias de SparkFiles.

Obtenga la ruta absoluta de un archivo agregado a través de SparkContext.addFile ().

Obtenga el directorio raíz que contiene los archivos agregados a través de SparkContext.addFile ().

clase pyspark. RDD ( jrdd, ctx, jrdd_deserializer = AutoBatchedSerializer (PickleSerializer ()) ) [fuente] ¶

Un conjunto de datos distribuido resistente (RDD), la abstracción básica en Spark. Representa una colección inmutable y particionada de elementos que se pueden operar en paralelo.

Agregue los elementos de cada partición, y luego los resultados para todas las particiones, usando una función combinada dada y un "valor cero" neutral.

Las funciones op (t1, t2) pueden modificar t1 y devolverlo como su valor de resultado para evitar la asignación de objetos, sin embargo, no debe modificar t2.

La primera función (seqOp) puede devolver un tipo de resultado diferente, U, que el tipo de este RDD. Por lo tanto, necesitamos una operación para fusionar una T en una U y una operación para fusionar dos U

Agregue los valores de cada clave, usando funciones combinadas dadas y un “valor cero” neutral. Esta función puede devolver un tipo de resultado diferente, U, que el tipo de los valores en este RDD, V. Por lo tanto, necesitamos una operación para fusionar una V en una U y una operación para fusionar dos U's. La operación anterior se usa para fusionar valores dentro de una partición, y esta última se utiliza para fusionar valores entre particiones. Para evitar la asignación de memoria, ambas funciones pueden modificar y devolver su primer argumento en lugar de crear una nueva U.

Conserve este RDD con el nivel de almacenamiento predeterminado (MEMORY_ONLY).

Devuelve el producto cartesiano de este RDD y otro, es decir, el RDD de todos los pares de elementos (a, b) donde a está en uno mismo y b está en otro.

Marque este RDD para puntos de control. Se guardará en un archivo dentro del directorio de punto de control establecido con SparkContext.setCheckpointDir () y se eliminarán todas las referencias a sus RDD principales. Se debe llamar a esta función antes de que se haya ejecutado cualquier trabajo en este RDD. Se recomienda encarecidamente que este RDD permanezca en la memoria; de lo contrario, guardarlo en un archivo requerirá un nuevo cálculo.

fusionarse numPartitions, shuffle = Falso ) [fuente] ¶

Devuelve un nuevo RDD que se reduce a numPartitions particiones.

Para cada clave k en self u other, devuelve un RDD resultante que contiene una tupla con la lista de valores para esa clave en self y other.

Devuelve una lista que contiene todos los elementos de este RDD.

Este método solo debe usarse si se espera que la matriz resultante sea pequeña, ya que todos los datos se cargan en la memoria del controlador.

Devuelve los pares clave-valor en este RDD al maestro como un diccionario.

este método solo debe usarse si se espera que los datos resultantes sean pequeños, ya que todos los datos se cargan en la memoria del controlador.

Función genérica para combinar los elementos de cada tecla mediante un conjunto personalizado de funciones de agregación.

Convierte un RDD [(K, V)] en un resultado de tipo RDD [(K, C)], para un "tipo combinado" C.

Los usuarios proporcionan tres funciones:

  • createCombiner, que convierte una V en una C (por ejemplo, crea una lista de un elemento)
  • mergeValue, para fusionar una V en una C (por ejemplo, la agrega al final de una lista)
  • mergeCombiners, para combinar dos C en una sola (por ejemplo, fusiona las listas)

Para evitar la asignación de memoria, tanto mergeValue como mergeCombiners pueden modificar y devolver su primer argumento en lugar de crear una nueva C.

Además, los usuarios pueden controlar la partición del RDD de salida.

V y C pueden ser diferentes; por ejemplo, se puede agrupar un RDD de tipo (Int, Int) en un RDD de tipo (Int, List [Int]).

SparkContext en el que se creó este RDD.

Devuelve el número de elementos de este RDD.

Versión aproximada de count () que devuelve un resultado potencialmente incompleto dentro de un tiempo de espera, incluso si no todas las tareas han finalizado.

Devuelve el número aproximado de elementos distintos en el RDD.

Parámetros:relativoSD - Precisión relativa. Los valores más pequeños crean contadores que requieren más espacio. Debe ser superior a 0,000017.

Cuente el número de elementos para cada clave y devuelva el resultado al maestro como un diccionario.

Devuelve el recuento de cada valor único en este RDD como un diccionario de pares (valor, recuento).

Devuelve un nuevo RDD que contiene los elementos distintos en este RDD.

Devuelve un nuevo RDD que contiene solo los elementos que satisfacen un predicado.

Devuelve el primer elemento de este RDD.

Devuelve un nuevo RDD aplicando primero una función a todos los elementos de este RDD y luego compactando los resultados.

Pase cada valor en el RDD del par clave-valor a través de una función flatMap sin cambiar las claves, esto también conserva la partición del RDD original.

Agregue los elementos de cada partición y luego los resultados de todas las particiones, usando una función asociativa dada y un "valor cero" neutral.

La función op (t1, t2) puede modificar t1 y devolverlo como su valor de resultado para evitar la asignación de objetos; sin embargo, no debe modificar t2.

Esto se comporta de forma algo diferente a las operaciones de plegado implementadas para colecciones no distribuidas en lenguajes funcionales como Scala. Esta operación de plegado se puede aplicar a particiones individualmente y luego plegar esos resultados en el resultado final, en lugar de aplicar el plegado a cada elemento secuencialmente en algún orden definido. Para las funciones que no son conmutativas, el resultado puede diferir del de un pliegue aplicado a una colección no distribuida.

Fusionar los valores para cada tecla usando una función asociativa "func" y un "zeroValue" neutral que se puede agregar al resultado un número arbitrario de veces, y no debe cambiar el resultado (por ejemplo, 0 para la suma o 1 para la multiplicación. ).

Aplica una función a todos los elementos de este RDD.

Aplica una función a cada partición de este RDD.

Realiza una unión externa correcta entre el yo y el otro.

Para cada elemento (k, v) en self, el RDD resultante contendrá todos los pares (k, (v, w)) para w en otro, o el par (k, (v, None)) si no hay elementos en otro tener llave k.

De manera similar, para cada elemento (k, w) en otro, el RDD resultante contendrá todos los pares (k, (v, w)) para v en sí mismo, o el par (k, (Ninguno, w)) si no hay elementos en uno mismo tiene clave k.

Hash-particiona el RDD resultante en el número dado de particiones.

Obtiene el nombre del archivo al que se le asignó este RDD.

No se define si RDD está controlado localmente.

Devuelve el número de particiones en RDD.

Obtén el nivel de almacenamiento actual del RDD.

Devuelve un RDD creado al fusionar todos los elementos dentro de cada partición en una lista.

Devuelve un RDD de elementos agrupados.

Agrupe los valores de cada clave en el RDD en una sola secuencia. Hash-particiona el RDD resultante con particiones numPartitions.

Si está agrupando para realizar una agregación (como una suma o un promedio) sobre cada clave, el uso de reduceByKey o aggregateByKey proporcionará un rendimiento mucho mejor.

Alias ​​para cogroup pero con soporte para múltiples RDD.

Calcule un histograma utilizando los depósitos proporcionados. Los cubos están todos abiertos a la derecha excepto el último que está cerrado. p.ej. [1,10,20,50] significa que los depósitos son [1,10) [10,20) [20,50], lo que significa 1 & lt = x & lt10, 10 & lt = x & lt20, 20 & lt = x & lt = 50. Y en la entrada de 1 y 50 tendríamos un histograma de 1,0,1.

Si su histograma está espaciado uniformemente (por ejemplo, [0, 10, 20, 30]), esto se puede cambiar de una inserción O (log n) a O (1) por elemento (donde n es el número de cubos).

Los depósitos deben estar ordenados, no contener duplicados y tener al menos dos elementos.

Si cubos es un número, generará cubos que están espaciados uniformemente entre el mínimo y el máximo del RDD. Por ejemplo, si el valor mínimo es 0 y el máximo es 100, dados los depósitos como 2, los depósitos resultantes serán [0,50) [50,100]. los depósitos deben ser al menos 1. Se genera una excepción si el RDD contiene infinito. Si los elementos del RDD no varían (máx. == mín.), Se utilizará un solo depósito.

El valor de retorno es una tupla de depósitos e histograma.

Un ID único para este RDD (dentro de su SparkContext).

Devuelve la intersección de este RDD y otro. La salida no contendrá ningún elemento duplicado, incluso si los RDD de entrada lo hicieran.

Este método realiza una reproducción aleatoria internamente.

Devuelve si este RDD está controlado y materializado, ya sea de manera confiable o local.

Devuelve verdadero si y solo si el RDD no contiene ningún elemento.

un RDD puede estar vacío incluso cuando tiene al menos 1 partición.

Devuelve si este RDD está marcado para puntos de control locales.

Devuelve un RDD que contiene todos los pares de elementos con claves coincidentes en self y other.

Cada par de elementos se devolverá como una tupla (k, (v1, v2)), donde (k, v1) está en self y (k, v2) en other.

Realiza una combinación de hash en todo el clúster.

Crea tuplas de los elementos en este RDD aplicando f.

Devuelve un RDD con las claves de cada tupla.

Realice una unión exterior izquierda de uno mismo y el otro.

Para cada elemento (k, v) en self, el RDD resultante contendrá todos los pares (k, (v, w)) para w en otro, o el par (k, (v, None)) si no hay elementos en otro tener llave k.

Hash-particiona el RDD resultante en el número dado de particiones.

Marque este RDD para puntos de control locales utilizando la capa de almacenamiento en caché existente de Spark.

Este método es para usuarios que desean truncar linajes RDD mientras se saltan el costoso paso de replicar los datos materializados en un sistema de archivos distribuido confiable. Esto es útil para RDD con linajes largos que deben truncarse periódicamente (por ejemplo, GraphX).

Los puntos de control locales sacrifican la tolerancia a fallos por el rendimiento. En particular, los datos con puntos de control se escriben en un almacenamiento local efímero en los ejecutores en lugar de en un almacenamiento confiable y tolerante a fallas. El efecto es que si un ejecutor falla durante el cálculo, es posible que los datos con puntos de control ya no sean accesibles, lo que provocaría una falla irrecuperable del trabajo.

Esto NO es seguro de usar con la asignación dinámica, que elimina los ejecutores junto con sus bloques en caché. Si debe utilizar ambas funciones, se recomienda establecer spark.dynamicAllocation.cachedExecutorIdleTimeout en un valor alto.

El directorio de punto de control establecido a través de SparkContext.setCheckpointDir () no se usa.

Devuelve la lista de valores en el RDD para la clave clave. Esta operación se realiza de manera eficiente si el RDD tiene un particionador conocido al buscar solo la partición a la que se asigna la clave.

Devuelve un nuevo RDD aplicando una función a cada elemento de este RDD.

Devuelve un nuevo RDD aplicando una función a cada partición de este RDD.

Devuelve un nuevo RDD aplicando una función a cada partición de este RDD, mientras rastrea el índice de la partición original.

En desuso: use mapPartitionsWithIndex en su lugar.

Devuelve un nuevo RDD aplicando una función a cada partición de este RDD, mientras rastrea el índice de la partición original.

Pase cada valor en el RDD del par clave-valor a través de una función de mapa sin cambiar las claves, esto también conserva la partición del RDD original.

Encuentre el artículo máximo en este RDD.

Parámetros:clave - Una función utilizada para generar una clave para comparar

Calcule la media de los elementos de este RDD.

Operación aproximada para devolver la media dentro de un tiempo de espera o cumplir con la confianza.

Encuentre el artículo mínimo en este RDD.

Parámetros:clave - Una función utilizada para generar una clave para comparar

Devuelve el nombre de este RDD.

partición por ( numPartitions, partitionFunc = & ltfunction portable_hash & gt ) [fuente] ¶

Devuelve una copia del RDD particionado usando el particionador especificado.

Configure el nivel de almacenamiento de este RDD para conservar sus valores en todas las operaciones después de la primera vez que se calcula. Esto solo se puede usar para asignar un nuevo nivel de almacenamiento si el RDD aún no tiene un nivel de almacenamiento establecido. Si no se especifica ningún nivel de almacenamiento, el valor predeterminado es (MEMORY_ONLY).

Devuelve un RDD creado por elementos de tubería a un proceso externo bifurcado.

Parámetros:Código de verificación - si comprobar o no el valor de retorno del comando de shell.
randomSplit ( pesos, seed = Ninguno ) [fuente] ¶

Divide aleatoriamente este RDD con los pesos proporcionados.

  • pesos - los pesos de las divisiones se normalizarán si no suman 1
  • semilla - Semilla aleatoria

Reduce los elementos de este RDD utilizando el operador binario conmutativo y asociativo especificado. Actualmente reduce las particiones a nivel local.

Fusionar los valores de cada clave mediante una función de reducción asociativa y conmutativa.

Esto también realizará la fusión localmente en cada mapeador antes de enviar los resultados a un reductor, de manera similar a un "combinador" en MapReduce.

La salida se particionará con particiones numPartitions, o el nivel de paralelismo predeterminado si no se especifica numPartitions. El particionador predeterminado es la partición hash.

Combine los valores para cada clave usando una función de reducción asociativa y conmutativa, pero devuelva los resultados inmediatamente al maestro como un diccionario.

Esto también realizará la fusión localmente en cada mapeador antes de enviar los resultados a un reductor, de manera similar a un "combinador" en MapReduce.

Devuelve un nuevo RDD que tiene exactamente numPartitions particiones.

Puede aumentar o disminuir el nivel de paralelismo en este RDD. Internamente, esto usa una mezcla para redistribuir los datos. Si está disminuyendo el número de particiones en este RDD, considere usar la fusión, que puede evitar realizar una reproducción aleatoria.

Vuelva a particionar el RDD de acuerdo con el particionador dado y, dentro de cada partición resultante, clasifique los registros por sus claves.

Realiza una unión externa correcta entre el yo y el otro.

Para cada elemento (k, w) en otro, el RDD resultante contendrá todos los pares (k, (v, w)) para v en este, o el par (k, (Ninguno, w)) si no hay elementos en uno mismo. tener llave k.

Hash-particiona el RDD resultante en el número dado de particiones.

Devuelve un subconjunto muestreado de este RDD.

  • con Reemplazo - ¿Se pueden muestrear elementos varias veces (reemplazados cuando se muestrean)?
  • fracción - tamaño esperado de la muestra como una fracción del tamaño de este RDD sin reemplazo: probabilidad de que cada elemento sea elegido fracción debe ser [0, 1] con reemplazo: número esperado de veces que cada elemento es elegido fracción debe ser & gt = 0
  • semilla - semilla para el generador de números aleatorios

No se garantiza que esto proporcione exactamente la fracción especificada del recuento total del DataFrame dado.

Devuelve un subconjunto de este RDD muestreado por clave (mediante muestreo estratificado). Cree una muestra de este RDD utilizando tasas de muestreo variables para diferentes claves según lo especificado por fracciones, una clave para el mapa de tasas de muestreo.

Calcule la desviación estándar de la muestra de los elementos de este RDD (que corrige el sesgo al estimar la desviación estándar dividiendo por N-1 en lugar de N).

Calcule la varianza muestral de los elementos de este RDD (que corrige el sesgo al estimar la varianza dividiendo por N-1 en lugar de N).


Descargas

  1. Incluye los tiempos de ejecución de .NET Core y ASP.NET Core
  2. Para alojar aplicaciones independientes en servidores Windows. Incluye el módulo ASP.NET Core para IIS y se puede instalar por separado en servidores sin instalar el tiempo de ejecución de .NET Core.

Imágenes de Docker

Las imágenes de .NET Core Docker se han actualizado para esta versión. Los detalles sobre nuestro control de versiones de Docker y cómo trabajar con las imágenes se pueden ver en "Cómo mantenerse actualizado con las imágenes del contenedor .NET".

Se han actualizado los siguientes repositorios

Servicios de aplicaciones de Azure

  • .NET Core 2.2.1 se está implementando en Azure App Services y se espera que la implementación se complete en un par de días.

2.2 Vinculación y celosías

Como acabamos de ver, un átomo busca tener una capa exterior completa (es decir, ocho electrones para la mayoría de los elementos, o dos electrones para el hidrógeno y el helio) para ser atómicamente estable. Esto se logra transfiriendo o compartiendo electrones con otros átomos.

Figura 2.2.1 Una configuración electrónica muy simplificada de átomos de sodio y cloro (arriba). El sodio cede un electrón para convertirse en catión (abajo a la izquierda) y el cloro acepta un electrón para convertirse en anión (abajo a la derecha). [Descripción de la imagen]

El sodio tiene 11 electrones: dos en la primera capa, ocho en la segunda y uno en la tercera (Figura 2.2.1). El sodio cede fácilmente ese único electrón de la tercera capa, y cuando pierde esta única carga negativa, se carga positivamente (porque ahora tiene 11 protones y solo 10 electrones). Al ceder su único electrón de la tercera capa, el sodio termina con una capa externa completa. El cloro, por otro lado, tiene 17 electrones: dos en la primera capa, ocho en la segunda y siete en la tercera. El cloro acepta fácilmente un octavo electrón para llenar su tercera capa y, por lo tanto, se carga negativamente porque tiene 17 protones y 18 electrones. Al cambiar su número de electrones, estos átomos se vuelven iones —El sodio pierde un electrón para convertirse en un ión positivo o catión , y el cloro gana un electrón para convertirse en un ion negativo o anión (Figura 2.2.1).

Dado que las cargas negativas y positivas se atraen, los iones de sodio y cloro pueden unirse, creando una enlace iónico . Se puede pensar que los electrones son transferido de un átomo a otro en un enlace iónico. La sal de mesa común (NaCl) es un mineral compuesto de cloro y sodio unidos por enlaces iónicos (Figura 1.4.1). El nombre mineral del NaCl es halita.

Un elemento como el cloro también puede formar enlaces sin formar iones. Por ejemplo, dos átomos de cloro, cada uno de los cuales busca un octavo electrón en su capa exterior, pueden compartir un electrón en lo que se conoce como enlace covalente para formar cloro gaseoso (Cl2) (Figura 2.2.2). Los electrones son compartido en un enlace covalente.

Figura 2.2.2 Representación de un enlace covalente entre dos átomos de cloro. Los electrones son negros en el átomo izquierdo y azules en el derecho. Se comparten dos electrones (uno negro y otro azul) de modo que cada átomo "parece" tener una capa exterior completa.

Ejercicio 2.1 Cationes, aniones y enlaces iónicos

A continuación se enumeran varios elementos junto con sus números atómicos. Suponiendo que la primera capa de electrones puede contener dos electrones y las capas de electrones subsiguientes pueden contener ocho electrones, dibuje las configuraciones de electrones para estos elementos. Predecir si es probable que el elemento forme un catión (+) o un anión (-) cuando tiene lugar la transferencia de electrones, y qué carga tendría (p. Ej., +1, +2, −1).

El primero de ellos está hecho para ti. El flúor necesitaba un electrón extra para tener 8 en su capa más externa, y al obtener ese electrón, se cargó negativamente.

Un átomo de carbono tiene seis protones y seis electrones, dos de los electrones están en la capa interna y cuatro en la externa (Figura 2.2.3). El carbono necesitaría ganar o perder cuatro electrones para tener una capa exterior llena, y esto crearía un desequilibrio de carga demasiado grande para que el ion sea estable. Por otro lado, el carbono puede compartir electrones para crear enlaces covalentes. En el diamante mineral, los átomos de carbono están unidos en un marco tridimensional, donde cada átomo de carbono está unido a otros cuatro átomos de carbono y cada enlace es un enlace covalente muy fuerte. En el mineral grafito, los átomos de carbono están unidos en láminas o capas (Figura 2.2.3), y cada átomo de carbono está unido covalentemente a otros tres. Los compuestos a base de grafito, que son fuertes debido a la fuerte unión covalente entre capas, se utilizan en equipos deportivos de alta gama, como bicicletas de carreras ultraligeras. El grafito en sí es suave porque la unión entre estas capas es relativamente débil y se usa en una variedad de aplicaciones, incluidos lubricantes y lápices.

Figura 2.2.3 La configuración electrónica del carbono (izquierda) y el intercambio de electrones en el enlace covalente del diamante (derecha). Los electrones que se muestran en azul se comparten entre átomos de carbono adyacentes. Aunque se muestra aquí solo en dos dimensiones, el diamante tiene una estructura tridimensional como se muestra en la Figura 2.2.5. [Descripción de la imagen]

El silicio y el oxígeno se unen para crear un tetraedro de sílice , que es una forma de pirámide de cuatro lados con O en cada esquina y Si en el medio (Figura 2.2.4). Esta estructura es el componente básico de los minerales de silicato (que se describen en la Sección 2.4). Los enlaces en un tetraedro de sílice tienen algunas de las propiedades de los enlaces covalentes y algunas de las propiedades de los enlaces iónicos. Como resultado del carácter iónico, el silicio se convierte en un catión (con una carga de +4) y el oxígeno se convierte en un anión (con una carga de –2). La carga neta de un tetraedro de sílice (SiO4) es: 4 + 4 (−2) = 4-8 = −4. Como veremos más adelante, los tetraedros de sílice (plural de tetraedro) se unen de diversas formas para formar la mayoría de los minerales comunes de la corteza.

Figura 2.2.4 El tetraedro de sílice, el componente básico de todos los minerales de silicato. (Debido a que el ion de silicio tiene una carga de +4 y los cuatro iones de oxígeno tienen cada uno una carga de -2, el tetraedro de sílice tiene una carga neta de -4).

La mayoría de los minerales se caracterizan por enlaces iónicos, enlaces covalentes o una combinación de los dos, pero hay otros tipos de enlaces que son importantes en los minerales, incluidos los enlaces metálicos y las fuerzas electrostáticas más débiles (hidrógeno o enlaces de Van der Waals). Los elementos metálicos tienen electrones externos que se mantienen relativamente sueltos. (Los metales están resaltados en la tabla periódica en el Apéndice 1.) Cuando se forman enlaces entre tales átomos, estos electrones pueden moverse libremente de un átomo a otro. Por tanto, se puede pensar en un metal como una serie de núcleos atómicos cargados positivamente sumergidos en un mar de electrones móviles. Esta característica explica dos propiedades muy importantes de los metales: su conductividad eléctrica y su maleabilidad (pueden deformarse y moldearse).

Las moléculas que están unidas iónica o covalentemente también pueden tener otras fuerzas electrostáticas más débiles que las mantienen juntas. Ejemplos de esto son la fuerza que mantiene juntas las láminas de grafito y la atracción entre las moléculas de agua.

¿Qué & # 8217s con todos estos & # 8220sili & # 8221 nombres?

El elemento silicio es uno de los elementos geológicos más importantes y es el segundo elemento más abundante en la corteza terrestre (después del oxígeno). El silicio se une fácilmente al oxígeno para formar una sílice tetraedro (Figura 2.2.4). Los cristales de silicio puro (creados en un laboratorio) se utilizan para fabricar medios semiconductores para dispositivos electrónicos. A silicato El mineral es aquel en el que el silicio y el oxígeno están presentes como tetraedros de sílice. La sílice también se refiere a un componente químico de una roca y se expresa como% SiO.2. El cuarzo mineral está compuesto completamente de tetraedros de sílice, y algunas formas de cuarzo también se conocen como & # 8220silica & # 8221. Silicona es un producto sintético (por ejemplo, caucho de silicona, resina o calafateo) elaborado a partir de cadenas de silicio-oxígeno y varias moléculas orgánicas. Para ayudarlo a mantener los nombres "sili" correctos, aquí hay una tabla de resumen:

Tabla 2.3 Resumen de los nombres de & # 8220Sili & # 8221
& # 8220Sili & # 8221 nombre Definición
Silicio El decimocuarto elemento
Oblea de silicio Un cristal de silicio puro cortado en rodajas muy finas y utilizado para electrónica.
Tetraedro de sílice Una combinación de un átomo de silicio y cuatro átomos de oxígeno que forman un tetraedro.
% de sílice La proporción de una roca que se compone del componente SiO2
Sílice Un sólido hecho de SiO2 (pero no necesariamente un mineral & # 8211 por ejemplo, ópalo)
Silicato Un mineral que contiene tetraedros de sílice (por ejemplo, cuarzo, feldespato, mica, olivino)
Silicona Un material sintético flexible formado por cadenas de Si – O con moléculas orgánicas adheridas.

Los elementos que tienen una capa exterior completa se describen como inerte porque no tienden a reaccionar con otros elementos para formar compuestos. Eso es porque no necesitan perder ni ganar electrones para estabilizarse, por lo que no se convierten en iones. Todos aparecen en la columna de la extrema derecha de la tabla periódica. Algunos ejemplos son: helio, neón, argón, etc.

Como se describe en el Capítulo 1, todos los minerales se caracterizan por un patrón tridimensional específico conocido como estructura reticular o cristalina. Estas estructuras van desde el patrón cúbico simple de halita (NaCl) (Figura 1.4.1), hasta los patrones muy complejos de algunos minerales de silicato. Dos minerales pueden tener la misma composición, pero estructuras y propiedades cristalinas muy diferentes. El grafito y el diamante, por ejemplo, están compuestos solo de carbono, pero mientras que el diamante es la sustancia más dura que se conoce, el grafito es más suave que el papel. Sus estructuras de celosía se comparan en la Figura 2.2.5.

Figura 2.2.5 Representación de las celosías de grafito y diamante.

Las celosías minerales tienen implicaciones importantes para las propiedades minerales, como lo demuestra la dureza del diamante y la suavidad del grafito. Las celosías también determinan la forma en la que crecen los cristales minerales y cómo se rompen. Por ejemplo, los ángulos rectos en la red del mineral halita (Figura 1.4.1) influyen tanto en la forma de sus cristales (cúbicos) como en la forma en que se rompen (Figura 2.2.6).

Figura 2.2.6 Cristales cúbicos (izquierda) y planos de división en ángulo recto (derecha) del mineral halita. Si observa de cerca el fragmento de hendidura a la derecha, puede ver dónde se rompería nuevamente (se partirá) a lo largo de un plano paralelo a una superficie existente. En la mayoría de los minerales, los planos de escisión no se alinean con las superficies de los cristales.

Descripciones de imágenes

Figura 2.2.1 descripción de la imagen: El sodio tiene un electrón en su capa exterior y el cloro tiene 7 electrones en su capa exterior. Sodio & # 8217s un electrón externo va al cloro, lo que hace que el cloro sea ligeramente negativo y el sodio ligeramente positivo. Se atraen y juntos forman Cloruro de Sodio. [Volver a la figura 2.2.1]

Figura 2.2.3 descripción de la imagen: (Izquierda) Un átomo de carbono tiene dos electrones en su capa interna y cuatro electrones en su capa externa. (Derecha) Un átomo de carbono comparte electrones con otros cuatro átomos de carbono para formar una capa exterior completa. [Volver a la figura 2.2.3]


Soluciones a los ejercicios del capítulo 2

Exactamente uno es cierto si (a es cierto, y B es falso) o (a es falso, y B es verdad). Entonces, una forma de definirlo es aBa ∧¬B ∨¬aB. Las dos mitades de esa fórmula también corresponden a las dos filas verdaderas de la tabla de verdad de xor:

Solución al ejercicio 2.1.1.5

Solución al ejercicio 2.1.2.1

Solución al ejercicio 2.1.2.2

Solución al ejercicio 2.1.2.3

Insatisfactorio, a menos que, por supuesto, interprete "nadie" como "nadie destacado".

Solución al ejercicio 2.1.2.4

Ninguno de los dos. Si interpreta "llega tarde" como un problema social, pero "temprano" como un problema de reloj, entonces la afirmación podría ser cierta, dependiendo de dónde esté "aquí".

Solución al ejercicio 2.1.2.5

Insatisfactorio, excepto quizás en un sentido kármico.

Solución al ejercicio 2.2.1.1

Tabla 2.28 Tabla de verdad para comprobar la asociatividad de la implicación

Al inspeccionar las dos columnas más a la derecha, vemos que las fórmulas no son equivalentes. Tienen valores diferentes para dos escenarios de verdad, aquellos con a = falso y C = falso.

Solución al ejercicio 2.2.1.2

En el código original, devolvemos value2 cuando el primer caso es falso, pero el segundo caso es verdadero. Usando un WFF, cuando ¬ (aB) ∧ (aB). ¿Es esto equivalente al WFF? a ∧¬B ∨¬aB? Aquí hay una tabla de verdad:

Sí, mirando las dos columnas apropiadas vemos que son equivalentes.

Solución al ejercicio 2.2.2.1

  • 2 variables: Como hemos visto, 4 filas.
  • 3 variables: 8 filas.
  • 5 variables: 32 filas.
  • 10 variables: 1024 filas.
  • norte variables: 2 n filas.

Solución al ejercicio 2.2.2.2

  • Con 2 variables, tenemos 4 filas. ¿De cuántas formas diferentes podemos asignar verdadero y falso a esas 4 posiciones? Si las escribe todas, debería obtener 16 combinaciones.
  • Con 3 variables, tenemos 8 filas y un total de 256 funciones diferentes.
  • Con n variables, tenemos 2 n filas y un total de 2 2n funciones diferentes. Eso es mucho

Solución al ejercicio 2.3.1.1

Solución al ejercicio 2.3.1.2

Solución al ejercicio 2.3.2.1

Aparte: los mapas de Karnaugh 38 son una técnica general para encontrar fórmulas mínimas de CNF y DNF.

Se utilizan con mayor facilidad cuando sólo se trata de una pequeña cantidad de variables. Sin embargo, no nos preocuparemos por minimizar las fórmulas.

Solución al ejercicio 2.3.3.1

De hecho, podemos reducir la cuestión de la tautología a la cuestión de la equivalencia: si alguien le pregunta si φ es cierto, puedes simplemente darte la vuelta y preguntarle a tu amigo si las siguientes dos fórmulas son equivalentes: φ, y verdadero. La respuesta de su amigo a esta pregunta variante será su respuesta a la pregunta de su cliente sobre φ. Por lo tanto, el problema de la tautología no es particularmente más difícil que el problema de la equivalencia.

Pero también, la equivalencia se puede reducir a tautología: si alguien te pregunta si φ es equivalente a ψ, puedes construir una nueva fórmula (φψ) ∧ (ψφ). Esta fórmula es verdadera exactamente cuando φ y ψ son equivalentes. Entonces, le pregunta a su amigo si esta fórmula más grande es una tautología, y luego tiene su respuesta sobre si las dos fórmulas originales eran equivalentes. Por lo tanto, el problema de la equivalencia no es particularmente más difícil que el problema de la tautología.

Dados estos dos hechos (que cada problema se reduce al otro), nos damos cuenta de que en realidad son esencialmente el mismo problema, disfrazado.

Solución a Ejercicio 2.3.3.2

Compare las dos últimas columnas a continuación:

Solución al ejercicio 2.4.1.1

Intuitivamente, esto es sencillo. Ya que A posee 2, luego sus dos vecinos, incluidos B, debe ser inseguro. Para este problema, seamos un poco más formales y usemos WFF en lugar de prosa en los pasos.

A - tiene - 2 ⇒ B - inseguro ∧ F - inseguro

Axioma del dominio WaterWorld, es decir, definición de A - tiene - 2

Solución al ejercicio 2.4.1.2

De nuevo una idea similar, si A posee 1, entonces al menos uno de ALos dos vecinos deben ser inseguros. Pero, como sabemos que uno de estos, GRAMO no es inseguro, luego el otro, B, debe ser inseguro.

A - tiene - 1 ⇒ B - seguro ∧ G - inseguro ∨ B - inseguro ∧ G - seguro

B - seguro ∧ G - inseguro ∨ B - inseguro ∧ G - seguro

Solución al ejercicio 2.4.1.3

Aquí, mostraremos solo χ ∧ υ ∧ ω f χ ∧ υ ∧ ω y dejaremos la otra dirección (y la asociatividad de ∨) al lector. Todos estos son muy similares al ejemplo de conmutatividad anterior (Ejemplo 2.14).

Tenga en cuenta que omitimos la explicación detallada de cómo se aplica cada regla, ya que esto debe quedar claro en cada uno de estos pasos.

Solución al ejercicio 2.4.1.4

Primero, si sabemos, entonces eso significa que hay alguna prueba escrita. lo sabemos, simplemente por

Si sabemos f φψ, entonces si agregamos una premisa φ, luego ψ sigue ⇒Elim. Observe cómo esta prueba se trata de otras pruebas. (Sin embargo, mientras razonamos sobre este sistema de inferencia en particular, no estamos usando este sistema mientras probamos cosas al respecto, esta prueba está necesariamente fuera del sistema de inferencia.

Solución al ejercicio 2.4.2.1

Solution al ejercicio 2.4.3.1

Sería sólido: mire todas las posibles pruebas que se pueden hacer en el sistema original, todas esas pruebas llevan a conclusiones verdaderas (ya que ese sistema original es sólido, como afirmamos). Si descartamos todas las que incluyen RAA, las pruebas restantes siguen siendo todas verdaderas, por lo que el sistema más pequeño es sólido.

Sin embargo, no estaría completo: como se señaló, RAA es nuestra única forma de probar negaciones sin premisas. Hay fórmulas negadas que son verdaderas (y no tienen premisas), por ejemplo, falsas. Sin RAA, no podemos proporcionar una prueba de falso, por lo que el sistema más pequeño está incompleto.

Solución al ejercicio 2.5.1

Muchos contraejemplos posibles. "Es malo estar deprimido. Hacer la tarea me deprime, así que es bueno no hacer la tarea". O, "Es malo que la gente tenga dolor físico. El parto causa dolor. Por lo tanto, todas las personas deben evitar el parto. "Si la conclusión original es realmente correcta, Tracy necesita dilucidar algunas de sus suposiciones tácitas.

El faw parece estar en la línea de "evitar lo malo a corto plazo puede no siempre ser bueno a largo plazo" (o lo que es lo mismo, a veces tienes que elegir el menor de dos males). No, no se le pidió que nombrara un faw específico, y las personas razonables pueden diferir en qué es precisamente el faw. (Y la lógica formal no es particularmente útil aquí). No obstante, descubrir supuestos ocultos en los argumentos a menudo ayuda a comprender los problemas reales involucrados.

A UN LADO: Para divertirse, lea la portada del periódico diario y vea cuántos argumentos usan reglas de inferencia defectuosas y la mayoría se basan en premisas tácitas (con las que no todos pueden estar de acuerdo). En particular, las cuestiones políticas que llegan a la prensa principal a menudo están plagadas de errores, aunque por lo general hay argumentos razonables en ambos lados que los legisladores y los tribunales debaten.

Solución al ejercicio 2.5.2

"Terry afirma que fomentar los derechos humanos es más importante que jugar al Tetris. Pero Terry jugó al Tetris ayer en lugar de ser voluntario de Amnistía Internacional 39". La mayoría de la gente no condenaría a Terry como un hipócrita solo por esto, incluso las personas más dedicadas con derecho a algunos tiempo libre. Si su amigo quiere demostrar que Terry es hipócrita, tendrá que proporcionar más pruebas o argumentos.

O de manera similar, "Político X reclama para apoyar la financiación de la ciencia, pero votó en contra de una propuesta para trasladar todos los fondos de Medicare a la NASA. "

Solución a Ejercicio 2.5.3

  1. Puede ser socialmente aceptable usar mi traje de baño en un restaurante de comida rápida. Mi ropa interior es menos reveladora que mi traje de baño y, sin embargo, aún despertaría muchas más cejas ir a ese restaurante en ropa interior que mi traje de baño. La ropa (y el estilo en general) abarcan de alguna manera una forma de comunicación, y las personas pueden objetar el estado de ánimo o el mensaje de un outft sin objetar realmente cuánto revela el outft. (Otros ejemplos de comunicación a través del estilo incluyen logotipos de equipos, camisetas con eslóganes divertidos y brazaletes).
  2. Los autobuses son mucho más baratos que el tren ligero. Sin embargo, el tren ligero aquí en Houston demuestra que muchas personas que normalmente no tomarían un autobús son dispuesto a tomar el tren ligero. (Sólo después de reconocer esto, podemos intentar averiguar qué por qué la diferencia existe, y luego haga una lluvia de ideas para encontrar una mejor solución general).

Solución al ejercicio 2.5.5

  1. r ∧¬q
  2. rpag Piense en la reformulación del inglés como "Si sacaste una A en esta clase, debes haber sacado una A al final".
  3. 3. pagqr

Solución al ejercicio 2.5.7

Poppins María

Solución al ejercicio 2.5.10

  1. Hay muchas respuestas simples, como Y - tiene - 1, ¬W - tiene - 1,.
  2. Hay muchas respuestas simples, como a, N - tiene - 1, J - tiene - 3,.

Para cada uno, también hay muchas fórmulas compuestas con conectivos como ∧ y ∨.


Martes, 22 de julio de 2008

Capítulo 2 Ejercicios

2.1 Considere la gramática libre de contexto

a) Muestre cómo esta gramática puede generar la cadena aa + a *.

b) Construya un árbol de análisis sintáctico para esta cadena.

c) ¿Qué lenguaje genera esta gramática? Justifica tu respuesta.

Esta gramática genera un lenguaje que consiste en cualquier posible operación aritmética que involucre a con el uso de solo las operaciones + y * y la notación de sufijo. El único símbolo no terminal en la gramática es a y reemplaza todas las apariciones de S, dejando solo una declaración que consiste en una serie de a's y las operaciones + y *.

2.2 ¿Qué lenguaje generan las siguientes gramáticas?

Esta gramática genera un lenguaje que consta de una serie de ceros y unos entre un 0 y un 1. Debe haber al menos dos ceros y dos unos y hay el mismo número de ceros que de unos.

b) S & # 8594 + SS | -SS | a

Esta gramática genera un lenguaje que consiste en cualquier posible operación aritmética que involucre a con el uso de solo las operaciones + y * y la notación de prefijo.

Esta gramática genera un lenguaje que consiste en una serie de pares de paréntesis emparejados adyacentes y anidados.

Esta gramática genera un lenguaje que consta de un número igual de a y b sin ningún orden en particular.

e) S & # 8594 a | S + S | S S | S * | ( S )

Esta gramática genera un lenguaje que consiste en cualquier posible operación aritmética que involucre a con el uso de solo las operaciones + y * y conjuntos de paréntesis coincidentes. Puede incluir notaciones tanto de sufijo como de infijo.

2.3 ¿Cuáles de las gramáticas del ejercicio 2.2 son ambiguas?

La letra e del ejercicio 2.2 es ambigua. La cadena a + a * se puede analizar de más de una forma:

2.4 Construya gramáticas libres de contexto inequívocas para cada uno de los siguientes idiomas.

a) Expresiones aritméticas en notación postfija.

expr & # 8594 expr expr +
expr & # 8594 expr expr -
expr & # 8594 dígitos
dígito & # 8594 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

b) Listas asociativas a la izquierda de identificadores separados por comas.

c) Listas asociativas por la derecha de identificadores separados por comas.

d) Expresiones aritméticas de números enteros e identificadores con los cuatro operadores binarios +, -, *, /.

expr & # 8594 expr + término | expr - término | término
término & # 8594 término * factor | término / factor | factor
factor & # 8594 dígitos | id | (expr)

e) Suma unario más y menos a los operadores aritméticos de (d).

expr & # 8594 expr + término | expr - término | término
término & # 8594 término * factor | término / factor | factor
factor & # 8594 dígitos | id | (expr) | + factor | -factor


Registro de referencia para OID 1.3.6.1.2.1.2.2.1.10

El número total de octetos recibidos en el
interfaz, incluidos los personajes de encuadre.

Analizado del archivo MRVINREACH.mib
Módulo: MRVINREACH

Descripción por cisco_v1

El número total de octetos recibidos en la interfaz,
incluidos los personajes de encuadre.

Las discontinuidades en el valor de este contador pueden ocurrir en
reinicialización del sistema de gestión, y en otros
veces como lo indica el valor de
ifCounterDiscontinuityTime.

Descripción por oid_info

Número total de octetos recibidos en la interfaz, incluidos los caracteres de entramado.
Ver en oid-info.com

Descripción por mibdepot

El número total de octetos recibidos en el
interfaz, incluidos los personajes de encuadre.

Analizado desde el archivo msh100.mib.txt
Compañía: Ninguna
Módulo: LBMSH-MIB

Descripción por Cisco

El número total de octetos recibidos en la interfaz,
incluidos los personajes de encuadre.

Las discontinuidades en el valor de este contador pueden ocurrir en
reinicialización del sistema de gestión, y en otros
veces como lo indica el valor de
ifCounterDiscontinuityTime.


2.2.1: Ejercicios 2.2

El equipo de Apache Maven desea anunciar el lanzamiento de Maven 2.2.1.

Maven es una herramienta de comprensión y gestión de proyectos de software. Basado en el concepto de un modelo de objetos de proyecto (POM), Maven puede administrar la construcción, los informes y la documentación de un proyecto desde un lugar central.

La versión principal es independiente de los complementos disponibles. Las versiones posteriores de complementos se realizarán por separado. Consulte la Lista de complementos para obtener más información.

¡Esperamos que disfrute usando Maven! Si tiene alguna pregunta, consulte:

2.2.1 Notas de la versión

Maven 2.2.1 tiene como objetivo corregir varias regresiones críticas relacionadas con la selección de la implementación de Wagon basada en HttpClient para transferencias HTTP / HTTPS en Maven 2.2.0. La nueva versión revierte esta selección, restableciendo la versión Sun-based - o ligero - Implementación de vagones por defecto para este tipo de tráfico. Sin embargo, Maven 2.2.1 va un paso más allá para proporcionar un medio para seleccionar qué proveedor - o implementación - el usuario desea utilizar para un protocolo de transferencia particular. Puede encontrar más información sobre proveedores en nuestra Guía de proveedores de vagones.

Además, Maven 2.2.1 aborda algunos problemas de larga data relacionados con la inyección de asignaciones de ciclo de vida personalizadas y controladores de artefactos. Estos componentes personalizados ahora se cargan correctamente independientemente de si provienen de un complemento con la marca de extensiones habilitada o de una extensión de compilación pura. Además, ahora se utilizarán controladores de artefactos personalizados para configurar los atributos del artefacto principal del proyecto, además de cualquier artefacto relacionado con las dependencias o los adjuntos del proyecto creados durante la compilación.

La lista completa de cambios se puede encontrar en nuestro sistema de gestión de problemas y se reproduce a continuación.


Ver el vídeo: PROBLEMA. ESTATICA BEER - JOHNSTON 9ED. RESUELTO PASO A PASO (Mayo 2022).