Prohlášení o užití generativní AI












            ******************************************************************************************

            *
            ******************************************************************************************







            ******************************************************************************************
            * Vážené studentky, vážení studenti,

            ******************************************************************************************


            tento formulář Vás provede tvorbou Prohlášení o užití umělé inteligence. V tomto prohlášen
            byla při tvorbě práce užita umělá inteligence a popíšete, jakým způsobem.


            Univerzita Karlova podporuje využívání nástrojů generativní umělé inteligence studujícími 
            že je využití AI transparentní a v souladu s právním řádem ČR, předpisy Univerzity Karlovy
            součástí.


            Níže si můžete vygenerovat základní podobu Prohlášení. Doporučujeme zkontrolovat, zda vaše
            nepožaduje jinou formu prohlášení, případně konzultovat se svým školitelem či školitelkou.



            <div id="ai-declaration-widget"> <h2 id="ai-title">Prohlášení o využití AI</h2> <p id="ai-

            Tento formulář vyžaduje povolený JavaScript. Pokud po kliknutí na tlačítko nevznikne prohl
            redakční systém pravděpodobně odstraňuje skripty. V takovém případě použijte tento formulá
            jako vodítko a výsledné prohlášení zapište ručně podle textů níže. </p> <input type="hidde

            lang" name="ai-lang" value="cs"> <br> <fieldset> <legend id="ai-legend-used">1. Použití AI
            <p id="ai-question-used">Použil/a jste při tvorbě této práce nějaký nástroj umělé intelige
            <p> <label><input type="radio" name="ai-used" value="no"> <span id="ai-label-used-no">Ne, 

            a jsem žádné nástroje AI.</span></label><br> <label><input type="radio" name="ai-used" val
            checked> <span id="ai-label-used-yes">Ano, použil/a jsem alespoň jeden nástroj AI.</span><
            p> </fieldset> <br> <fieldset id="ai-tool-section"> <legend id="ai-legend-tool">2. Použitý

            legend> <p> <label id="ai-label-tool" for="ai-tool">Nástroj AI</label><br> <select id="ai-
            tool"> <option value="Microsoft Copilot">Microsoft Copilot</option> <option value="ChatGPT
            option> <option value="Claude">Claude</option> <option value="Grammarly">Grammarly</option

            value="Gemini">Gemini</option> <option value="Elicit">Elicit</option> <option value="Write
            option> <option value="Llama">Llama</option> <option value="DeepL">DeepL</option> <option
            value="NotebookLM">NotebookLM</option> <option value="Grok">Grok</option> <option value="Q

            option> <option value="Mistral">Mistral</option> <option value="QwQ">QwQ</option> <option 
            id="ai-option-other">Jiný nástroj</option> </select> </p> <p id="ai-tool-other-row"> <labe
            label-tool-other" for="ai-tool-other">Jiný nástroj, pokud není v seznamu</label><br> <inpu

            tool-other" name="ai-tool-other" type="text" size="50" placeholder="Např. Midjourney"> </p
            border="0" cellpadding="4" cellspacing="0"> <tr> <td><label id="ai-label-from" for="ai-per
            použití od</label></td> <td><input id="ai-period-from" name="ai-period-from" type="date"><

            <tr> <td><label id="ai-label-to" for="ai-period-to">Období použití do</label></td> <td><in
            period-to" name="ai-period-to" type="date"></td> </tr> </table> <p> <label id="ai-label-de
            for="ai-description">Popište, jak byl nástroj použit</label><br> <textarea id="ai-descript

            description" rows="6" cols="70" placeholder="Např. korektury textu, generování osnovy, pom
            rešeršních dotazů…"></textarea> </p> <p> <button id="ai-add-tool" type="button">Přidat nás
            seznamu</button> </p> </fieldset> <br> <fieldset id="ai-recorded-section"> <legend id="ai-

            recorded">Zaznamenaná použití</legend> <div id="ai-recorded-list"> <p>Zatím není zaznamená
            nástroj.</p> </div> </fieldset> <br> <fieldset> <legend id="ai-legend-data">Import/export<
            id="ai-data-help">Stav formuláře můžete uložit do JSON souboru a později znovu načíst.</p>

            id="ai-export" type="button">Exportovat JSON</button> <button id="ai-import" type="button"
            JSON</button> </p> </fieldset> <br> <fieldset> <legend id="ai-legend-result">Výsledné proh
            <div id="ai-error"></div> <blockquote id="ai-result"> <p>Zde se po vyplnění formuláře zobr

            prohlášení.</p> </blockquote> <p> <button id="ai-copy" type="button">Kopírovat prohlášení<
            <button id="ai-clear" type="button">Vymazat formulář</button> </p> </fieldset> </div> <scr
            () { var entries = []; var lastText = ''; var resultIsPlaceholder = true; var AI_DECLARATI

            = 'cs'; function el(id) { return document.getElementById(id); } var T = { cs: { title: 'Pr
            využití AI', jsWarning: 'Tento formulář vyžaduje povolený JavaScript. Pokud po kliknutí na
            nevznikne prohlášení, redakční systém pravděpodobně odstraňuje skripty. V takovém případě 

            tento formulář jen jako vodítko a výsledné prohlášení zapište ručně podle textů níže.', le
            'Jazyk', labelLang: 'Jazyk prohlášení', langCs: 'Česky', langEn: 'English', legendUsed: '1
            AI', questionUsed: 'Použil/a jste při tvorbě této práce nějaký nástroj umělé inteligence?'

            'Ne, nepoužil/a jsem žádné nástroje AI.', usedYes: 'Ano, použil/a jsem alespoň jeden nástr
            legendTool: '2. Použitý nástroj', labelTool: 'Nástroj AI', otherOption: 'Jiný nástroj', la
            'Název jiného nástroje', otherPlaceholder: 'Např. Midjourney', labelFrom: 'Období použití 

            'Období použití do', labelDescription: 'Popište, jak byl nástroj použit', descriptionPlace
            korektury textu, generování osnovy, pomoc s formulací rešeršních dotazů…', addTool: 'Přida
            seznamu', legendData: 'Export/Import', dataHelp: 'Rozpracovaný formulář si můžete uložit d

            a později znovu načíst.', exportJson: 'Uložit rozpracovaný formulář', importJson: 'Načíst 
            formulář', importOk: 'Data byla načtena.', importError: 'Soubor nemá platný formát nebo je
            načíst.', legendRecorded: 'Zaznamenaná použití', noEntries: 'Zatím není zaznamenán žádný n

            remove: 'Odebrat', clear: 'Vymazat formulář', legendResult: 'Výsledné prohlášení', resultP
            'Prohlášení se zde průběžně zobrazí podle aktuálního stavu formuláře.', copy: 'Kopírovat p
            none: 'Prohlašuji, že při přípravě předložené práce nebyly použity žádné nástroje umělé in

            usedIntro: 'Prohlašuji, že při přípravě předložené práce byly použity následující nástroje
            způsoby:', usedOutro: 'Po použití uvedených nástrojů umělé inteligence jsem důkladně revid
            upravil/a obsah podle potřeby a plně přejímám odpovědnost za výslednou podobu práce.', per

            'neuvedeno', descriptionLabel: 'popis použití', errorDescription: 'Vyplňte prosím popis po
            errorTool: 'Uveďte prosím název nástroje.', errorPeriod: 'Datum „od“ nemůže být později ne
            ignoredEntries: 'Zaznamenaná použití jsou při volbě „Ne“ neaktivní a do prohlášení se neza

            copied: 'Prohlášení bylo zkopírováno do schránky.', copyFailed: 'Kopírování do schránky se
            Označte text ručně a zkopírujte jej.' }, en: { title: 'AI Use Declaration', jsWarning: 'Th
            JavaScript. If no declaration appears after clicking the button, the content management sy

            removes scripts. In that case, use this form only as guidance and write the final declarat
            using the text below.', legendLang: 'Language', labelLang: 'Declaration language', langCs:
            langEn: 'English', legendUsed: '1. AI use', questionUsed: 'Have you used any AI tool in wr

            thesis?', usedNo: 'No, I did not use any AI tools.', usedYes: 'Yes, I used at least one AI
            legendTool: '2. AI tool used', labelTool: 'AI tool', otherOption: 'Other tool', labelToolO
            of the other tool', otherPlaceholder: 'e.g. Midjourney', labelFrom: 'Period of use from', 

            'Period of use to', labelDescription: 'Describe how the tool was used', descriptionPlaceho
            text editing, outline generation, assistance with formulating literature-search queries…',
            'Add tool to the list', legendData: 'Import/export', dataHelp: 'You can save the unfinishe

            JSON file and load it again later.', exportJson: 'Save unfinished form', importJson: 'Load
            form', importOk: 'Data has been loaded.', importError: 'The file is not valid or cannot be
            legendRecorded: 'Recorded uses', noEntries: 'No tool has been recorded yet.', remove: 'Rem

            'Clear form', legendResult: 'Generated declaration', resultPlaceholder: 'The declaration w
            here automatically according to the current form state.', copy: 'Copy declaration', none: 
            that no AI tools were used in the preparation of this thesis.', usedIntro: 'I declare that

            AI tools have been used in preparation of this thesis in the ways indicated:', usedOutro: 
            used the above AI tools, I have thoroughly revised and edited the content as necessary and
            responsibility for the final form of the thesis.', periodMissing: 'not specified', descrip

            'usage description', errorDescription: 'Please fill in the description of how the tool was
            errorTool: 'Please enter the tool name.', errorPeriod: 'The “from” date cannot be later th
            date.', ignoredEntries: 'Recorded uses are inactive when “No” is selected and will not be 

            declaration.', copied: 'The declaration has been copied to the clipboard.', copyFailed: 'C
            Please select the text manually and copy it.' } }; function tr(key) { return T[getLang()][
            getLang() { return AI_DECLARATION_LANGUAGE === 'en' ? 'en' : 'cs'; } function setText(id, 

            node = el(id); if (node) node.textContent = value; } var otherToolRow = el('ai-tool-other-
            otherToolAnchor = otherToolRow ? otherToolRow.nextSibling : null; var otherToolParent = ot
            otherToolRow.parentNode : null; var otherToolInput = el('ai-tool-other'); function setOthe

            { var lang = getLang(); var label = otherToolRow ? otherToolRow.getElementsByTagName('labe
            if (label) label.textContent = T[lang].labelToolOther; if (otherToolInput) otherToolInput.
            = T[lang].otherPlaceholder; } function updateOtherToolVisibility() { var select = el('ai-t

            if (!select || !otherToolRow || !otherToolParent) return; if (select.value === '__other__'
            { if (!otherToolRow.parentNode) otherToolParent.insertBefore(otherToolRow, otherToolAnchor
            (otherToolInput) otherToolInput.disabled = false; setOtherToolTexts(); } else { if (otherT

            { otherToolInput.value = ''; otherToolInput.disabled = true; } if (otherToolRow.parentNode
            otherToolRow.parentNode.removeChild(otherToolRow); } } function applyLanguage() { var lang
            getLang(); setText('ai-title', T[lang].title); setText('ai-js-warning', T[lang].jsWarning)

            setText('ai-legend-lang', T[lang].legendLang); setText('ai-label-lang', T[lang].labelLang)
            langSelect = el('ai-lang'); if (langSelect && langSelect.options && langSelect.options.len
            { langSelect.options[0].text = T[lang].langCs; langSelect.options[1].text = T[lang].langEn

            legend-used', T[lang].legendUsed); setText('ai-question-used', T[lang].questionUsed); setT
            label-used-no', T[lang].usedNo); setText('ai-label-used-yes', T[lang].usedYes); setText('a
            tool', T[lang].legendTool); setText('ai-label-tool', T[lang].labelTool); setText('ai-optio

            T[lang].otherOption); setOtherToolTexts(); setText('ai-label-from', T[lang].labelFrom); se
            label-to', T[lang].labelTo); setText('ai-label-description', T[lang].labelDescription); if
            description')) el('ai-description').placeholder = T[lang].descriptionPlaceholder; setText(

            T[lang].addTool); setText('ai-legend-data', T[lang].legendData); setText('ai-data-help', T
            setText('ai-export', T[lang].exportJson); setText('ai-import', T[lang].importJson); setTex
            recorded', T[lang].legendRecorded); setText('ai-clear', T[lang].clear); setText('ai-legend

            T[lang].legendResult); setText('ai-copy', T[lang].copy); renderEntries(); if (resultIsPlac
            { el('ai-result').innerHTML = '<p>' + htmlEscape(T[lang].resultPlaceholder) + '</p>'; } el
            { refreshDeclaration(); } updateOtherToolVisibility(); } function formatDate(value, lang) 

            value) return ''; var parts = value.split('-'); if (parts.length !== 3) return value; if (
            return Number(parts[2]) + '. ' + Number(parts[1]) + '. ' + parts[0]; return Number(parts[2
            Number(parts[1]) + '/' + parts[0]; } function formatPeriod(entry, lang) { var from = forma

            lang); var to = formatDate(entry.to, lang); if (from && to) return from + ' – ' + to; if (
            lang === 'cs' ? 'od ' + from : 'from ' + from; if (to) return lang === 'cs' ? 'do ' + to :

            ' + to; return T[lang].periodMissing; } function htmlEscape(s) { return String(s).replace(
            g, function (c) { return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]; 
            function setError(message) { el('ai-error').innerHTML = message ? '<p><strong>' + htmlEsca

            + '</strong></p>' : ''; } function selectedUsed() { var radios = document.getElementsByNam
            used'); for (var i = 0; i < radios.length; i++) if (radios[i].checked) return radios[i].va
            'yes'; } function currentToolName() { var select = el('ai-tool'); if (select.value === '__

            return otherToolInput ? otherToolInput.value.replace(/^\s+|\s+$/g, '') : ''; return select
            function renderEntries() { var box = el('ai-recorded-list'); var lang = getLang(); var dis
            selectedUsed() === 'no'; if (!entries.length) { box.innerHTML = '<p>' + htmlEscape(T[lang]

            + '</p>'; return; } var html = disabledByNo ? '<p><em>' + htmlEscape(T[lang].ignoredEntrie
            em></p>' : ''; html += '<ol>'; for (var i = 0; i < entries.length; i++) { html += '<li><st
            htmlEscape(entries[i].tool) + '</strong><br>' + htmlEscape(formatPeriod(entries[i], lang))

            + htmlEscape(entries[i].description); if (!disabledByNo) { html += ' <button type="button"
            remove="' + i + '">' + htmlEscape(T[lang].remove) + '</button>'; } html += '</li>'; } html
            box.innerHTML = html; var buttons = box.getElementsByTagName('button'); for (var j = 0; j 

            j++) { buttons[j].onclick = function () { var index = Number(this.getAttribute('data-ai-re
            (!isNaN(index)) { entries.splice(index, 1); renderEntries(); refreshDeclaration(); } }; } 
            addEntry() { setError(''); var lang = getLang(); var tool = currentToolName(); var from = 

            from').value; var to = el('ai-period-to').value; var description = el('ai-description').va
            ^\s+|\s+$/g, ''); if (!tool) { setError(T[lang].errorTool); return; } if (from && to && fr
            { setError(T[lang].errorPeriod); return; } if (!description) { setError(T[lang].errorDescr

            return; } entries.push({tool: tool, from: from, to: to, description: description}); if (ot
            otherToolInput.value = ''; updateOtherToolVisibility(); el('ai-period-from').value = ''; e
            period-to').value = ''; el('ai-description').value = ''; renderEntries(); refreshDeclarati

            function buildDeclaration() { setError(''); var lang = getLang(); if (selectedUsed() === '
            { lastText = T[lang].none; resultIsPlaceholder = false; return '<p>' + htmlEscape(lastText
            + '</p>'; } if (!entries.length) { lastText = ''; resultIsPlaceholder = true; return '<p>'

            htmlEscape(T[lang].resultPlaceholder) + '</p>'; } var lines = [T[lang].usedIntro, '']; for
            = 0; i < entries.length; i++) { if (lang === 'cs') lines.push('- ' + entries[i].tool + ' v
            + formatPeriod(entries[i], lang) + ', ' + T[lang].descriptionLabel + ': ' + entries[i].des

            + '.'); else lines.push('- ' + entries[i].tool + ' in the period ' + formatPeriod(entries[
            lang) + ', ' + T[lang].descriptionLabel + ': ' + entries[i].description + '.'); } lines.pu
            T[lang].usedOutro); lastText = lines.join('\n'); resultIsPlaceholder = false; var html = '

            htmlEscape(T[lang].usedIntro) + '</p><ul>'; for (var j = 0; j < entries.length; j++) { var
            = lang === 'cs' ? '<strong>' + htmlEscape(entries[j].tool) + '</strong> v období <strong>'
            htmlEscape(formatPeriod(entries[j], lang)) + '</strong>, ' + htmlEscape(T[lang].descriptio

            + ': ' + htmlEscape(entries[j].description) + '.' : '<strong>' + htmlEscape(entries[j].too
            strong> in the period <strong>' + htmlEscape(formatPeriod(entries[j], lang)) + '</strong>,
            htmlEscape(T[lang].descriptionLabel) + ': ' + htmlEscape(entries[j].description) + '.'; ht

            + item + '</li>'; } html += '</ul><p>' + htmlEscape(T[lang].usedOutro) + '</p>'; return ht
            refreshDeclaration() { var html = buildDeclaration(); if (html) el('ai-result').innerHTML 
            function clearAll() { entries = []; lastText = ''; resultIsPlaceholder = true; setError(''

            tool').selectedIndex = 0; if (otherToolInput) otherToolInput.value = ''; updateOtherToolVi
            el('ai-period-from').value = ''; el('ai-period-to').value = ''; el('ai-description').value
            el('ai-result').innerHTML = '<p>' + htmlEscape(tr('resultPlaceholder')) + '</p>'; renderEn

            refreshDeclaration(); } function stateForExport() { var lang = getLang(); var used = selec
            oldEntries = []; for (var i = 0; i < entries.length; i++) { oldEntries.push({ toolId: entr
            customLabel: '', periodFrom: entries[i].from || '', periodTo: entries[i].to || '', descrip

            entries[i].description || '' }); } return { schema_version: 3, generator: 'ai-declaration-
            embed', exported_at: new Date().toISOString(), lang: lang, used: used, done: true, entries
            oldEntries, embed_entries: entries.slice(), current: { toolId: '', customLabel: '', period

            '', periodTo: '', description: '', errors: {} }, answers: { q_usage: used === 'no' ? 'no' 
            q_tools: oldEntries.map(function (e) { return e.toolId; }), q_period_from: oldEntries.leng
            oldEntries[0].periodFrom : '', q_period_to: oldEntries.length === 1 ? oldEntries[0].period

            q_purpose: oldEntries.length === 1 ? oldEntries[0].description : '' } }; } function downlo
            obj) { var text = JSON.stringify(obj, null, 2); var blob = new Blob([text], { type: 'appli
            json;charset=utf-8' }); var url = URL.createObjectURL(blob); var a = document.createElemen

            = url; a.download = filename; document.body.appendChild(a); a.click(); document.body.remov
            URL.revokeObjectURL(url); } function exportJson() { downloadJson('ai-declaration-state.jso
            stateForExport()); } function normalizeImportedEntry(entry) { if (!entry || typeof entry !

            return null; var tool = entry.tool || entry.toolName || entry.name || entry.customLabel ||
            || ''; if (!tool && entry.toolId) tool = entry.toolId; if (entry.toolId === 'other' && ent
            tool = entry.customLabel; if (entry.toolId && entry.toolId !== 'other' && !entry.tool) too

            tool = String(tool || '').replace(/^\s+|\s+$/g, ''); var description = entry.description |
            || entry.purpose || ''; description = String(description || '').replace(/^\s+|\s+$/g, '');
            = entry.from || entry.periodFrom || entry.period_from || entry.dateFrom || entry.q_period_

            var to = entry.to || entry.periodTo || entry.period_to || entry.dateTo || entry.q_period_t
            (!tool && !description) return null; return { tool: tool || T[getLang()].errorTool, from: 
            || ''), to: String(to || ''), description: description }; } function normalizeImport(obj) 

            || typeof obj !== 'object') return null; var imported = { lang: obj.lang === 'en' ? 'en' :
            'yes', entries: [] }; if (obj.used === 'no' || (obj.done === true && obj.entries && obj.en
            === 0)) imported.used = 'no'; /* Důležité: export nové verze kvůli zpětné kompatibilitě ob

            embed_entries, entries i answers. Při importu proto NESMÍME číst všechny větve najednou, j
            nástroje zdvojí. Bereme první dostupný formát v pořadí: nový embed formát -> původní entri
            answers. */ var source = null; if (Array.isArray(obj.embed_entries)) { source = obj.embed_

            else if (Array.isArray(obj.entries)) { source = obj.entries; } if (source) { for (var i = 
            source.length; i++) { var n = normalizeImportedEntry(source[i]); if (n) imported.entries.p
            else if (obj.answers && typeof obj.answers === 'object') { if (obj.answers.q_usage === 'no

            imported.used = 'no'; var tools = obj.answers.q_tools; if (!tools && obj.answers.q_tool) t
            = [obj.answers.q_tool]; if (!tools && obj.answers.q_tools_other_text) tools = ['other']; i
            Array.isArray(tools)) tools = []; var desc = obj.answers.q_purpose || obj.answers.descript

            var from = obj.answers.q_period_from || obj.answers.q_date_start || ''; var to = obj.answe
            || obj.answers.q_date_end || ''; for (var a = 0; a < tools.length; a++) { var toolId = too
            tool = toolId === 'other' ? (obj.answers.q_tools_other_text || obj.answers.q_tools_other |

            toolId; var e = normalizeImportedEntry({ tool: tool, from: from, to: to, description: desc
            imported.entries.push(e); } } if (imported.entries.length > 0 && imported.used !== 'no') i
            = 'yes'; return imported; } function applyImportedState(data) { var normalized = normalize

            if (!normalized) { setError(T[getLang()].importError); return; } el('ai-lang').value = get
            radios = document.getElementsByName('ai-used'); for (var i = 0; i < radios.length; i++) ra
            = radios[i].value === normalized.used; entries = normalized.entries; el('ai-tool').selecte

            (otherToolInput) otherToolInput.value = ''; el('ai-period-from').value = ''; el('ai-period
            ''; el('ai-description').value = ''; applyLanguage(); updateOtherToolVisibility(); toggleT
            renderEntries(); refreshDeclaration(); setError(T[getLang()].importOk); } function importJ

            fileInput = document.createElement('input'); fileInput.type = 'file'; fileInput.accept = '
            json,.json'; fileInput.setAttribute('hidden', 'hidden'); fileInput.onchange = function () 
            = fileInput.files ? fileInput.files[0] : null; if (!file) return; var reader = new FileRea

            reader.onload = function (event) { try { applyImportedState(JSON.parse(event.target.result
            catch (err) { setError(T[getLang()].importError); } if (fileInput.parentNode)
            fileInput.parentNode.removeChild(fileInput); }; reader.onerror = function

            () { setError(T[getLang()].importError); if (fileInput.parentNode)
            fileInput.parentNode.removeChild(fileInput); }; reader.readAsText(file); };
            document.body.appendChild(fileInput); fileInput.click(); } function copyResult() { var lan

            getLang(); if (!lastText) refreshDeclaration(); if (!lastText) return; if (navigator.clipb
            && navigator.clipboard.writeText) { navigator.clipboard.writeText(lastText).then(function
            () { setError(T[lang].copied); }, function () { setError(T[lang].copyFailed); }); } else

            setError(T[lang].copyFailed); } function setSectionVisible(node, visible) { if (!node) ret
            node.hidden = !visible; node.style.display = visible ? '' : 'none'; } function toggleToolS
            showToolSections = selectedUsed() !== 'no'; setSectionVisible(el('ai-tool-section'), showT

            setSectionVisible(el('ai-recorded-section'), showToolSections); renderEntries(); refreshDe
            if (el('ai-lang')) el('ai-lang').value = getLang(); var warning = el('ai-js-warning'); if 
            warning.parentNode) warning.parentNode.removeChild(warning); el('ai-add-tool').onclick = a

            export').onclick = exportJson; el('ai-import').onclick = importJson; el('ai-clear').onclic
            el('ai-copy').onclick = copyResult; el('ai-lang').onchange = applyLanguage; el('ai-tool').
            = function () { updateOtherToolVisibility(); }; var radios = document.getElementsByName('a

            for (var i = 0; i < radios.length; i++) radios[i].onclick = function () { toggleToolSectio
            refreshDeclaration(); }; var validationIds = ['ai-tool-other', 'ai-period-from', 'ai-perio
            description']; for (var k = 0; k < validationIds.length; k++) { var validationNode = el(va

            if (validationNode) { validationNode.oninput = function () { setError(''); }; validationNo
            = function () { setError(''); }; } } applyLanguage(); updateOtherToolVisibility(); toggleT
            refreshDeclaration(); })(); </script>





            Jak generátor prohlášení funguje
            Tento generátor prohlášení o užití umělé inteligence vám pomůže jednoduše shrnout, jaké ná
            inteligence jste při tvorbě práce použili.


            Nejprve odpovězte na otázku, jestli jste vůbec nějaké nástroje umělé inteligence použili. 
            prohlášení velmi krátké a bez dalších kroků se vám vygeneruje ve spodní části stránky, v s

            prohlášení.


            Pokud jste nějaký nástroj AI použili, vyplňte, o jaký se jedná, v jakém časovém období jst
            a jakým způsobem. Kliknutím na Přidat nástroj do seznamu se Vám tento záznam přidá do Výsl
            ve spodní části stránky a zároveň vymaže zadané informace k tomuto nástroji.


            Následně můžete zadat jiný nástroj stejným způsobem, který se vám opět kliknutím na Přidat
            seznamu přidá do Výsledného prohlášení ve spodní části stránky.


            V sekci Zaznamenaná použití si můžete průběžně prohlížet a kontrolovat seznam vámi zadanýc
            můžete zde nástroje odebírat.


            Pozor, kliknutím na Vymazat formulář ve spodní části stránky se vymažou všechna zaznamenan




            Rozpracovaný formulář si můžete i uložit a vrátit se k němu později.


            Uděláte to jednoduše. V sekci Import/export vyberte tlačítko Exportovat JSON. Tento dokume
            počítače.

            Až se budete chtít k práci na formuláři vrátit, opět otevřete tuto stránku a tentokrát v s
            export vyberte Importovat JSON a do stránky vložte uložený dokument.


            Rozpracovaný formulář se vám opět načte.



            Až budete s podobou Prohlášení spokojeni a budete si jisti, že jste na žádný použitý nástr
            zkopírujte výsledné prohlášení a vložte jej na příslušné místo ve vaší závěrečné nebo jiné



            Příklady Prohlášení o užití umělé inteligence
            Prohlašuji, že při přípravě předložené práce byly použity následující nástroje AI uvedeným


            - Grammarly v období 12. 4. 2026 – 12. 5. 2026, popis použití: Jazyková a stylistická revi
            zejména oprava gramatických chyb a zlepšení čitelnosti textu..

            - ChatGPT v období 8. 3. 2026 – 30. 5. 2026, popis použití: Vytvoření počáteční struktury 
            brainstorming nad interpretačními přístupy k analyzovanému textu a k provedení základní re
            zdrojů..


            Po použití uvedených nástrojů umělé inteligence jsem důkladně revidoval a upravil obsah po
            plně přejímám odpovědnost za výslednou podobu práce.







            Prohlašuji, že při přípravě předložené práce byly použity následující nástroje AI uvedeným


            - GitHub Copilot v období 20. 2. 2026 – 27. 3. 2026, popis použití: Generování a optimaliz
            kódu, vytváření kostry algoritmu a návrhu testovacích funkcí..

            - Claude v období 7. 2. 2026 – 2. 5. 2026, popis použití: Vysvětlení komplexních konceptů 
            diskuse nad architekturou neuronových sítí a revize technických vysvětlení v textu..
            - Microsoft Copilot v období 27. 2. 2026 – 23. 5. 2026, popis použití: Vytvoření grafů na 

            a 41 a k vygenerování rejstříku..

            Po použití uvedených nástrojů umělé inteligence jsem důkladně revidoval/a a upravil/a obsa

            plně přejímám odpovědnost za výslednou podobu práce.







            Prohlašuji, že při přípravě předložené práce byly použity následující nástroje AI uvedeným

            - ChatGPT v období 17. 5. 2026 – 30. 5. 2026, popis použití: Vytvoření osnovy práce, synté

            stavu vědeckých poznatků a výběr relevantní odborné literatury..
            - Microsoft Copilot v období 28. 2. 2026 – 21. 3. 2026, popis použití: Konzultace výběru a
            postupu, vytváření grafů a tabulek jazyková formulace vlastní interpretace výsledků..

            - Grammarly v období 6. 3. 2026 – 10. 5. 2026, popis použití: Jazyková korektura a formáto

            Po použití uvedených nástrojů umělé inteligence jsem důkladně revidovala a upravila obsah 

            plně přejímám odpovědnost za výslednou podobu práce.







            Prohlašuji, že při přípravě předložené práce byly použity následující nástroje AI uvedeným

            - ChatGPT v období 10. 1. 2026 – 13. 2. 2026, popis použití: Brainstorming nad výzkumnými 

            strukturování teoretických konceptů a diskuse nad různými sociologickými perspektivami..
            - Claude v období 10. 7. 2026 – 12. 8. 2026, popis použití: Analýza kvalitativních dat z r
            vytváření tematických kategorií..

            - Notion AI v období 10. 7. 2026 – 20. 8. 2026, popis použití: Organizace poznámek a vytvo
            mapy..


            Po použití uvedených nástrojů umělé inteligence jsem důkladně revidoval/a a upravil/a obsa
            plně přejímám odpovědnost za výslednou podobu práce.