Coding theory

Error

There was an error loading the page.

Contributors

Feedback

From users who are not members of Content created by Newcastle University :

Bill Foster

said

Ready to use

6 years, 5 months ago

History

○

Christian Lawson-Perfect 4 years, 9 months ago

Published this.

○

Bill Foster 6 years, 5 months ago

Gave some feedback: Ready to use

○

Christian Lawson-Perfect 6 years, 7 months ago

Created this.

There is only one version of this exam that you have access to.

There is one other version that you do not have access to.

Question groups

Group 20 questions

1.
Ready to use

Correct an error in a received message which was encoded using Hamming's square code
2.
Ready to use

Decode a message of two codewords encoded using Hamming's [7,4] code, with at most one error per codeword.
3.
Ready to use

Find all words with given Hamming distance from a given codeword.
4.
Has some problems

Compute tables of Hamming distances in given codes, then determine which codes are equivalent.
5.
Ready to use

Compute the information rate and minimum distance of some binary codes.
6.
Ready to use

Find upper and lower bounds on the number of codewords in three maximal codes given their codeword lengths and minimum distances. Uses Hamming, Singleton and Gilbert-Varshamov bounds.
7.
Ready to use

List all vectors in a spanning set. (repeated 3 times)
8.
Ready to use

Given a set of vectors, find a basis which generates their span as a subspace of $\mathbb{Z}_n$ .
9.
Ready to use

Given a matrix in the field $\mathbb{Z}_n$ . By reducing it to row-echelon form (or otherwise), find a basis for the row space of the matrix, as a list of vectors.
10.
Should not be used

Given a generating matrix for a binary linear code, construct a parity check matrix, list all the codewords, list all the words in a given coset, give coset leaders, calculate syndromes for each coset, correct a codeword with one error.
11.
Ready to use

Given a set of codewords generating a code, write down a generator matrix, encode three data vectors, and decode one codeword.
12.
Ready to use

Given a set of codewords generating a code, give a generating matrix, encode three data vectors, and decode one codeword.
13.
Ready to use

Given a set of codewords generating a code, give a generating matrix, encode three data vectors, and decode one codeword.
14.
Should not be used

Given a generating matrix for a linear code, give a parity check matrix
15.
Ready to use

Compute the minimum distance between codewords of a code, given a parity check matrix.
16.
Ready to use

Given a generator matrix for a linear code, write a parity check matrix, compute the syndrome of a word, and decide if it's a codeword.
17.
Ready to use

Write down a lexicographic parity check matrix for a Hamming code and correct two received codewords.
18.
Ready to use

Write down the lexicographic parity check matrix for a Hamming code, and correct two received codewords.
19.
Ready to use

Compute the word length, minimum distance and dimension of some given Hamming codes.
20.
Ready to use

Write down the lexicographic parity check matrix and generator matrix for a Hamming code, which is the dual of a Simplex code, then determine if a given word is a codeword of the corresponding Simplex code.

Topics

No topics have been defined.

Diagnostic algorithm

Extend built-in algorithm?

Base diagnostic algorithm

state (Produces the initial value of the state object): // should be renamed "initial_state"
    [
        "topics": map(
            [
                "topic": topic,
                "status": "unknown" // "unknown", "passed", or "failed"
            ],
            topic,
            values(topics)
        ),
        "retries": 3,
        "finished": false,
    ]

topics_by_objective (A dictionary mapping a learning objective name to a list of indices of topics):
    dict(map(
        let(
            ltopics, values(topics),
            indices, filter(lo["name"] in ltopics[j]["learning_objectives"], j, 0..len(ltopics)-1),
            [lo["name"],indices]
        ),
        lo,
        learning_objectives
    ))

unknown_topics (Which topics are still unknown?): 
    map(x["topic"],x,filter(x["status"]="unknown",x,state["topics"]))

first_topic (The first topic to pick a question on):
    unknown_topics[floor(len(unknown_topics)/2)]["name"]

first_question (The first question to show the student):
    random(topics[first_topic]["questions"])

get_dependents (An expression which gets the topics to update after answering a question):
    expression("""
        [target] + flatten(map(eval(get_dependents,["target":t,"correct":correct]),t,topics[target][if(correct,"depends_on","leads_to")]))
    """)

correct (Did the student get the current question right?):
    current_question["credit"]=1

after_answering (Update the state after the student answers a question):
    let(
        ntopics, eval(get_dependents,["target":current_topic,"correct":correct])
    ,   nstate, state + ['topics': map(
                    if(tstate["topic"]["name"] in ntopics, tstate + ["status":if(correct,"passed","failed")], tstate),
                    tstate,
                    state["topics"]
                )]
    , nstate
    )

action_retry (Use up one retry and visit the same topic again):
    [
        "label": translate("diagnostic.use retry"),
        "state": state + ["retries": state["retries"]-1],
        "next_question": random(topics[current_topic]["questions"])
    ]

action_stop (Stop the exam):
    [
        "label": translate("diagnostic.end test"),
        "state": state,
        "next_question": nothing
    ]

action_move_on (Move to the next topic, or end the exam if there are no more):
    let(
        state, after_answering,
        immediate_next_topics, topics[current_topic][if(correct, "leads_to", "depends_on")],
        unknown_topics, map(x["topic"],x,filter(x["status"]="unknown",x,state["topics"])),
        unknown_immediate_topics, filter(x["name"] in immediate_next_topics,x,unknown_topics),
        next_topics, if(len(unknown_immediate_topics), unknown_immediate_topics, unknown_topics),
        finished, len(next_topics)=0 or state["finished"],
        topic,
            if(not finished,
                next_topics[floor(len(next_topics)/2)]["name"]
            ,
                nothing
            ),
        [
            "label": translate("diagnostic.move to next topic"),
            "state": after_answering,
            "next_question": if(not finished, random(topics[topic]["questions"]), nothing)
        ]
    )

can_move_on:
    action_move_on["next_question"]<>nothing

next_actions (Actions to offer to the student when they ask to move on):
    let(
        feedback, retries_feedback+"\n\n"+translate("diagnostic.next step question")
    ,   [
            "feedback": feedback,
            "actions": if(not correct and state["retries"]>0, [action_retry], []) + if(can_move_on,[action_move_on],[action_stop])
        ]
    )

after_exam_ended (Update the state after the exam ends):
    let(
        state, after_answering,
        ntopics, map(t+["status": if(t["status"]="unknown","failed",t["status"])],t,state["topics"]),
        state+["finished": true]
    )

finished (Is the test finished? True if there are no unknown topics):
    len(unknown_topics)=0 or state["finished"]

total_progress:
    let(
        num_topics, len(state["topics"]),
        known, filter(tstate["status"]<>"unknown",tstate,state["topics"]),
        passed, filter(tstate["status"]="passed",tstate,known),
        num_known, len(known),
        num_passed, len(passed),
        [
            "name": translate("control.total"),
            "progress": if(num_topics>0,num_known/num_topics,0), 
            "credit": if(num_known>0,num_passed/num_topics,0)
        ]
    )

learning_objective_progress:
    map(
        let(
            tstates, map(state["topics"][j],j,topics_by_objective[lo["name"]]),
            known, filter(tstate["status"]<>"unknown",tstate,tstates),
            passed, filter(tstate["status"]="passed",tstate,known),
            num_topics, len(tstates),
            num_known, len(known),
            num_passed, len(passed),
            ["name": lo["name"], "progress": if(num_topics>0,num_known/num_topics,0), "credit": if(finished,num_passed/num_topics,if(num_known>0,num_passed/num_known,0))]
        ),
        lo,
        learning_objectives
    )

progress (Progress on each of the learning objectives, plus total progress):
    learning_objective_progress+
    total_progress

retries_feedback:
    translate("diagnostic.now assessing topic", ["current_topic": current_topic]) + " " +
    let(
        retries, state["retries"], 
        pluralise(retries, translate("diagnostic.one retry left"), translate("diagnostic.retries left", ["retries": retries ]))
    )
    + " " +
    let(
        p,total_progress["progress"],
        percentage, dpformat(100p, 0),
        translate("diagnostic.percentage completed", ["percentage": percentage])
    )

weak_objective_threshold (The amount of credit below which a learning objective is considered weak):
    0.6

finished_feedback:
    let(
        weak_objectives, filter(p["credit"]<weak_objective_threshold, p, learning_objective_progress),
    //
        translate("diagnostic.test is over") + " "
        +
        if(len(weak_objectives)=0,
            translate("diagnostic.passed all lo")
        ,
            translate("diagnostic.more work on lo", ["los": 
                join(map(lo["name"], lo, weak_objectives),", ")])
        )
    )

feedback:
    if(finished,
        finished_feedback,
        retries_feedback
    )

Custom diagnostic algorithm

Interface theme

Upload a new theme

Interface language

Allow students to print question content?

Show student's name?

Enter review mode immediately on ending the exam?

	Always	In submitted mode	Only in review mode	Never
Show answer correctness
Show the student's score
Show the maximum score
Show part feedback messages
Show expected answers
Show question advice

Pass threshold

Feedback messages

Loading...

Error

Metadata

Taxonomy: mathcentre

Taxonomy: Kind of activity

Taxonomy: Context

Contributors

Feedback

History

Comment

Checkpoint description

Christian Lawson-Perfect 4 years, 9 months ago

Bill Foster 6 years, 5 months ago

Christian Lawson-Perfect 6 years, 7 months ago

Question groups

Topics

Learning objectives

Base diagnostic algorithm

Custom diagnostic algorithm

On leaving a question

On timeout

5 minutes before timeout