The if keyword means that, if the result of the value schema passes validation, apply the then schema, otherwise apply the else schema.

Your schema didn't work because you needed to require "foo" in your if schema, otherwise an empty JSON instance would pass validation of the if schema, and therefore apply the then schema, which requires "bar".

Second, you want "propertyNames":false, which prevents having any keys in the schema, unlike if you were to set "else": false which would make anything always fail validation.

{
  "type": "object",
  "properties": {
    "foo": {
      "type": "string"
    },
    "bar": {
      "type": "string"
    }
  },
  "if": {
    "properties": {
      "foo": {
        "enum": [
          "bar"
        ]
      }
    },
    "required": [
      "foo"
    ]
  },
  "then": {
    "required": [
      "bar"
    ]
  },
  "else": false
}

I do not fully understand the intention of your original schema, but how about this one?

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "type": "object",
    "properties": {
        "previous_employment_section": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "companyAddress": {
                        "type": "string"
                    },
                    "companyName": {
                        "type": "string"
                    }
                }
            }
        },
        "isInexperienced": {
            "type": "boolean"
        }
    },
    "if": {
        "properties": {
            "isInexperienced": {
                "const": false
            }
        }
    },
    "then": {
        "properties": {
            "previous_employment_section": {
                "items": {
                    "required": [
                        "companyName",
                        "companyAddress"
                    ]
                },
                "minItems": 1
            }
        }
    }
}

Try this:

{
  "if":{
    "type":"object",
    "properties":{
      "i0":{
        "type":"object",
        "properties":{
          "j0":{
            "type":"object",
            "required":["a0"]
          }
        },
        "required":["j0"]
      }
    },
    "required":["i0"]
  },
  "then":{
    "type":"object",
    "properties":{
      "i1":{
        "type":"object",
        "properties":{
          "j1":{
            "type":"object",
            "required":["a1"]
          }
        },
        "required":["j1"]
      }
    },
    "required":["i1"]
  }
}

You have to use the overall structure within the if/then keywords, starting with whatever common root they have. In this case, their paths begin to diverge at the i0/i1 property, so you have to include the entire structure from that point.

The type keywords ensure that you have an object, otherwise the schema could pass validation when other types, like strings or booleans, are used.

The required keywords ensure that the if/then subschemas only match on objects which actually contain the i0.j0.a0/i1.j1.a1 property paths, respectively.

Additionally, the required keywords for the a0/`a1 properties only specify that they exist. You can add more validation to that subschema if you need it.