[Question]
  [
Former US Secretary of Defense, Donald Rumsfeld, [famously](https://en.wikipedia.org/wiki/There_are_known_knowns) popularized the phrase "known knowns." Here we're going to distill his remarks into a four-line stanza.
Specifically, output this text:
```
known knowns
known unknowns
unknown knowns
unknown unknowns
```
Capitalization doesn't matter (for example, `Known unKnowns` is fine), and a single trailing newline is acceptable, but no other formatting changes are allowed. That means a single space between the words, and either `LF` (59 bytes) or `CR/LF` (62 bytes) between the lines.
### Rules
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~54~~ 52 bytes
-2 bytes thanks to xnor
```
k='unknowns'
for i in 8,6,2,0:print k[i/3:7],k[i%3:]
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9tWvTQvOy@/PK9YnSstv0ghUyEzT8FCx0zHSMfAqqAoM69EITs6U9/YyjxWB8hQNbaK/f8fAA "Python 2 – Try It Online")
The results from the `/` and `%` will be `[[2, 2], [2, 0], [0, 2], [0, 0]]` that will be the starting indexes, removing the `un` when `2`, keeping the string unaltered when `0`
[Answer]
# Vim ~~28~~ 25 bytes
This is my first Vim answer, any golfing tips are welcome.
```
2iunknown ␛rsY3P2xw.+.jw.
```
[![In action](https://i.stack.imgur.com/cftH0.gif)](https://i.stack.imgur.com/cftH0.gif)
Thank you [Lynn](https://codegolf.stackexchange.com/users/3852/lynn) for writing the [python script](https://gist.github.com/lynn/5f4f532ae1b87068049a23f7d88581c5) to make that fantastic animation.
This can also be run by V [Try it Online!](https://tio.run/##K/v/3yizNC87L788T0G6qDjSOMCoIlxPWy8rXO//fwA)
Also 25:
```
2iknown ␛rsY3pwiun␛+.+.w.
```
[Answer]
# bash, 36 bytes
```
printf %s\\n {,un}known\ {,un}knowns
```
other solutions
36
```
eval echo\ {,un}known\ {,un}knowns\;
```
37
```
eval printf '%s\\n' \{,un}known{\\,s}
```
38
```
eval eval echo\\ \{,un}known{\\,'s\;'}
```
41
```
x=\\\ {,un}known;eval "eval echo$x$x\s\;"
```
45
```
x='\ {,un}known' e=eval;$e "$e echo$x$x\s\;"
x='\ {,un}known' e=eval\ ;$e"$e\echo$x$x\s\;"
```
if leading newline and extra space were accepted 31 bytes :
```
echo '
'{,un}known\ {,un}knowns
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~13~~ 12 bytes
Saved 1 byte thanks to *Erik the Outgolfer* (avoid closing string)
```
„Š¢—‚#D's«â»
```
[Try it online!](https://tio.run/##ASEA3v8wNWFiMWX//@KAnsWgwqLigJTigJojRCdzwqvDosK7//8 "05AB1E – Try It Online")
**Explanation**
```
„Š¢—‚           # push the string "known unknown"
     #          # split on spaces
      D         # duplicate
       's«      # append "s" to each
          â     # cartesian product
           »    # join on newline
```
[Answer]
## CJam (26 25 bytes)
```
"unknown"_2>\]2m*{S*'sN}%
```
[Online demo](http://cjam.aditsu.net/#code=%22unknown%22_2%3E%5C%5D2m*%7BS*'sN%7D%25)
Cartesian product of `["known" "unknown"]` with itself, then each element joined with space and suffixed with `s` and a newline.
Thanks to [Erik](https://codegolf.stackexchange.com/users/41024/erik-the-outgolfer) for a one-byte saving.
[Answer]
# [R](https://www.r-project.org/), ~~52~~ ~~51~~ 50 bytes
```
cat(gsub(1,"known","1 1s
1 un1s
un1 1s
un1 un1s"))
```
[Try it online!](https://tio.run/##K/r/PzmxRCO9uDRJw1BHKTsvvzxPSUfJUMGwmMtQoTQPSAEJBSgF4itpav7/DwA "R – Try It Online")
Surprisingly short substitution and print commands make this an *actually competitive* R answer in a [string](/questions/tagged/string "show questions tagged 'string'") challenge!
~~Even if it's super boring.~~ Mildly more interesting now, and with a byte saved thanks to [J.Doe](https://codegolf.stackexchange.com/users/81549/j-doe)!
Saved another byte thanks to [this answer, also by J.Doe!](https://codegolf.stackexchange.com/a/173971/67312)
[Answer]
# [Haskell](https://www.haskell.org/), ~~60~~ ~~58~~ ~~53~~ 51 bytes
```
f<$>l<*>l
f x y=x++' ':y++"s"
l=["known","unknown"]
```
[Try it online!](https://tio.run/##y0gszk7Nyfmfk1lcomCrEPM/zUbFLsdGyy6HK02hQqHStkJbW11B3apSW1upWIkrxzZaKTsvvzxPSUepNA/Civ2fm5iZB9Scm1jgq1BQWhJcUuSTpwAy8f@/5LScxPTi/7rJBQUA "Haskell – Try It Online")
Yields a list of lines as was recently allowed. Thanks to [@firefrorefiddle](https://codegolf.stackexchange.com/users/7508/firefrorefiddle) for pointing out.
-2 bytes thanks to [cole](https://codegolf.stackexchange.com/users/42833/cole).
---
**58 byte version:**
```
f=<<"? ?s\n? un?s\nun? ?s\nun? un?s"
f '?'="known"
f c=[c]
```
[Try it online!](https://tio.run/##y0gszk7NyflfXFKUmZeuYKsQ8z/N1sZGyV7Bvjgmz16hNA9EA0kFGA0SUeJKU1C3V7dVys7LL88D8ZJto5Nj/@cmZuYBzSgoLQkuKVKAmPn/X3JaTmJ68X/d5IICAA "Haskell – Try It Online") Yields a single string.
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 54 bytes
```
v=>@"z zs
z unzs
unz zs
unz unzs".Replace("z","known")
```
[Try it online!](https://tio.run/##LY2xDsIgFAB3voIwQVL7A7WNiYmTLjo4I74YIj5IH9RI02/HGlnuctMZ2hg/Qgnp5qzhxmkivp8ZRR3Xvnwowqs9JDRbiqPFR/PXEPoy9cNOZJ6JZZ5w1Qpe9WvRniE4bUCKLBrxRP9GoUrH6qw@Jm/v/KQtSsXmOtx7JO@gvY42wtEiyCAxOadUxxa2lC8 "C# (.NET Core) – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~33~~ 32 bytes
```
 s¶ uns¶un s¶un uns
 |s
known$&
```
[Try it online!](https://tio.run/##K0otycxL/P@fS6H40DaF0jwgWZqnACGBPC6FmmKu7Lz88jwVtf//AQ "Retina – Try It Online") Edit: Saved 1 byte thanks to @ovs. Explanation: This is almost the trivial approach of using a placeholder for `known`, except here I simply insert it before each space or `s`, which saves ~~3~~ 4 bytes.
[Answer]
# PHP, ~~55 51~~ 47 bytes
```
<?=strtr("1 1s
1 01s
01 1s
01 01s",[un,known]);
```
[try it online](http://sandbox.onlinephpfunctions.com/code/721dcb4227f413507aae5f582e8de8c2284983eb)
[Answer]
## [Retina](https://github.com/m-ender/retina), ~~33~~ 32 bytes
*Saved 1 byte using an intermediate printing approach from Leo.*
```
 ¶u
knowns
u
 un
:`s 
 
m`^
un
```
[Try it online!](https://tio.run/##K0otycxL/P@fS@HQtlIuruy8/PK8Yq5SLoXSPC6rhGIFLgWu3IQ4rtK8//8B "Retina – Try It Online")
### Explanation
```
 ¶u
```
Turns the non-existent (i.e. empty) input into the string on the second line. That one seems pretty weird, but these characters are codes for the stuff that goes *between* two instances of `known[s]` on the first two lines of the result. Space and linefeed are just themselves and `u` is  `un`.
```
knowns
```
Now we insert `knowns` at every position (i.e. at the beginning, end, and between every pair of characters).
```
u
 un
```
We decode the `u`.
```
:s 
 
```
Then we get rid of the `s`s in front of spaces, i.e. those in the first half of each line, and print the result.
```
m`^
un
```
And finally we prepend `un` to both lines and print the result again.
This beats [the trivial approach](https://tio.run/##K0otycxL/P@fK1shu/jQtmyF0jwQDSQVYDRIhCubKzsvvzzv/38A) of just using a placeholder for `known` by 4 bytes, but not [Neil's more efficient implementation](https://codegolf.stackexchange.com/a/145453/52210) of that approach.
[Answer]
# [Shakespeare Programming Language](https://github.com/TryItOnline/spl), ~~1021~~ ~~1012~~ 993 bytes
*-19 bytes thanks to Joe King!*
```
,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:Am I nicer a big cat?If sois the remainder of the quotient betweenI the sum ofa cat a big cat worse a big cat?If notlet usScene V.You be the sum ofa fat fat fat pig the cube ofthe sum ofa cat a big big cat.Speak thy.You be the sum ofyou the sum ofa cat a fat fat fat pig.Speak thy.Scene V:.[Exit Ajax][Enter Page]Page:You be the product ofthe sum ofa cat a big big cat the sum ofa pig a big big big big cat.Speak thy.You be the sum ofyou the sum ofa cat a big cat.Speak thy.Ford:You be the sum ofI a cat.Speak thy.You be the sum ofyou a big big big cat.Speak thy.Page:Speak thy.You be the sum ofyou the sum ofa cat a big big cat.Is the remainder of the quotient betweenAjax a big cat worse a cat?If soyou big big big big big cat.Speak thy.If solet usScene X.You be twice the sum ofa cat a big big cat.Speak thy.Scene X:.[Exit Page][Enter Ajax]Ford:You be the sum ofyou a cat.Be you worse a big big big cat?If solet usAct I.
```
[Try it online!](https://tio.run/##pVNBboMwEPzKPgD5AVyiVEol3ypFqlpFHBxYUtpgE2yL5PXUayAxcdSi9gDCu57Z8TDWzbHvE7b@FOeEPau2SNiLOKCr5AZ4yrY5SqSP3eaMVppst5EGWyAACFkAYTJapesaOMgqd10B@@oAuTArXoJWlQbzgdBiLSpZuL4qfeFklalQGtij6RAl91Vta7dBEPxGBJ1qNc6JpTJHNGD1IPKVvSvrqGYkpYNOT@Og1Mut26TKx7NGfrZtUHy57ZeY9eIKMfhuUkAwyvMeVsZbN9lIXmf0SoMpTasK6@z/ReJMA53t1v3XQWIg/eM0QnMQSwaIHxT5k/9J4MTFF0ZryGuUpmtEadK9e7FevzXM3NtVc@eCD0sjNYKnRPgUBBcre2z44CYxPSHQIrwTwaBVINNfY9b33w)
[Answer]
# [Perl 6](https://perl6.org), 45 bytes
```
$_='known';.say for [X](($_,"un$_")xx 2)X~'s'
```
[Try it](https://tio.run/##K0gtyjH7/18l3lY9Oy@/PE/dWq84sVIhLb9IIToiVkNDJV5HqTRPJV5Js6JCwUgzok69WP3/fwA "Perl 6 – Try It Online")
## Expanded
```
$_ = 'known';
.say                # print with trailing newline the value in topic variable ｢$_｣
  for               # do that for each of the following
    [X](
      ($_, "un$_")  # ('known','unknown')
        xx 2        # list repeated twice
    ) X~ 's'        # cross using &infix:«~» with 's' (adds ｢s｣ to the end)
```
The `[X](…)` part generates
```
(("known","known"),("known","unknown"),("unknown","known"),("unknown","unknown")).Seq
```
Then using `X~` on it coerces the inner lists into a Str (because of the `&infix:«~»` operator), which doing so adds a space between values.
```
("known known", "known unknown", "unknown known", "unknown unknown").Seq
```
Then each is joined with an `s`
```
("known knowns", "known unknowns", "unknown knowns", "unknown unknowns").Seq
```
[Answer]
## Haskell, ~~57~~ 52 bytes
```
id=<<id=<<mapM(\s->[s,"un"++s])["known ","knowns\n"]
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzPzPF1sYGTOQmFvhqxBTr2kUX6yiV5ilpaxfHakYrZefll@cpKOlAGMUxeUqx/3MTM/MUbBUKSkuCS4oU0v7/S07LSUwv/q@bXFAAAA "Haskell – Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~64~~ ~~47~~ 35 bytes
```
⍪,∘.{⍺,' ',⍵,'s'}⍨k('un',k←'known')
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtEx71rtJ51DFDr/pR7y4ddQV1nUe9W3XUi9VrH/WuyNZQL81T18kGKlPPzssvz1PX/P8fAA)
**How?**
`k←'known'` - `k` is `"known"`
`k('un',k←'known')` - `"known" "unknown"`
`∘.`...`⍨` - outer product with itself
    `{⍺,' ',⍵,'s'}` - with the function that formats the args as `{⍺} {⍵}s`
`,` - smash the product table into vector
`⍪` - separate to columns
[Answer]
# Java 8, ~~56~~ 55 bytes
```
v->" s\n uns\nun s\nun uns".replaceAll(" |s","known$0")
```
-1 byte thanks to *@SuperChafouin*.
**Explanation:**
[Try it here.](https://tio.run/##LY7BCsIwEETvfsUQPKRgi/ei4AfYi@BFPcQ0Smq6LU1SEe231y0t7A7MLryZSvUqbVpDVfkatVPe46gsfVeApWC6h9IGxWSBU@gsPaHlubEl@iTn68DL44MKVqMAYYexT/cC/kqIxBoJs7ITWWdax8yDc1Lg58VGvKh503orkjGfYW28O4YtzH4Kq7mTnPMvN6hkKfTxwdRZE0PW8is4kpRpSdG5ZGk3jH8)
```
v->                         // Method with empty unused parameter
  " s\n uns\nun s\nun uns"  //  Literal String
   .replaceAll(" |s",       //  Replace all spaces and "s" with:
     "known                 //   Literal "known"
           $0")             //   + the match (the space or "s")
                            // End of method (implicit / single-line return-statement)
```
[Answer]
# C (gcc), ~~79~~  ~~78~~  76 bytes
*Thanks to @Justin Mariner for golfing one byte!*
```
f(){printf("%s %1$ss\n%1$s un%1$ss\nun%1$s %1$ss\nun%1$s un%1$ss","known");}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NQ7O6oCgzryRNQ0m1WEHVUKW4OCYPRCmU5kF5EIYCKg8qq6SjlJ2XX56npGld@x9ojEJuYmaehiZXNZcCEABNt@aq/Q8A)
[Answer]
# [Husk](https://github.com/barbuz/Husk), 14 bytes
```
OΠṠemhw¨ṅW∫ḟωμ
```
[Try it online!](https://tio.run/##ASIA3f9odXNr//9PzqDhuaBlbWh3wqjhuYVX4oir4bifz4nOvP// "Husk – Try It Online")
# Explanation
```
OΠṠemhw¨ṅW∫ḟωμ
       ¨ṅW∫ḟωμ    The compressed string "knowns unknowns"
      w           Split on spaces ["knowns","unknowns"]
   e              Make a list with:
    mh             this list with the last letter dropped from each word
  Ṡ                and this same list
                  [["known","unknown"],["knowns","unknowns"]]
 Π                Cartesian product [["known","knowns"],["unknown","knowns"],["known","unknowns"],["unknown","unknowns"]]
O                 Sort the list [["known","knowns"],["known","unknowns"],["unknown","knowns"],["unknown","unknowns"]]
                  Implicitely print joining with spaces and newlines
```
[Answer]
# [6502 machine code](https://en.wikibooks.org/wiki/6502_Assembly) (C64), 48 bytes
```
00 C0 A9 37 85 FB A9 73 4D 2B C0 8D 2B C0 A9 0D 4D 2C C0 8D 2C C0 A9 26 90 02
E9 02 A0 C0 20 1E AB 06 FB D0 E1 60 55 4E 4B 4E 4F 57 4E 53 0D 00
```
**[Online demo](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22know.prg%22:%22data:;base64,AMCpN4X7qXNNK8CNK8CpDU0swI0swKkmkALpAqDAIB6rBvvQ4WBVTktOT1dOUw0A%22%7D,%22vice%22:%7B%22-autostart%22:%22know.prg%22%7D%7D)**
**Usage:** `sys49152`
---
### How it works
The trick here is to use a "loop counter" for 8 iterations where bits 7 to 1 of the initial value are `1` for `unknown(s)` and `0` for `known(s)` in one iteration. This counter is shifted to the left after each iteration (shifting the leftmost bit into the carry flag) and bit `0` is initially `1` so we know we're finished once the last bit was shifted out. In the first iteration, `known` is printed because when calling the program, the carry flag is clear.
In each iteration, the end of the string is toggled between `<space>` and `s<newline>`.
Here's the commented disassembly listing:
```
         00 C0            .WORD $C000    ; load address
.C:c000  A9 37            LDA #$37       ; initialize loop counter ...
.C:c002  85 FB            STA $FB        ; ... as 0011 0111, see description
.C:c004   .loop:
.C:c004  A9 73            LDA #('s'^' ') ; toggle between 's' and space
.C:c006  4D 2B C0         EOR .plural
.C:c009  8D 2B C0         STA .plural
.C:c00c  A9 0D            LDA #$0D       ; toggle between newline and 0
.C:c00e  4D 2C C0         EOR .newline
.C:c011  8D 2C C0         STA .newline
.C:c014  A9 26            LDA #<.knowns  ; start at "known" except
.C:c016  90 02            BCC .noprefix  ; when carry set from shifting $fb:
.C:c018  E9 02            SBC #$02       ; than start at "un"
.C:c01a   .noprefix:
.C:c01a  A0 C0            LDY #>.knowns  ; high-byte of string start
.C:c01c  20 1E AB         JSR $AB1E      ; output 0-terminated string
.C:c01f  06 FB            ASL $FB        ; shift loop counter
.C:c021  D0 E1            BNE .loop      ; repeat if not 0 yet
.C:c023  60               RTS            ; done
.C:c024   .unknowns:
.C:c024  55 4E           .BYTE "un"
.C:c026   .knowns:
.C:c026  4B 4E 4F 57 4E  .BYTE "known"
.C:c02b   .plural:
.C:c02b  53              .BYTE "s"
.C:c02c   .newline
.C:c02c  0D 00           .BYTE $0d, $00
```
[Answer]
## [Perl 5](https://www.perl.org/), 33 bytes
**Disclaimer**: I didn't realise that brace expansion was possible within the `<...>` operator (learned thanks to @[Grimy](https://codegolf.stackexchange.com/users/6484/grimy)'s [answer](https://codegolf.stackexchange.com/a/146295/9365)!) and the using the clever expansion trick from @[NahuelFouilleul](https://codegolf.stackexchange.com/users/70745/nahuel-fouilleul)'s [amazing bash answer](https://codegolf.stackexchange.com/a/145456/9365), I was able to build this solution. I will happily remove this at either of their request.
```
print<"{,un}known {,un}knowns$/">
```
[Try it online!](https://tio.run/##K0gtyjH9/7@gKDOvxEapWqc0rzY7L788TwHBLFbRV7L7/x8A "Perl 5 – Try It Online")
---
## [Perl 5](https://www.perl.org/), 42 bytes
**41 bytes code + 1 for `-p`.**
```
s//K Ks
K unKs/;s/K/known/g;$\=s/^/un/gmr
```
[Try it online!](https://tio.run/##K0gtyjH9/79YX99bwbuYy1uhNM@7WN@6WN9bPzsvvzxPP91aJca2WD9OvxTIzi36/5/rX35BSWZ@XvF/3QIA "Perl 5 – Try It Online")
---
# [Perl 5](https://www.perl.org/), 45 bytes
Tried to come up with an alternative, but couldn't make it shorter... Thought it was different enough to warrant adding anyway.
```
print"un"x/[3467]/,known,$_%2?"s
":$"for 0..7
```
[Try it online!](https://tio.run/##K0gtyjH9/7@gKDOvRKk0T6lCP9rYxMw8Vl8nOy@/PE9HJV7VyF6pmEvJSkUpLb9IwUBPz/z/fwA "Perl 5 – Try It Online")
[Answer]
# Haskell, ~~71~~ ~~66~~ ~~56~~ 54 bytes
```
(<*>).map((++).init)<*>map(' ':)$["knowns","unknowns"]
```
Thanks to [@Leo](https://codegolf.stackexchange.com/users/62393/leo) for -3 bytes!
Note: In the question's comments, the o.p. said that returning a list of strings is okay
[Try it here.](https://repl.it/MjyA/2)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
“ṿ1“ŒwƘ»pż€⁾ sY
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5yHO/cbAqmjk8qPzTi0u@DonkdNax417lMojvz/HwA "Jelly – Try It Online")
[Answer]
# Ruby, ~~53~~ 50 bytes
```
$><<"a as
a unas
una as
una unas".gsub(?a,"known")
```
[Answer]
## Batch, 66 bytes
```
@set s= in (known unknown)do @
@for %%a%s%for %%b%s%echo %%a %%bs
```
Alternative answer, also 66 bytes:
```
@for %%a in (k unk)do @for %%b in (k unk) do @echo %%anown %%bnowns
```
[Answer]
# Haxe, 71 bytes
```
(?x)->[for(a in x=["","un"])for(b in x)a+'known ${b}knowns'].join("\n")
```
[Try it online!](http://try-haxe.mrcdk.com/#7c670)
[Answer]
# [Jq 1.5](https://stedolan.github.io/jq/), 47 bytes
```
"K Ks
K unKs
unK Ks
unK unKs"|gsub("K";"known")
```
[Try it online!](https://tio.run/##yyr8/1/JW8G7mMtboTQPSAEJBSgF4ivVpBeXJmkoeStZK2Xn5ZfnKWn@//8vv6AkMz@v@L@ubl5pTo5uZl5BaQmQU5RYrptfWgLkAAA "jq – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~46~~ 44 bytes
```
' s
 uns
un s
un uns'-replace' |s','known$&'
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X12hmEuhNK@YqzRPAUwA2eq6RakFOYnJqeoKNcXqOurZefnleSpq6v//AwA "PowerShell – Try It Online")
(Almost) simple string replacement. Uses [Neil's approach](https://codegolf.stackexchange.com/a/145453/8478) to trim two bytes. Thanks to Martin for pointing that out.
Sadly, it's shorter than the more interesting cross-product method by ~~three~~ ~~five~~ three bytes:
## [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~49~~ 47 bytes
```
($a='known','unknown')|%{$i=$_;$a|%{"$i $_`s"}}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0Ml0VY9Oy@/PE9dR700D8LSrFGtVsm0VYm3VkkEMpVUMhVU4hOKlWpr//8HAA "PowerShell – Try It Online")
[Answer]
# T-SQL, ~~56~~ 54 bytes
```
PRINT REPLACE('1 1s
1 un1s
un1 1s
un1 un1s',1,'known')
```
SQL supports line breaks inside string literals, so similar to some other languages already posted.
**EDIT**: Slightly longer (**82 bytes**), but a bit more clever:
```
SELECT k+s+k+p+k+s+u+p+u+s+k+p+u+s+u+p
FROM(SELECT'known'k,' 's,'unknown'u,'s
'p)t
```
**EDIT 2**: My favorite so far, using a cross-self-join from a derived table (**79 bytes**):
```
WITH t AS(SELECT'known'a UNION SELECT'unknown')
SELECT z.a+' '+t.a+'s'FROM t,t z
```
**EDIT 3**: Changed the replacement character from `'x'` to `1`, which lets me remove the quotes around it and save 2 bytes, since `REPLACE` does an implicit conversion to string.
[Answer]
# [ReRegex](https://github.com/TehFlaminTaco/ReRegex), 38 bytes
```
a/known/a as\na unas\nuna as\nuna unas
```
[Try it online!](https://tio.run/##K0otSk1Prfj/P1E/Oy@/PE8/USGxOCYvUaE0D0QDSQUYDRL5/x8A "ReRegex – Try It Online")
[Answer]
# Javascript ~~66 54 53~~ 50 bytes
```
_=>` s
 uns
un s
un uns`.replace(/ |s/g,'known$&')
```
### History
* saved 12 bytes thanks to @someone (explicit usage of "un" in the main string)
* saved 1 byte thanks to @ThePirateBay (split..join instead of replace)
* saved 3 bytes thanks to @Neil (better replace())
]