EF Can't update one-to-zero or one relationship fields, but updates the rest

Am trying to make an update on the database with one-to-one relationship models, but only the Student model fields are the only ones working. How can I make the rest update too?

This is my Repository method for updating :

 public void Edit(Student student)
        {
            var existingStudent = _context.Students
                .Include(e => e.Education)
                .Include(s => s.Siblings)
                .Include(p => p.Parents)
                .Include(g => g.Guardian)
                .Single(s => s.Id == student.Id);

            if (existingStudent != null)
            {
                // do some updating.
                _context.Attach(existingStudent);
                _context.Entry(existingStudent).CurrentValues.SetValues(student);
                _context.Entry(existingStudent).State = EntityState.Modified;
                _context.SaveChanges();

            }


        }

Then, this is my Student model class :

public class Student
    {
        [Key]
        public long Id { get; set; }
        [Display(Name="First Name")]
        public string FirstName { get; set; }
        [Display(Name="Middle Name")]
        public string MiddleName { get; set; }
        [Display(Name="Last Name")]
        public string LastName { get; set; }
        [Display(Name="Nationality")]
        public string Nationality { get; set; }
        [Display(Name="Gender")]
        public string Gender { get; set; }
        [Display(Name="Religion")]
        public string Religion { get; set; }
        [Display(Name="Medical Condition")]
        public string MedicalCondition { get; set; }
        [Display(Name="Deceased")]
        public string Deceased { get; set; }
        [Display(Name="Home Address")]
        public string HomeAddress { get; set; }
        [Display(Name="Country Of Residence")]
        public string CountryOfResidence { get; set; }
        [Display(Name="City")]
        public string City { get; set; }
        [Display(Name="Date Of Birth")]
        public DateTime DateOfBirth { get; set; }
        public int Age { get; set; }
        public virtual Parents Parents { get; set; }
        public virtual Education Education { get; set; }
        public virtual Guardian Guardian { get; set; }
        public virtual Siblings Siblings { get; set; }
    }

Then one of the one-to-one relationship classes is as below :

public class Siblings
    {
        public long Id { get; set; }
        [Display(Name="Number of Brothers")]
        public int NumberOfBrothers { get; set; }
        [Display(Name="Number of Sisters")]
        public int NumberOfSisters { get; set; }

        public Student Student { get; set; }

        public  long? StudentId { get; set; }
    }

The rest of the related model classes Parents, Education, Guardian are the same as Siblings.

How can I be able to ensure that the update cuts across all the fields. Thanks.

EDIT

This is what I have in OnModelCreating() :

protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);

            builder.Entity<Student>()
                .HasOne(e => e.Education)
                .WithOne(s => s.Student)
                ;


            builder.Entity<Student>()
                .HasOne(g => g.Guardian)
                .WithOne(s => s.Student);

            builder.Entity<Student>()
                .HasOne(p => p.Parents)
                .WithOne(s => s.Student);

            builder.Entity<Student>()
                .HasOne(s => s.Siblings)
                .WithOne(s => s.Student);


            builder.Entity<Education>()
                .HasOne(s => s.Student)
                .WithOne(e => e.Education);
            builder.Entity<Guardian>()
                .HasOne(s => s.Student)
                .WithOne(g => g.Guardian);

            builder.Entity<Parents>()
                .HasOne(s => s.Student)
                .WithOne(p => p.Parents);

            builder.Entity<Siblings>()
                .HasOne(s => s.Student)
                .WithOne(p => p.Siblings);


}