In Pascal's triangle each number is the sum of the two numbers directly above it, treating empty spots as zero:

By rotating the triangle, we can cut out square matrices of varying sizes and rotations which I will call Pascal's matrices. Note that those matrices always need to contain the top $1$. Here are some examples:

1  1  1  1

1  2  3  4

1  3  6 10

1  4 10 20



6  3  1

3  2  1

1  1  1



1  5 15 35 70

1  4 10 20 35

1  3  6 10 15

1  2  3  4  5

1  1  1  1  1



1



1  1

2  1

The Task

Given a square matrix containing positive numbers in any reasonable format, decide if it is a Pascal's matrix.

Decide means to either return truthy or falsy values depending on whether the input is a Pascal's matrix, or to fix two constant values and return one for the true inputs and the other for false inputs.

This is code-golf, so try to use as few bytes as possible in the language of your choice. The shortest code in each language wins, thus I will not accept an answer.

Test cases

True

[[1, 1, 1, 1], [1, 2, 3, 4], [1, 3, 6, 10], [1, 4, 10, 20]]

[[6, 3, 1], [3, 2, 1], [1, 1, 1]]

[[1, 5, 15, 35, 70], [1, 4, 10, 20, 35], [1, 3, 6, 10, 15], [1, 2, 3, 4, 5], [1, 1, 1, 1, 1]]

[[1]]

[[1, 1], [2, 1]]

False

[[2]]

[[1, 2], [2, 1]]

[[1, 1], [3, 1]]

[[1, 1, 1, 1], [1, 2, 3, 4], [1, 4, 6, 10], [1, 4, 10, 20]]

[[6, 3, 1], [1, 1, 1], [3, 2, 1]]

[[2, 2, 2, 2], [2, 4, 6, 8], [2, 6, 12, 20], [2, 8, 20, 40]] 

[[1, 5, 15, 34, 70], [1, 4, 10, 20, 34], [1, 3, 6, 10, 15], [1, 2, 3, 4, 5], [1, 1, 1, 1, 1]]

Brachylog, 28 bytes

This feels quite long but here it is anyway

-4 bytes thanks to DLosc

{|↔}↰₁{h=₁&s₂ᶠ⟨a₀ᶠ+ᵐ⟩ᵐ}

Explanation

{|↔}↰₁{h=₁&s₂ᶠ⟨a₀ᶠ+ᵐ⟩ᵐ}       # Tests if this is a pascal matrix:

{|↔}↰₁                       #     By trying to get a rows of 1's on top

{|↔}                          #       Through optionally mirroring vertically

                             #       Transposing

      ↰₁                      #       Through optionally mirroring vertically



       {h=₁&s₂ᶠ⟨a₀ᶠ+ᵐ⟩ᵐ}       #     and checking the following

        h=₁                   #        first row is a rows of 1's

            s₂ᶠ               #        and for each 2 rows which follow each other

               ⟨a₀ᶠ+ᵐ⟩ᵐ        #          the 2nd is the partial sums of the 1st

                a₀ᶠ           #             take all prefixes of the 1st

                   +ᵐ         #             which if summed are the 2nd

Try it online!

Charcoal, 41 bytes

Ｆ‹¹⌈§θ⁰≔⮌θθＦ‹¹⌈Ｅθ§ι⁰≦⮌θ⌊⭆θ⭆ι⁼λ∨¬κΣ…§θ⊖κ⊕μ

Try it online! Link is to verbose version of code. Explanation:

Ｆ‹¹⌈§θ⁰

If the minimum of its first row is greater than 1,

≔⮌θθ

then flip the input array.

Ｆ‹¹⌈Ｅθ§ι⁰

If the minimum of its first column is greater than 1,

≦⮌θ

then mirror the input array.

⌊⭆θ⭆ι

Loop over the elements of the input array and print the minimum result (i.e. the logical And of all of the results),

⁼λ∨¬κΣ…§θ⊖κ⊕μ

comparing each value to 1 if it is on the first row otherwise the sum of the row above up to and including the cell above.

JavaScript (ES6), 114 bytes

m=>[m,m,m=m.map(r=>[...r].reverse()),m].some(m=>m.reverse(p=[1]).every(r=>p=!r.some((v,x)=>v-~~p[x]-~~r[x-1])&&r))

Try it online!