xkb mapping of R_Control+Arrows

You need to add a function wrapper as follows.

default  partial alphanumeric_keys modifier_keys
xkb_symbols "custom" {

key <UP> {  
    type= "PC_CONTROL_LEVEL2",  
    symbols[Group1]= [ Up, NoSymbol ],  
    actions[Group1] = [NoAction(), RedirectKey(key=<PGUP>, clearMods=Control)] };  
key <DOWN> {  
    type= "PC_CONTROL_LEVEL2",  
    symbols[Group1]= [ Down, NoSymbol ],  
    actions[Group1] = [NoAction(), RedirectKey(key=<PGDN>, clearMods=Control)] };  
key <LEFT> {  
    type= "PC_CONTROL_LEVEL2",  
    symbols[Group1]=  [ Left, NoSymbol ],  
    actions[Group1] = [NoAction(), RedirectKey(key=<PGUP>)] };  
key <RGHT> {   
    type= "PC_CONTROL_LEVEL2",  
    symbols[Group1]= [ Right, NoSymbol ],  
    actions[Group1] = [NoAction(), RedirectKey(key=<PGDN>)] };
};

There are two issues here. I will discuss them first and then give three solutions, all of which work in my tests.

Issue A: The "dangling virtual modifier" bug in xkb configs.

Notice that type "PC_RCONTROL_LEVEL2" (defined in /usr/share/X11/xkb/types/pc) uses the virtual modifier RControl. For the virtual modifier RControl to do what we expect, it should be associated with the actual keysym Control_R via an interpret stanza in /usr/share/X11/xkb/compat/pc. But the virtual modifier RControl is not associated with any keysym at all, and in fact it is not set up in any way in the compatibility configs: grep RControl /usr/share/X11/xkb/compat/* returns nothing. This is why you are finding that PC_RCONTROL_LEVEL2 has no effect, and this can be considered to be a "dangling RControl config bug" in xkb. (This issue does not affect the type PC_CONTROL_LEVEL2 because that type does not use any virtual modifier - it uses the real modifier Control.)

Issue B: Need a separate real modifier bit for right control, distinct from the Control modifier bit.

The symbols config file /usr/share/X11/xkb/symbols/pc contains:

modifier_map Control { Control_L, Control_R };

As the left and right control keys are both configured by default to set the Control modifier bit, they will behave identically unless explicitly bound to distinct modifier bits via separate modifier maps. Here we of course need the right control key to act as a different modifier than the left control key. This can be done, e.g., by changing the right control key's modifier bit (Control) to a different available modifier bit, say Mod3 (Mod3 is not bound to any key in the default xkb configs).

Here are three ways to address these two issues.

Solution 1: Fix the dangling virtual modifier issue for RControl.

The workaround below achieves your desired setup (in my tests).

First, include the following in your xkb compatibility configs to interpret the Control_R keysym as the virtual modifier RControl:

partial default xkb_compatibility "rctrlinterpret" {

  virtual_modifiers RControl;

  interpret Control_R+Any {
    virtualModifier = RControl;
    useModMapMods= level1;
    action= SetMods(modifiers=RControl, clearLocks);
  };

  interpret Control_R {
    virtualModifier = RControl;
    action= SetMods(modifiers=RControl, clearLocks);
  };

};

(E.g., you can save the above to a file, say rctrlfix, and then within xkb_compat { ... }, change the include "complete" to include "complete+rctrlfix".)

Next, separate the modifier map for the right control key. Since its existing modifier map in the default config uses the keysym Control_R, you will need to use the keysym Control_R when replacing the modifier map; using the key <RCTL> will not work. You will also need to manually clear and set desired modifier bits in your key emulations. So include the following in your symbols configs:

partial alphanumeric_keys modifier_keys
xkb_symbols "rctrlarrows" {

    replace key <RCTL> { [ Control_R ] };    // The default, anyway

    // Bind to modifier Mod3 (instead of existing default Control)
    replace modifier_map none { Control_R };
    replace modifier_map Mod3 { <RCTL> };

    key <UP> {
        type = "PC_RCONTROL_LEVEL2",
        symbols = [ Up, NoSymbol ],
        actions = [ NoAction(),
                        RedirectKey(
                            key=<PGUP>,
                            clearMods=RControl
                        )]
    };

    key <DOWN> {
        type = "PC_RCONTROL_LEVEL2",
        symbols = [ Down, NoSymbol ],
        actions = [ NoAction(),
                        RedirectKey(
                            key=<PGDN>,
                            clearMods=RControl
                        )]
    };

    key <LEFT> {
        type= "PC_RCONTROL_LEVEL2",
        symbols = [ Left, NoSymbol ],
        actions = [ NoAction(),
                        RedirectKey(
                            key=<PGUP>,
                            clearMods=RControl,
                            Modifiers=Control
                    )]
    };


    key <RGHT> {
        type= "PC_RCONTROL_LEVEL2",
        symbols = [ Right, NoSymbol ],
        actions = [ NoAction(),
                        RedirectKey(
                            key=<PGDN>,
                            clearMods=RControl,
                            Modifiers=Control
                        )]
    };

};

As the modifier map for Control_R is being defined a second time, there can be a error message saying that, but it seems harmless.

A variant of Solution 1 would be to ditch the keysym Control_R altogether, and use a spare keysym in its place that is not a modifier and not used in the compatibility configs (e.g. Pause), and interpret it as the virtual modifier RControl in the compatibility configs. That is, replace Control_R by Pause throughout in the above configs. This would also avoid the multiple modifier map error message.

Alternative workarounds.

Solution 2: Bypass the dangling virtual modifier issue by using a type based on a real modifier (Mod3).

If the symbols configs are customized as above with Mod3 being the real modifier bit for the keysym Control_R (key <RCTL>), then the same result can be achieved by modifying the types configs (instead of modifying the compatibility configs, which can be left untouched): In the type definition of PC_RCONTROL_LEVEL2, replace the virtual modifier RControl by the real modifier Mod3. (You may want to put this in a new type, and in your key emulations change the type names accordingly.)

Solution 3: Re-define <RCTL> as the level 3 shifter keysym ISO_Level3_Shift.

Still another workaround (without need to touch either the compatibility configs or the types configs) would be to re-define the <RCTL> key as the Level3 modifier keysym ISO_Level3_Shift (instead of Control_R). Then define your desired key emulations using type = "THREE_LEVEL" and with symbol/action values defined at the third level (instead of the second level). This will work as expected, since (a) the default xkb symbols configs define a "fake" key <LVL3> as the keysym ISO_Level3_Shift with the real modifier bit Mod5 bound to it via a modifier map, (b) the default xkb types configs define the type THREE_LEVEL's level 3 shifting using the virtual modifier LevelThree, and (c) the default xkb compatibility configs interpret the keysym ISO_Level3_Shift as the virtual modifier LevelThree, so there is no dangling virtual modifier issue.

partial alphanumeric_keys modifier_keys
xkb_symbols "rctrlarrows" {

    replace key <RCTL> {
        type[Group1] = "ONE_LEVEL",
        symbols[Group1] = [ ISO_Level3_Shift ]
    };
    // Keysym ISO_Level3_Shift is bound to the real modifier bit Mod5
    // in the xkb default configs in symbols/pc (via key <LVL3>)

    key <UP>  { 
        type    =   "THREE_LEVEL",
        symbols =   [ NoSymbol, NoSymbol, NoSymbol ],
        actions =   [ NoAction(), NoAction(),
                        RedirectKey(keycode=<PGUP>,
                            clearmods=LevelThree)
                    ]
    };

    key <DOWN>  {
        type    =   "THREE_LEVEL",
        symbols =   [ NoSymbol, NoSymbol, NoSymbol ],
        actions =   [ NoAction(), NoAction(),
                        RedirectKey(keycode=<PGDN>,
                            clearmods=LevelThree)
                    ]
    };

    key <LEFT>  {
        type    =   "THREE_LEVEL",
        symbols =   [ NoSymbol, NoSymbol, NoSymbol ],
        actions =   [ NoAction(), NoAction(), 
                        RedirectKey(keycode=<PGUP>,
                            modifiers=Control, clearmods=LevelThree)
                    ]
    };

    key <RGHT>  {
        type    =   "THREE_LEVEL",
        symbols =   [ NoSymbol, NoSymbol, NoSymbol ],
        actions =   [ NoAction(), NoAction(),
                        RedirectKey(keycode=<PGDN>,
                            modifiers=Control, clearmods=LevelThree)
                    ]
    };

};