ring theory – Finding all the maximal ideals of $mathbb{Z}_{63}$

How do I go about finding all the maximal ideals of this ring ?

I realise that all ideals are subgroups with respect to addition. Therefore, since $mathbb{Z}_{63}$ is cyclic then every subgroup, and so every ideal, will be generated by a single element.
I also realise that $langle n rangle subseteq langle m rangle iff m vert n $.

I want to conclude then that all the ideals generated by prime numbers are maximal but this doesn’t seem right as $langle 2 rangle = mathbb{Z}_{63}$

Is there a better method to find the maximal ideals?

dnd 5e – What is your spellcasting ability when casting a spell from a Ring of Spell Storing?

The Ring of Spell Storing states (emphasis mine):

(…) While wearing this ring, you can cast any spell stored in it. The spell uses the slot level, spell save DC, spell attack bonus, and spellcasting ability of the original caster, but is otherwise treated as if you cast the spell. (…)

So say somebody has acquired such a ring and casts counterspell or dispel magic using it, or is targeted by the Arcane Trickster Rogue’s Spell Thief feature:

(…) If it is casting a spell of 4th level or higher, make an ability check using your spellcasting ability. (…)

(…) For each spell of 4th level or higher on the target, make an ability check using your spellcasting ability. The DC equals 10 + the spell’s level. (…)

(…) Immediately after a creature casts a spell that targets you or includes you in its area of effect, you can use your reaction to force the creature to make a saving throw with its spellcasting ability modifier. (…)

What would “your” or “its” spellcasting ability modifier actually be? Do you use the modifier of whoever put that spell into the ring? Does anything change if you have levels in zero, one, or two classes that can cast spells?


Some related questions:

c++ – doubly linked ring implementation

I was practicing c++ and data structures and wrote my own implementation of a doubly linked ring. I would love to improve my code a little bit more and would need help from the community.

Here is the implementation I have

#ifndef BIRING_H_INCLUDED
#define BIRING_H_INCLUDED

#include<iostream>
#include<string>

using namespace std;

template<typename Key, typename Value>
class Ring
{

private:

    struct Element
    {
        Key key;
        Value value;
        Element* next;
        Element* prev;
    };

    Element* head;
    Element* tail;


public:
    class iterator
    {

    private:
        Element* ptr;

    public:

        iterator()
        {
            ptr=NULL;
        };

        iterator(const iterator & copy)
        {
            ptr=copy.ptr;
        };

        iterator(Element* copy)
        {
            ptr=copy;
        };

        ~iterator() {};



        iterator& operator=(iterator & copy)
        {
            ptr=copy.ptr;
        };

        iterator& operator=(Element* copy)
        {
            ptr=copy;
            return *this;
        };

        Key & operator*()
        {
            return ptr->key;
        };

        const Key & getKey()
        {
            return ptr->key;
        };

        const Value & getValue()
        {
            return ptr->value;
        };

        iterator operator+(const int i)const
        {
            iterator newthis = *this;
            for(int j=0; j<i; j++)
                newthis++;
            return newthis;
        };

        iterator& operator+=(const int i)
        {
            for(int j=0; j<i; j++)
                ptr=ptr->next;
            return *this;
        };

        iterator& operator++()
        {
            iterator a(*this);
            ptr=ptr->next;
            return a;
        };

        iterator operator++(int)
        {
            ptr=ptr->next;
            return *this;
        };

        iterator operator-(const int i)const
        {
            iterator newthis = *this;
            for(int j=0; j<i; j++)
                newthis--;
            return newthis;
        };

        iterator& operator-=(const int i)
        {
            for(int j=0; j<i; j++)
                ptr=ptr->prev;
            return *this;
        };

        iterator& operator--()
        {
            iterator a(*this);
            ptr=ptr->prev;
            return a;
        };

        iterator operator--(int)
        {
            ptr=ptr->prev;
            return *this;
        };

        bool operator==(const iterator & comp)const
        {
            return ptr==comp.ptr;
        };

        bool operator!=(const iterator & comp)const
        {
            return ptr!=comp.ptr;
        };

        bool isNull()const
        {
            return !ptr;
        };
    };


    Ring();
    ~Ring();

    Ring(const Ring<Key,Value> & copy);
    Ring<Key,Value> & operator=(const Ring<Key,Value> & copy);

    Ring<Key,Value> operator+(const Ring<Key,Value> & add)const;
    Ring<Key,Value> operator-(const Ring<Key,Value> & subtract)const;

    Ring<Key,Value>& operator++();
    Ring<Key,Value> operator++(int);

    Ring<Key,Value>& operator--();
    Ring<Key,Value> operator--(int);

    Ring<Key,Value> & operator+=(const Ring<Key,Value> & add)
    {
        *this=*this+add;
        return *this;
    };
    Ring<Key,Value> & operator-=(const Ring<Key,Value> & subtract)
    {
        *this=*this-subtract;
        return *this;
    };

    void clear();
    void reverse();


    iterator begin() const
    {
        return iterator(head);
    };


    iterator end() const
    {
        return iterator(tail);
    };

    unsigned int size() const;
    bool empty()const
    {
        return !head;
    };

    bool insertAt(unsigned int pos, const Key&key, const Value &value);
    bool insertAfter(const Key&keypos, const Key&key, const Value &value);
    bool insertAfter(const iterator & iter, const Key&key, const Value &value);

    void push_front(const Key&key, const Value &value);
    void push_back(const Key&key, const Value &value);
    void pop_front()
    {
        iterator a(begin());
        remove(a);
    };
    void pop_back()
    {
        iterator a(end());
        remove(a);
    };

    bool remove(const Key&key);
    bool remove(iterator & iter);
    bool removeAllOf(const Key&key);

    bool exists(const Key&key);

    bool operator==(const Ring<Key,Value> & check)const;
    bool operator!=(const Ring<Key,Value> & check)const;


    template<typename u, typename i>
    friend ostream & operator<< (ostream & os, const Ring<u,i> & toprint);


    iterator find(const Key &where) const;//move to the position of the designated ID
    iterator findPlace(int place) const;//move to the position of designated startindex
    bool findNodePlace(int place) const;

};



template <typename Key, typename Value>
unsigned int Ring<Key, Value>::size() const
{
    int length=0;
    if(head!=NULL)
    {
        Element *current = head->next;
        length=1;
        while(current!=head)
        {
            length++;
            current=current->next;
        }
    }
    return length;
}


template<typename Key, typename Value>
Ring<Key,Value>::Ring()
{
    head=tail=NULL;
}

template<typename Key, typename Value>
Ring<Key,Value>::Ring(const Ring<Key,Value> & copy)
{
    head=tail=NULL;
    Element * temp = copy.head;
    while (temp)
    {
        this->push_back(temp->key, temp->value);
        if(temp==copy.tail)
            break;
        temp=temp->next;
    }
}

template<typename Key, typename Value>
Ring<Key,Value>::~Ring()
{
    clear();
}


template<typename Key, typename Value>
Ring<Key,Value> & Ring<Key,Value>::operator=(const Ring<Key,Value> & copy)
{
    if(&copy==this)
        return *this;

    clear();

    Element * temp = copy.head;
    while (temp)
    {
        this->push_back(temp->key, temp->value);
        if(temp==copy.tail)
            break;
        temp=temp->next;
    }

    return *this;
}


template<typename Key, typename Value>
bool Ring<Key,Value>::operator==(const Ring<Key,Value> & check)const
{
    bool same = true;
    Element * temp1 = head;
    Element * temp2 = check.head;
    while(temp1&&temp2)
    {
        if(temp1->key!=temp2->key || temp1->value!=temp2->value)
            same = false;
        if(temp1==tail||temp2==check.tail)
            break;
        temp1=temp1->next;
        temp2=temp2->next;
    }
    return same;
}

template<typename Key, typename Value>
bool Ring<Key,Value>::operator!=(const Ring<Key,Value> & check)const
{
    return !(*this==check);
};


template<typename Key, typename Value>
Ring<Key,Value> Ring<Key,Value>::operator+(const Ring<Key,Value> & added)const
{
    Ring<Key,Value> tempseq;
    Element * temp = head;
    while(temp)
    {
        tempseq.push_back(temp->key,temp->value);
        if(temp==tail)
            break;
        temp=temp->next;
    }
    temp = added.head;
    while(temp)
    {
        tempseq.push_back(temp->key,temp->value);
        if(temp==added.tail)
            break;
        temp=temp->next;
    }
    return tempseq;
}

template<typename Key, typename Value>
Ring<Key,Value> Ring<Key,Value>::operator-(const Ring<Key,Value> & subtract)const
{
    Ring<Key,Value> tempseq;
    Element * temp = head;
    while(temp)
    {
        tempseq.push_back(temp->key,temp->value);
        if(temp==tail)
            break;
        temp=temp->next;
    }
    temp = subtract.head;
    while(temp)
    {
        tempseq.removeAllOf(temp->key);
        if(temp==subtract.tail)
            break;
        temp=temp->next;
    }
    return tempseq;
}

template<typename Key, typename Value>
Ring<Key,Value>& Ring<Key,Value>::operator++()
{
    if(head)
    {
        head=head->next;
        tail=tail->next;
    }
    return *this;
}

template<typename Key, typename Value>
Ring<Key,Value> Ring<Key,Value>::operator++(int)
{
    Ring a(*this);
    if(head)
    {
        head=head->next;
        tail=tail->next;
    }
    return a;
}

template<typename Key, typename Value>
Ring<Key,Value>& Ring<Key,Value>::operator--()
{
    if(head)
    {
        head=head->prev;
        tail=tail->prev;
    }
    return *this;
}

template<typename Key, typename Value>
Ring<Key,Value> Ring<Key,Value>::operator--(int)
{
    Ring a(*this);
    if(head)
    {
        head=head->prev;
        tail=tail->prev;
    }
    return a;
}


template<typename u, typename i>
ostream & operator<<(ostream & os, const Ring<u,i> & toprint)
{
    typename Ring<u,i>::Element* temp;
    temp = toprint.head;
    while(temp)
    {
        os << "Key: " << temp->key << endl << "Value: " << temp->value << endl;
        if(temp==toprint.tail)
            break;
        temp = temp->next;
    }
    return os;
}



template<typename Key,typename Value>
void Ring<Key,Value>::clear()
{
    Element * temp;
    temp=head;
    if(tail)
        tail->next=NULL;
    while(temp)
    {
        temp = temp->next;
        delete head;
        head = temp;
    }
    head=tail=NULL;

}

template<typename Key,typename Value>
void Ring<Key,Value>::reverse()
{
    Ring<Key,Value> tempseq;
    Element * temp = head;
    while(temp)
    {
        tempseq.push_front(temp->key,temp->value);
        if(temp==tail)
            break;
        temp=temp->next;
    }
    *this=tempseq;
}

template<typename Key,typename Value>
bool Ring<Key,Value>::insertAt(unsigned int pos, const Key&key, const Value &value)
{
    if(pos>size())
        return false;

    Element * temp = head;

    for(unsigned int i = 0; i<pos; i++)
    {
        temp=temp->next;
    }

    Element * newElement;
    newElement = new Element;

    newElement->key=key;
    newElement->value=value;
    newElement->next=newElement;
    newElement->prev=newElement;

    if(!temp)
    {
        head=tail=newElement;
    }
    else
    {
        newElement->next=temp;
        newElement->prev=temp->prev;

        temp->prev->next=newElement;
        temp->prev=newElement;
    }

    if(pos==0){
        head=newElement;
   }else if(pos==size()){
        tail=newElement;
   }
    return true;
}

template<typename Key,typename Value>
bool Ring<Key,Value>::insertAfter(const Key&keypos, const Key&key, const Value &value)
{
    Element * temp = head;
    bool found = false;

    while(temp)
    {
        if(temp->key==keypos)
        {
            found=true;
            break;
        }
        if(temp==tail)
            break;
        temp=temp->next;
    }

    if(!found)
        return false;

    Element * newElement;
    newElement = new Element;
    newElement->key=key;
    newElement->value=value;

    newElement->next=temp->next;
    newElement->prev=temp;

    temp->next->prev=newElement;
    temp->next=newElement;

    if(head==tail){
        head=tail=newElement;
    }else if(temp==tail){
        tail=newElement;
    }
    return true;
}

template<typename Key,typename Value>
bool Ring<Key,Value>::insertAfter(const iterator & iter, const Key&key, const Value &value)
{
    Element * temp = head;
    bool found = false;
    iterator comp;

    while(temp)
    {
        comp=temp;
        if(comp==iter)
        {
            found=true;
            break;
        }
        if(temp==tail)
            break;
        temp=temp->next;
    }

    if(!found)
        return false;

    Element * newElement;
    newElement = new Element;
    newElement->key=key;
    newElement->value=value;

    newElement->next=temp->next;
    newElement->prev=temp;

    temp->next->prev=newElement;
    temp->next=newElement;

    if(head==tail)
        head=tail=newElement;
    else if(temp==tail)
        tail=newElement;

    return true;
}


template<typename Key, typename Value>
void Ring<Key,Value>::push_front(const Key&key, const Value &value)
{
    Element * newElement;

    newElement = new Element;
    newElement->key = key;
    newElement->value = value;

    if(head)
    {
        newElement->next = head;
        newElement->prev = tail;
        tail->next=newElement;
        head->prev=newElement;
        head=newElement;
    }
    else
    {
        newElement->next = newElement;
        newElement->prev = newElement;
        head=tail=newElement;
    }
}

template<typename Key, typename Value>
void Ring<Key,Value>::push_back(const Key&key,  const Value &value)
{
    Element * newElement;

    newElement = new Element;
    newElement->key = key;
    newElement->value = value;

    if(head)
    {
        newElement->next = head;
        newElement->prev = tail;
        tail->next=newElement;
        head->prev=newElement;
        tail=newElement;
    }
    else
    {
        newElement->next = newElement;
        newElement->prev = newElement;
        head=tail=newElement;
    }
}


template<typename Key, typename Value>
bool Ring<Key,Value>::remove(const Key&key)
{
    Element* temp = head;
    while(temp)
    {
        if(temp->key==key)
        {
            if(head==tail)
            {
                delete temp;
                head = tail = NULL;
                size--;
                return;
            }
            else
            {
                temp->next->prev=temp->prev;
                temp->prev->next=temp->next;
                size--;
                delete temp;
                return;
            }
        }
        if(temp==tail)
            break;
        temp=temp->next;
    }
}

template<typename Key, typename Value>
bool Ring<Key,Value>::remove(iterator& iter)
{
    if(iter.isNull())
        return false;
    Element* temp = head;
    iterator comp;
    while(temp)
    {
        comp = temp;
        if(comp==iter)
        {
            iter++;
            if(head==tail)
            {
                delete temp;
                head = tail = NULL;
                return true;
            }
            else
            {
                if(temp==head)
                    head=temp->next;
                else if(temp==tail)
                    tail=temp->prev;
                temp->next->prev=temp->prev;
                temp->prev->next=temp->next;
                delete temp;
                return true;
            }
        }
        if(temp==tail)
            break;
        temp=temp->next;
    }
    return false;
}

template<typename Key, typename Value>
bool Ring<Key,Value>::removeAllOf(const Key&key)
{
    Element* temp = head;
    bool deleted = false;
    while(temp)
    {
        if(temp->key==key)
        {
            deleted=true;
            if(head==tail)
            {
                delete temp;
                head = tail = NULL;
                return deleted;
            }
            else
            {
                if(temp==head)
                    head=temp->next;
                else if(temp==tail)
                    tail=temp->prev;
                temp->next->prev=temp->prev;
                temp->prev->next=temp->next;
                delete temp;
            }
        }
        if(temp==tail)
            break;
        temp=temp->next;
    }
    return deleted;
}




template<typename Key, typename Value>
bool Ring<Key,Value>::exists(const Key&key)
{
    Element * temp = head;
    while(temp)
    {
        if(temp->key==key)
            return true;
        temp=temp->next;
    }
    return false;
}


template<typename Key, typename Info>
typename Ring<Key, Info>::iterator Ring<Key, Info>::find(const Key &where) const
{
    iterator iter = begin();
    if (head != NULL)
    {
        do
        {
            if (iter.getKey() == where)
            {
                return iter;
            }
            iter++;
        }
        while (iter != begin());
    }
    return NULL;
}


template <typename Key, typename Info>
typename Ring<Key, Info>::iterator Ring<Key, Info>::findPlace(int place) const
{
    iterator iter = begin();
    int position = 0;
    if (head != NULL)
    {

        do
        {
            if (position == place)
            {
                return iter;
            }
            iter++;
            position++;
        }
        while (iter != begin());
    }
    return NULL;
}


template <typename Key, typename Info>
bool Ring<Key, Info>::findNodePlace(int place) const
{
    iterator iter = find(place);
    if (iter == NULL)
    {
        return false;
    }
    else
    {
        return true;
    }
}


#endif // BIRING_H_INCLUDED

Thanks for reading!

abstract algebra – Ring homomorphism may not preserve $1$.

Suppose $R$ is a ring with unity,and $f:Rto R’$ is a ring homomorphism.Then $f(R)$ must have a $1_{f(R)}$ .But $1_{f(R)}$ may not be the identity of $R’$.Even $R’$ may not contain any identity and suppose $R’$ contains $1_{R’}$,still the ring homomorphism may not map $1_R$ yo $1_{R’}$ necessarily.

Why does this occur.I am unable to find exactly why it is so.Can this be explained by semigroup homomorphisms or monoid homomorphisms i.e. maps from semigroup $S_1$ to $S_2$ such that $f(a.b)=f(a).f(b)$?

abstract algebra – the dimension of a quotient ring as a $mathbb{C}-$vector space

what is the dimension of the following quotient ring as a $mathbb{C}-$vector space ?

$mathbb{C}(x,frac{1}{x-x^2})/(x-x^3)$.

For any $f in mathbb{C}(x,frac{1}{x-x^2})/(x-x^3)$, $ f= frac{tilde{f}(x)}{(x-x^2)^m}$, for some

$minmathbb{N}$, and by the division algorithm, the basis is of the form

${ frac{x}{(x-x^2)^n}, frac{x^2}{(x-x^2)^n} }, ninmathbb{N}$.

neutral density – step up ring for multiple filters

I saw that there is a technique to use a square holder for nd filter and then place in it x stop filter + graduate folter.

Since it is pretty expensive I was wondering is there is something like this for circular filters where I can use 2 filters at the same time.

To be more particular Im looking for 4 stop nd with 3 stop graduate filter in front and I have sony a6500 + sigma 16mm/1.4.

Thank you!

dnd 5e – If a platinum ring is removed and then replaced do the effects of Warding Bond resume?

Warding Bond has a duration of 1 hour and has a material requirement of

a pair of platinum rings worth at least 50 gp each, which you and the target must wear for the duration

If one of the two rings is removed does the spell end or are its effects merely suppressed? If the ring is replaced within the 1 hour duration would Warding Bond need to be re-cast or would its effects resume?

iphone – disable call from mac ring

I don't know if this is the correct way to describe this or not … so here it goes:

a] I have an iPhone, a MAC + tablet.

b] It is important that you keep my mac + tablet connected with my Apple ID for other reasons.

c] I also really like the fact that I can answer my cell phone through my MAC or TABLET

d] HOWEVER … most of the time I leave my MAC + TABLET at home, and take my cell phone with me – when I am away from home – my MAC rings, and my TABLET rings – very loudly according to "who must be obeyed "

Why: Because my tablet and laptop are often plugged into charging.

This is also bad, because when I receive a "SPAM CALL", my iPhone routes it very well to voicemail, but … my tablet and MAC sound at decimal levels that break the ears.

According to "who should be obeyed", violence on my MAC + TABLET can occur if I can't fix this.

e] BUT – I don't want to LOG OUT from iCLOUD … for other reasons above – My question is this: I need some way to silence the ringer or control the volume when I'm not at home. Or possibly turn this on: when I'm actively using the computer, i.e. when it's locked, turn it off.

the only ring: what counts as being "hurt" for the purpose of rules to regain a point of Hope?

In The ring In-game, players can regain a Hope point if their Community focus is not hurt during the session. The problem is that the rules don't seem to indicate whether they signify the Wounded condition (which involves a successful edge hit with armor that doesn't beat the injury), or simply taken damage.

How to apply Saturn's ring texture in Unreal Engine 4?

I am working on a model project of the "solar system". And when trying to apply the texture of Saturn's ring, which is this:
enter the image description here

ended up looking like this:
enter the image description here

I am new to UE4 and this branch in general. So I have no idea how to fix this.
Your help would be appreciated