Documentation

Auto.Embedding.LCtx

@[reducible]
def Auto.Embedding.mapAt (pos : Nat) (f : Nat → Nat) (n : Nat) :
Equations
Instances For
    theorem Auto.Embedding.mapAt_id_eq_id' (pos : Nat) :
    (mapAt pos fun (x : Nat) => x) = id
    theorem Auto.Embedding.mapAt_zero (f : Nat → Nat) :
    mapAt 0 f = f
    theorem Auto.Embedding.mapAt_succ_zero (pos : Nat) (f : Nat → Nat) :
    mapAt pos.succ f 0 = 0
    theorem Auto.Embedding.mapAt_succ_succ (pos : Nat) (f : Nat → Nat) (n : Nat) :
    mapAt pos.succ f n.succ = (mapAt pos f n).succ
    theorem Auto.Embedding.mapAt_comp (pos : Nat) (g f : Nat → Nat) (n : Nat) :
    mapAt pos (fun (x : Nat) => g (f x)) n = mapAt pos g (mapAt pos f n)
    @[reducible]
    def Auto.Embedding.restoreAt {α : Sort u_1} (pos : Nat) (restore : (Nat → α) → Nat → α) (lctx : Nat → α) (n : Nat) :
    α
    Equations
    Instances For
      theorem Auto.Embedding.restoreAt_zero {α : Sort u_1} (restore : (Nat → α) → Nat → α) :
      restoreAt 0 restore = restore
      theorem Auto.Embedding.restoreAt_succ_succ {α : Sort u_1} (pos : Nat) (restore : (Nat → α) → Nat → α) (lctx : Nat → α) (n : Nat) :
      restoreAt pos.succ restore lctx n.succ = restoreAt pos restore (fun (n : Nat) => lctx n.succ) n
      theorem Auto.Embedding.restoreAt_succ_succ_Fn {α : Sort u_1} (pos : Nat) (restore : (Nat → α) → Nat → α) (lctx : Nat → α) :
      (fun (n : Nat) => restoreAt pos.succ restore lctx n.succ) = restoreAt pos restore fun (n : Nat) => lctx n.succ
      def Auto.Embedding.coPair {α : Sort u_1} (f : Nat → Nat) (restore : (Nat → α) → Nat → α) :
      Equations
      Instances For
        def Auto.Embedding.coPairAt {α : Sort u_1} (f : Nat → Nat) (restore : (Nat → α) → Nat → α) :
        Equations
        Instances For
          theorem Auto.Embedding.coPairAt.ofcoPair {f : Nat → Nat} {α✝ : Sort u_1} {restore : (Nat → α✝) → Nat → α✝} (cp : coPair f restore) :
          coPairAt f restore
          def Auto.Embedding.contraPair {α : Sort u_1} (f : Nat → Nat) (cstr : (Nat → α) → Prop) (restore : (Nat → α) → Nat → α) :
          Equations
          Instances For
            def Auto.Embedding.contraPairAt {α : Sort u_1} (f : Nat → Nat) (cstr : (Nat → α) → Prop) (restore : (Nat → α) → Nat → α) :
            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              theorem Auto.Embedding.contraPairAt.ofContraPair {f : Nat → Nat} {α✝ : Sort u_1} {cstr : (Nat → α✝) → Prop} {restore : (Nat → α✝) → Nat → α✝} (cp : contraPair f cstr restore) :
              contraPairAt f cstr restore
              def Auto.Embedding.restoreAtDep {α : Sort u_1} {lctxty : α → Sort u} (pos : Nat) {restore : (Nat → α) → Nat → α} (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
              lctxty (restoreAt pos restore rty n)
              Equations
              Instances For
                theorem Auto.Embedding.restoreAtDep_zero {α : Sort u_1} {lctxty : α → Sort u} {restore : (Nat → α) → Nat → α} (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                restoreAtDep 0 (fun {rty : Nat → α} => restoreDep) lctx ≍ restoreDep lctx
                theorem Auto.Embedding.restoreAtDep_succ_succ {α : Sort u_1} {lctxty : α → Sort u} (pos : Nat) {restore : (Nat → α) → Nat → α} (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                restoreAtDep pos.succ (fun {rty : Nat → α} => restoreDep) lctx n.succ ≍ restoreAtDep pos (fun {rty : Nat → α} => restoreDep) (fun (n : Nat) => lctx n.succ) n
                theorem Auto.Embedding.restoreAtDep_succ_succ_Fn {α : Sort u_1} {lctxty : α → Sort u} (pos : Nat) {restore : (Nat → α) → Nat → α} (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                (fun (n : Nat) => restoreAtDep pos.succ (fun {rty : Nat → α} => restoreDep) lctx n.succ) ≍ restoreAtDep pos (fun {rty : Nat → α} => restoreDep) fun (n : Nat) => lctx n.succ
                def Auto.Embedding.coPairDep {α : Sort u_1} (lctxty : α → Sort u) (f : Nat → Nat) (restore : (Nat → α) → Nat → α) (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) :
                Equations
                Instances For
                  def Auto.Embedding.coPairDepAt {α : Sort u_1} (lctxty : α → Sort u) (f : Nat → Nat) (restore : (Nat → α) → Nat → α) (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) :
                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    theorem Auto.Embedding.coPairDepAt.ofCoPairDep {α✝ : Sort u_1} {lctxty : α✝ → Sort u_2} {f : Nat → Nat} {restore : (Nat → α✝) → Nat → α✝} {restoreDep : {rty : Nat → α✝} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)} (cpd : coPairDep lctxty f restore restoreDep) :
                    coPairDepAt lctxty f restore fun {rty : Nat → α✝} => restoreDep
                    def Auto.Embedding.contraPairDep {α : Sort u_1} (lctxty : α → Sort u) (f : Nat → Nat) (cstr : (Nat → α) → Prop) (restore : (Nat → α) → Nat → α) (cstrDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → Prop) (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) :
                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      def Auto.Embedding.contraPairDepAt {α : Sort u_1} (lctxty : α → Sort u) (f : Nat → Nat) (cstr : (Nat → α) → Prop) (restore : (Nat → α) → Nat → α) (cstrDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → Prop) (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) :
                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        theorem Auto.Embedding.contraPairDep.ofContraPairDep {α✝ : Sort u_1} {lctxty : α✝ → Sort u_2} {f : Nat → Nat} {cstr : (Nat → α✝) → Prop} {restore : (Nat → α✝) → Nat → α✝} {cstrDep : {rty : Nat → α✝} → ((n : Nat) → lctxty (rty n)) → Prop} {restoreDep : {rty : Nat → α✝} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)} (cpd : contraPairDep lctxty f cstr restore cstrDep restoreDep) :
                        contraPairDepAt lctxty f cstr restore (fun {rty : Nat → α✝} => cstrDep) fun {rty : Nat → α✝} => restoreDep
                        @[reducible]
                        def Auto.Embedding.pushLCtx {α : Sort u_1} (x : α) (lctx : Nat → α) (n : Nat) :
                        α
                        Equations
                        Instances For
                          @[reducible]
                          def Auto.Embedding.pushLCtxAt {α : Sort u_1} (x : α) (pos : Nat) (lctx : Nat → α) (n : Nat) :
                          α
                          Equations
                          Instances For
                            theorem Auto.Embedding.pushLCtxAt_lt {α : Sort u_1} {lctx : Nat → α} (x : α) (pos n : Nat) (hlt : n < pos) :
                            pushLCtxAt x pos lctx n = lctx n
                            theorem Auto.Embedding.pushLCtxAt_eq {α : Sort u_1} {lctx : Nat → α} (x : α) (pos : Nat) :
                            pushLCtxAt x pos lctx pos = x
                            theorem Auto.Embedding.pushLCtxAt_gt {α : Sort u_1} {lctx : Nat → α} (x : α) (pos n : Nat) (hle : n > pos) :
                            pushLCtxAt x pos lctx n = lctx n.pred
                            theorem Auto.Embedding.pushLCtxAt_succ_zero {α : Sort u_1} (x : α) (pos : Nat) (lctx : Nat → α) :
                            pushLCtxAt x pos.succ lctx 0 = lctx 0
                            theorem Auto.Embedding.pushLCtxAt_succ_succ {α : Sort u_1} (x : α) (pos : Nat) (lctx : Nat → α) (n : Nat) :
                            pushLCtxAt x pos.succ lctx n.succ = pushLCtxAt x pos (fun (n : Nat) => lctx n.succ) n
                            theorem Auto.Embedding.pushLCtxAt_succ_succ_Fn {α : Sort u_1} (x : α) (pos : Nat) (lctx : Nat → α) :
                            (fun (n : Nat) => pushLCtxAt x pos.succ lctx n.succ) = pushLCtxAt x pos fun (n : Nat) => lctx n.succ
                            theorem Auto.Embedding.pushLCtxAt_comm {α : Sort u_1} {β : Sort u_2} (f : α → β) (x : α) (pos : Nat) (lctx : Nat → α) (n : Nat) :
                            f (pushLCtxAt x pos lctx n) = pushLCtxAt (f x) pos (f ∘ lctx) n
                            theorem Auto.Embedding.pushLCtxAt_commFn {α : Sort u_1} {β : Sort u_2} (f : α → β) (x : α) (pos : Nat) (lctx : Nat → α) :
                            (fun (n : Nat) => f (pushLCtxAt x pos lctx n)) = fun (n : Nat) => pushLCtxAt (f x) pos (fun (n : Nat) => f (lctx n)) n
                            @[reducible]
                            def Auto.Embedding.pushLCtxDep {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                            lctxty (pushLCtx xty rty n)
                            Equations
                            Instances For
                              theorem Auto.Embedding.pushLCtxDep_heq {α₁ α₂ : Sort u_1} {lctxty₁ : α₁ → Sort u} {ty₁ : α₁} (x₁ : lctxty₁ ty₁) (rty₁ : Nat → α₁) (lctx₁ : (n : Nat) → lctxty₁ (rty₁ n)) {lctxty₂ : α₂ → Sort u} {ty₂ : α₂} (x₂ : lctxty₂ ty₂) (rty₂ : Nat → α₂) (lctx₂ : (n : Nat) → lctxty₂ (rty₂ n)) (h₁ : α₁ = α₂) (h₂ : lctxty₁ ≍ lctxty₂) (h₃ : ty₁ ≍ ty₂) (h₄ : x₁ ≍ x₂) (h₅ : rty₁ ≍ rty₂) (h₆ : lctx₁ ≍ lctx₂) :
                              pushLCtxDep x₁ lctx₁ ≍ pushLCtxDep x₂ lctx₂
                              theorem Auto.Embedding.pushLCtxDep_substLCtx {α : Sort u_1} {lctxty : α → Sort u} {ty : α} (x : lctxty ty) {rty₁ : Nat → α} (lctx₁ : (n : Nat) → lctxty (rty₁ n)) {rty₂ : Nat → α} (lctx₂ : (n : Nat) → lctxty (rty₂ n)) (h₁ : rty₁ = rty₂) (h₂ : lctx₁ ≍ lctx₂) :
                              pushLCtxDep x lctx₁ ≍ pushLCtxDep x lctx₂
                              theorem Auto.Embedding.pushLCtxDep_substx {α : Sort u_1} {lctxty : α → Sort u} {ty₁ : α} (x₁ : lctxty ty₁) {ty₂ : α} (x₂ : lctxty ty₂) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (h₁ : ty₁ = ty₂) (h₂ : x₁ ≍ x₂) :
                              pushLCtxDep x₁ lctx ≍ pushLCtxDep x₂ lctx
                              def Auto.Embedding.pushLCtxAtDep {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) (pos : Nat) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                              lctxty (pushLCtxAt xty pos rty n)
                              Equations
                              Instances For
                                theorem Auto.Embedding.pushLCtxAtDep_heq {α₁ α₂ : Sort u_1} {lctxty₁ : α₁ → Sort u} {ty₁ : α₁} (x₁ : lctxty₁ ty₁) (pos₁ : Nat) (rty₁ : Nat → α₁) (lctx₁ : (n : Nat) → lctxty₁ (rty₁ n)) {lctxty₂ : α₂ → Sort u} {ty₂ : α₂} (x₂ : lctxty₂ ty₂) (pos₂ : Nat) (rty₂ : Nat → α₂) (lctx₂ : (n : Nat) → lctxty₂ (rty₂ n)) (h₁ : α₁ = α₂) (h₂ : lctxty₁ ≍ lctxty₂) (h₃ : ty₁ ≍ ty₂) (h₄ : x₁ ≍ x₂) (h₅ : pos₁ = pos₂) (h₆ : rty₁ ≍ rty₂) (h₇ : lctx₁ ≍ lctx₂) :
                                pushLCtxAtDep x₁ pos₁ lctx₁ ≍ pushLCtxAtDep x₂ pos₂ lctx₂
                                theorem Auto.Embedding.pushLCtxAtDep_substLCtx {α : Sort u_1} {lctxty : α → Sort u} {ty : α} (x : lctxty ty) (pos : Nat) {rty₁ : Nat → α} (lctx₁ : (n : Nat) → lctxty (rty₁ n)) {rty₂ : Nat → α} (lctx₂ : (n : Nat) → lctxty (rty₂ n)) (h₁ : rty₁ = rty₂) (h₂ : lctx₁ ≍ lctx₂) :
                                pushLCtxAtDep x pos lctx₁ ≍ pushLCtxAtDep x pos lctx₂
                                theorem Auto.Embedding.pushLCtxAtDep_substx {α : Sort u_1} {lctxty : α → Sort u} {ty₁ : α} (x₁ : lctxty ty₁) {ty₂ : α} (x₂ : lctxty ty₂) (pos : Nat) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (h₁ : ty₁ = ty₂) (h₂ : x₁ ≍ x₂) :
                                pushLCtxAtDep x₁ pos lctx ≍ pushLCtxAtDep x₂ pos lctx
                                theorem Auto.Embedding.pushLCtxAtDep_zero {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                pushLCtxAtDep x 0 lctx ≍ pushLCtxDep x lctx
                                theorem Auto.Embedding.pushLCtxAtDep_succ_zero {α : Sort u_1} {rty : Nat → α} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) (pos : Nat) (lctx : (n : Nat) → lctxty (rty n)) :
                                pushLCtxAtDep x pos.succ lctx 0 = lctx 0
                                theorem Auto.Embedding.pushLCtxAtDep_succ_succ {α : Sort u_1} {rty : Nat → α} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) (pos : Nat) (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                pushLCtxAtDep x pos.succ lctx n.succ ≍ pushLCtxAtDep x pos (fun (n : Nat) => lctx n.succ) n
                                theorem Auto.Embedding.pushLCtxAtDep_succ_succ_Fn {α : Sort u_1} {rty : Nat → α} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) (pos : Nat) (lctx : (n : Nat) → lctxty (rty n)) :
                                (fun (n : Nat) => pushLCtxAtDep x pos.succ lctx n.succ) ≍ pushLCtxAtDep x pos fun (n : Nat) => lctx n.succ
                                def Auto.Embedding.pushLCtxAtDep_comm {α : Sort w} {β : α → Sort x} {rty : Nat → α} {lctxty : α → Sort u} (f : (x : α) → lctxty x → β x) {xty : α} (x : lctxty xty) (pos : Nat) (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                f (pushLCtxAt xty pos rty n) (pushLCtxAtDep x pos lctx n) = pushLCtxAtDep (f xty x) pos (fun (n : Nat) => f (rty n) (lctx n)) n
                                Equations
                                • ⋯ = ⋯
                                Instances For
                                  def Auto.Embedding.pushLCtxAtDep.nonDep {α : Sort u_1} {rty : Nat → α} {lctxty : Sort u} {xty : α} (x : lctxty) (pos : Nat) (lctx : Nat → lctxty) (n : Nat) :
                                  pushLCtxAtDep x pos lctx n = pushLCtxAt x pos lctx n
                                  Equations
                                  • ⋯ = ⋯
                                  Instances For
                                    def Auto.Embedding.pushLCtxAtDep_absorbAux {α : Sort u_1} {rty : Nat → α} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) (pos : Nat) (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                    pushLCtxAtDep x pos lctx n ≍ pushLCtxAtDep x pos lctx n
                                    Equations
                                    • ⋯ = ⋯
                                    Instances For
                                      theorem Auto.Embedding.pushLCtxAtDep_absorb {α : Sort u_1} {rty : Nat → α} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) (pos : Nat) (lctx : (n : Nat) → lctxty (rty n)) :
                                      pushLCtxAtDep x pos lctx ≍ pushLCtxAtDep x pos lctx
                                      theorem Auto.Embedding.pushLCtx_zero {α : Sort u_1} (x : α) (lctx : Nat → α) :
                                      pushLCtx x lctx 0 = x
                                      theorem Auto.Embedding.pushLCtx_succ {α : Sort u_1} (x : α) (lctx : Nat → α) (n : Nat) :
                                      pushLCtx x lctx n.succ = lctx n
                                      theorem Auto.Embedding.pushLCtx_succ_Fn {α : Sort u_1} (x : α) (lctx : Nat → α) :
                                      (fun (n : Nat) => pushLCtx x lctx n.succ) = lctx
                                      theorem Auto.Embedding.pushLCtx_comm {α : Sort u_1} {β : Sort u_2} (f : α → β) (x : α) (lctx : Nat → α) (n : Nat) :
                                      f (pushLCtx x lctx n) = pushLCtx (f x) (fun (n : Nat) => f (lctx n)) n
                                      theorem Auto.Embedding.pushLCtx_commFn {α : Sort u_1} {β : Sort u_2} (f : α → β) (x : α) (lctx : Nat → α) :
                                      (fun (n : Nat) => f (pushLCtx x lctx n)) = fun (n : Nat) => pushLCtx (f x) (fun (n : Nat) => f (lctx n)) n
                                      theorem Auto.Embedding.pushLCtx_pushLCtxAt {α : Sort u_1} (x y : α) (pos : Nat) (lctx : Nat → α) :
                                      pushLCtx y (pushLCtxAt x pos lctx) = pushLCtxAt x pos.succ (pushLCtx y lctx)
                                      theorem Auto.Embedding.pushLCtxDep_zero {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                      pushLCtxDep x lctx 0 = x
                                      theorem Auto.Embedding.pushLCtxDep_succ {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                      pushLCtxDep x lctx n.succ = lctx n
                                      theorem Auto.Embedding.pushLCtxDep_succ_Fn {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                      (fun (n : Nat) => pushLCtxDep x lctx n.succ) = lctx
                                      theorem Auto.Embedding.pushLCtxDep_comm {α : Sort w} {β : α → Sort x} {rty : Nat → α} {lctxty : α → Sort u} (f : (x : α) → lctxty x → β x) (lctx : (n : Nat) → lctxty (rty n)) {xty : α} (x : lctxty xty) (n : Nat) :
                                      f (pushLCtx xty rty n) (pushLCtxDep x lctx n) = pushLCtxDep (f xty x) (fun (n : Nat) => f (rty n) (lctx n)) n
                                      theorem Auto.Embedding.pushLCtx_commDep {α : Sort u_1} {n : Nat} {β : α → Sort x} {x : α} {lctx : Nat → α} (f : (x : α) → β x) :
                                      f (pushLCtx x lctx n) ≍ pushLCtxDep (f x) (fun (n : Nat) => f (lctx n)) n
                                      theorem Auto.Embedding.pushLCtxDep_absorbAux {α : Sort u_1} {rty : Nat → α} {lctxty : α → Sort u} (lctx : (n : Nat) → lctxty (rty n)) {xty : α} (x : lctxty xty) (n : Nat) :
                                      pushLCtxDep x lctx n ≍ pushLCtxDep x lctx n
                                      theorem Auto.Embedding.pushLCtxDep_absorb {α : Sort u_1} {rty : Nat → α} {lctxty : α → Sort u} (lctx : (n : Nat) → lctxty (rty n)) {xty : α} (x : lctxty xty) :
                                      theorem Auto.Embedding.pushLCtxDep_pushLCtxAtDep {α : Sort u_1} {rty : Nat → α} {lctxty : α → Sort u} (lctx : (n : Nat) → lctxty (rty n)) {xty : α} (x : lctxty xty) {yty : α} (y : lctxty yty) (pos : Nat) :
                                      @[reducible]
                                      def Auto.Embedding.pushLCtxs {α : Type u_1} (xs : List α) (lctx : Nat → α) (n : Nat) :
                                      α
                                      Equations
                                      Instances For
                                        theorem Auto.Embedding.pushLCtxs_lt {n : Nat} {α✝ : Type u_1} {xs : List α✝} {lctx : Nat → α✝} (h : n < xs.length) :
                                        pushLCtxs xs lctx n = xs.getD n (lctx 0)
                                        theorem Auto.Embedding.pushLCtxs_ge {n : Nat} {α✝ : Type u_1} {xs : List α✝} {lctx : Nat → α✝} (h : n ≥ xs.length) :
                                        pushLCtxs xs lctx n = lctx (n - xs.length)
                                        theorem Auto.Embedding.pushLCtxs_nil {α : Type u_1} (lctx : Nat → α) :
                                        pushLCtxs [] lctx = lctx
                                        theorem Auto.Embedding.pushLCtxs_cons {α : Type u_1} {x : α} (xs : List α) (lctx : Nat → α) :
                                        pushLCtxs (x :: xs) lctx = pushLCtx x (pushLCtxs xs lctx)
                                        theorem Auto.Embedding.pushLCtxs_append {α : Type u_1} (xs ys : List α) (lctx : Nat → α) :
                                        pushLCtxs (xs ++ ys) lctx = pushLCtxs xs (pushLCtxs ys lctx)
                                        theorem Auto.Embedding.pushLCtxs_singleton {α : Type u_1} (x : α) (lctx : Nat → α) :
                                        pushLCtxs [x] lctx = pushLCtx x lctx
                                        theorem Auto.Embedding.pushLCtxs_append_singleton {α : Type u_1} (xs : List α) (x : α) (lctx : Nat → α) :
                                        pushLCtxs (xs ++ [x]) lctx = pushLCtxs xs (pushLCtx x lctx)
                                        theorem Auto.Embedding.pushLCtxs_cons_zero {α : Type u_1} {x : α} (xs : List α) (lctx : Nat → α) :
                                        pushLCtxs (x :: xs) lctx 0 = x
                                        theorem Auto.Embedding.pushLCtxs_cons_succ {α : Type u_1} {x : α} (xs : List α) (lctx : Nat → α) (n : Nat) :
                                        pushLCtxs (x :: xs) lctx n.succ = pushLCtxs xs lctx n
                                        theorem Auto.Embedding.pushLCtxs_cons_succ_Fn {α : Type u_1} {x : α} (xs : List α) (lctx : Nat → α) :
                                        (fun (n : Nat) => pushLCtxs (x :: xs) lctx n.succ) = pushLCtxs xs lctx
                                        theorem Auto.Embedding.pushLCtxs_comm {α : Type u_1} {β : Type u_2} (f : α → β) (xs : List α) (lctx : Nat → α) (n : Nat) :
                                        f (pushLCtxs xs lctx n) = pushLCtxs (List.map f xs) (fun (n : Nat) => f (lctx n)) n
                                        @[reducible]
                                        def Auto.Embedding.pushLCtxsAt {α : Type u_1} (xs : List α) (pos : Nat) (lctx : Nat → α) (n : Nat) :
                                        α
                                        Equations
                                        Instances For
                                          theorem Auto.Embedding.pushLCtxsAt_succ_zero {α : Type u_1} (xs : List α) (pos : Nat) (lctx : Nat → α) :
                                          pushLCtxsAt xs pos.succ lctx 0 = lctx 0
                                          theorem Auto.Embedding.pushLCtxsAt_succ_succ {α : Type u_1} (xs : List α) (pos : Nat) (lctx : Nat → α) (n : Nat) :
                                          pushLCtxsAt xs pos.succ lctx n.succ = pushLCtxsAt xs pos (fun (n : Nat) => lctx n.succ) n
                                          theorem Auto.Embedding.pushLCtxsAt_succ_succ_Fn {α : Type u_1} (xs : List α) (pos : Nat) (lctx : Nat → α) :
                                          (fun (n : Nat) => pushLCtxsAt xs pos.succ lctx n.succ) = pushLCtxsAt xs pos fun (n : Nat) => lctx n.succ
                                          @[reducible]
                                          def Auto.Embedding.pushLCtxsDep {α : Type u_1} {lctxty : α → Sort u} {tys : List α} (xs : HList lctxty tys) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                          lctxty (pushLCtxs tys rty n)
                                          Equations
                                          Instances For
                                            theorem Auto.Embedding.pushLCtxsDep_lt {α : Type u_1} {lctxty : α → Sort u} {tys : List α} {xs : HList lctxty tys} {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) {n : Nat} (h : n < tys.length) :
                                            pushLCtxsDep xs lctx n ≍ HList.getD (lctx 0) xs n
                                            theorem Auto.Embedding.pushLCtxsDep_ge {α : Type u_1} {lctxty : α → Sort u} {tys : List α} {xs : HList lctxty tys} {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) {n : Nat} (h : n ≥ tys.length) :
                                            pushLCtxsDep xs lctx n ≍ lctx (n - tys.length)
                                            theorem Auto.Embedding.pushLCtxsDep_heq {α₁ α₂ : Type u_1} {lctxty₁ : α₁ → Sort u} {tys₁ : List α₁} (xs₁ : HList lctxty₁ tys₁) (rty₁ : Nat → α₁) (lctx₁ : (n : Nat) → lctxty₁ (rty₁ n)) {lctxty₂ : α₂ → Sort u} {tys₂ : List α₂} (xs₂ : HList lctxty₂ tys₂) (rty₂ : Nat → α₂) (lctx₂ : (n : Nat) → lctxty₂ (rty₂ n)) (h₁ : α₁ = α₂) (h₂ : lctxty₁ ≍ lctxty₂) (h₃ : tys₁ ≍ tys₂) (h₄ : xs₁ ≍ xs₂) (h₅ : rty₁ ≍ rty₂) (h₆ : lctx₁ ≍ lctx₂) :
                                            pushLCtxsDep xs₁ lctx₁ ≍ pushLCtxsDep xs₂ lctx₂
                                            theorem Auto.Embedding.pushLCtxsDep_substLCtx {α : Type u_1} {tys : List α} {lctxty : α → Sort u_2} (xs : HList lctxty tys) {rty₁ : Nat → α} (lctx₁ : (n : Nat) → lctxty (rty₁ n)) {rty₂ : Nat → α} (lctx₂ : (n : Nat) → lctxty (rty₂ n)) (h₁ : rty₁ = rty₂) (h₂ : lctx₁ ≍ lctx₂) :
                                            pushLCtxsDep xs lctx₁ ≍ pushLCtxsDep xs lctx₂
                                            theorem Auto.Embedding.pushLCtxsDep_substxs {α : Type u_1} {lctxty : α → Sort u_2} {tys₁ : List α} (xs₁ : HList lctxty tys₁) {tys₂ : List α} (xs₂ : HList lctxty tys₂) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (h₁ : tys₁ = tys₂) (h₂ : xs₁ ≍ xs₂) :
                                            pushLCtxsDep xs₁ lctx ≍ pushLCtxsDep xs₂ lctx
                                            theorem Auto.Embedding.pushLCtxsDep_nil {α : Type u_1} {lctxty : α → Sort u} {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                            theorem Auto.Embedding.pushLCtxsDep_cons {α : Type u_1} {lctxty : α → Sort u} {ty : α} (x : lctxty ty) {tys : List α} (xs : HList lctxty tys) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                            theorem Auto.Embedding.pushLCtxsDep_cons_zero {α : Type u_1} {lctxty : α → Sort u} {ty : α} (x : lctxty ty) {tys : List α} (xs : HList lctxty tys) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                            pushLCtxsDep (HList.cons x xs) lctx 0 ≍ x
                                            theorem Auto.Embedding.pushLCtxsDep_cons_succ {α : Type u_1} {lctxty : α → Sort u} {ty : α} (x : lctxty ty) {tys : List α} (xs : HList lctxty tys) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                            pushLCtxsDep (HList.cons x xs) lctx n.succ ≍ pushLCtxsDep xs lctx n
                                            theorem Auto.Embedding.pushLCtxsDep_cons_succ_Fn {α : Type u_1} {lctxty : α → Sort u} {ty : α} (x : lctxty ty) {tys : List α} (xs : HList lctxty tys) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                            (fun (n : Nat) => pushLCtxsDep (HList.cons x xs) lctx n.succ) ≍ pushLCtxsDep xs lctx
                                            theorem Auto.Embedding.pushLCtxsDep_append {α : Type u_1} {lctxty : α → Sort u} {as bs : List α} (xs : HList lctxty as) (ys : HList lctxty bs) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                            pushLCtxsDep (xs.append ys) lctx ≍ pushLCtxsDep xs (pushLCtxsDep ys lctx)
                                            theorem Auto.Embedding.pushLCtxsDep_singleton {α : Type u_1} {lctxty : α → Sort u} {ty : α} (x : lctxty ty) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                            theorem Auto.Embedding.pushLCtxsDep_append_singleton {α : Type u_1} {lctxty : α → Sort u} {as : List α} {a : α} (xs : HList lctxty as) (x : lctxty a) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                            @[reducible]
                                            def Auto.Embedding.pushLCtxsAtDep {α : Type u_1} {lctxty : α → Sort u} {tys : List α} (xs : HList lctxty tys) (pos : Nat) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                            lctxty (restoreAt pos (pushLCtxs tys) rty n)
                                            Equations
                                            Instances For
                                              theorem Auto.Embedding.pushLCtxsAtDep_heq {α₁ α₂ : Type u_1} {lctxty₁ : α₁ → Sort u} {tys₁ : List α₁} (xs₁ : HList lctxty₁ tys₁) (pos₁ : Nat) (rty₁ : Nat → α₁) (lctx₁ : (n : Nat) → lctxty₁ (rty₁ n)) {lctxty₂ : α₂ → Sort u} {tys₂ : List α₂} (xs₂ : HList lctxty₂ tys₂) (pos₂ : Nat) (rty₂ : Nat → α₂) (lctx₂ : (n : Nat) → lctxty₂ (rty₂ n)) (h₁ : α₁ = α₂) (h₂ : lctxty₁ ≍ lctxty₂) (h₃ : tys₁ ≍ tys₂) (h₄ : xs₁ ≍ xs₂) (h₅ : pos₁ = pos₂) (h₆ : rty₁ ≍ rty₂) (h₇ : lctx₁ ≍ lctx₂) :
                                              pushLCtxsAtDep xs₁ pos₁ lctx₁ ≍ pushLCtxsAtDep xs₂ pos₂ lctx₂
                                              theorem Auto.Embedding.pushLCtxsAtDep_substLCtx {α : Type u_1} {tys : List α} {lctxty : α → Sort u_2} (xs : HList lctxty tys) (pos : Nat) {rty₁ : Nat → α} (lctx₁ : (n : Nat) → lctxty (rty₁ n)) {rty₂ : Nat → α} (lctx₂ : (n : Nat) → lctxty (rty₂ n)) (h₁ : rty₁ = rty₂) (h₂ : lctx₁ ≍ lctx₂) :
                                              pushLCtxsAtDep xs pos lctx₁ ≍ pushLCtxsAtDep xs pos lctx₂
                                              theorem Auto.Embedding.pushLCtxsAtDep_substxs {α : Type u_1} {lctxty : α → Sort u_2} {tys₁ : List α} (xs₁ : HList lctxty tys₁) {tys₂ : List α} (xs₂ : HList lctxty tys₂) (pos : Nat) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (h₁ : tys₁ = tys₂) (h₂ : xs₁ ≍ xs₂) :
                                              pushLCtxsAtDep xs₁ pos lctx ≍ pushLCtxsAtDep xs₂ pos lctx
                                              theorem Auto.Embedding.pushLCtxsAtDep_zero {α : Type u_1} {lctxty : α → Sort u} {tys : List α} (xs : HList lctxty tys) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                              pushLCtxsAtDep xs 0 lctx ≍ pushLCtxsDep xs lctx
                                              theorem Auto.Embedding.pushLCtxsAtDep_succ_zero {α : Type u_1} {pos : Nat} {lctxty : α → Sort u} {tys : List α} (xs : HList lctxty tys) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                              pushLCtxsAtDep xs pos.succ lctx 0 = lctx 0
                                              theorem Auto.Embedding.pushLCtxsAtDep_succ_succ {α : Type u_1} {lctxty : α → Sort u} {tys : List α} (xs : HList lctxty tys) (pos : Nat) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                              pushLCtxsAtDep xs pos.succ lctx n.succ ≍ pushLCtxsAtDep xs pos (fun (n : Nat) => lctx n.succ) n
                                              theorem Auto.Embedding.pushLCtxsAtDep_succ_succ_Fn {α : Type u_1} {lctxty : α → Sort u} {tys : List α} (xs : HList lctxty tys) (pos : Nat) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                              (fun (n : Nat) => pushLCtxsAtDep xs pos.succ lctx n.succ) ≍ pushLCtxsAtDep xs pos fun (n : Nat) => lctx n.succ
                                              theorem Auto.Embedding.List.ofFun_get?_eq_none {α : Type u_1} (f : Nat → α) (n m : Nat) (h : n ≤ m) :
                                              theorem Auto.Embedding.List.ofFun_ofPushLCtx {α : Type u_1} {n : Nat} (xs : List α) (heq : xs.length = n) (lctx : Nat → α) :
                                              List.ofFun (pushLCtxs xs lctx) n = xs
                                              def Auto.Embedding.HList.ofFun {α : Type u_1} {tyf : Nat → α} {β : α → Sort u_2} (f : (n : Nat) → β (tyf n)) (n : Nat) :
                                              HList β (List.ofFun tyf n)
                                              Equations
                                              Instances For
                                                theorem Auto.Embedding.HList.ofFun_zero {α : Type u_1} {tyf : Nat → α} {β : α → Sort u_2} (f : (n : Nat) → β (tyf n)) :
                                                theorem Auto.Embedding.HList.ofFun_succ {α : Type u_1} {tyf : Nat → α} {β : α → Sort u_2} (f : (n : Nat) → β (tyf n)) (n : Nat) :
                                                ofFun f n.succ = HList.cons (f 0) (ofFun (fun (n : Nat) => f n.succ) n)
                                                theorem Auto.Embedding.HList.ofFun_ofPushLCtxDep {α : Type u_1} {n : Nat} {lctxty : α → Sort u} {tys : List α} (heq : tys.length = n) (xs : HList lctxty tys) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                                ofFun (pushLCtxsDep xs lctx) n ≍ xs
                                                theorem Auto.Embedding.HList.ofFun_getD_eq_some {α : Type u_1} {tyf : Nat → α} {β : α → Sort u_2} (f : (n : Nat) → β (tyf n)) (n m : Nat) (h : n > m) {ty : α} (default : β ty) :
                                                HList.getD default (ofFun f n) m ≍ f m
                                                theorem Auto.Embedding.HList.ofFun_getD_eq_none {α : Type u_1} {tyf : Nat → α} {β : α → Sort u_2} (f : (n : Nat) → β (tyf n)) (n m : Nat) (h : n ≤ m) {ty : α} (default : β ty) :
                                                HList.getD default (ofFun f n) m ≍ default
                                                def Auto.Embedding.replaceAt {α : Sort u_1} (x : α) (pos : Nat) (lctx : Nat → α) (n : Nat) :
                                                α
                                                Equations
                                                Instances For
                                                  def Auto.Embedding.replaceAtDep {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) (pos : Nat) {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                                  lctxty (replaceAt xty pos rty n)
                                                  Equations
                                                  Instances For
                                                    theorem Auto.Embedding.BinTree.get?_insert_eq_replaceAt_get? {α : Type u_1} {m : Nat} {x : α} {n : Nat} {d : α} {bt : BinTree α} :
                                                    ((bt.insert m x).get? n).getD d = replaceAt x m (fun (n : Nat) => (bt.get? n).getD d) n
                                                    theorem Auto.Embedding.BinTree.get?_insert_eq_replaceAt_get?_Fn {α : Type u_1} {m : Nat} {x d : α} {bt : BinTree α} :
                                                    (fun (n : Nat) => ((bt.insert m x).get? n).getD d) = replaceAt x m fun (n : Nat) => (bt.get? n).getD d
                                                    theorem Auto.Embedding.push_pop_eq {α : Sort u_1} (lctx : Nat → α) :
                                                    (pushLCtx (lctx 0) fun (n : Nat) => lctx n.succ) = lctx
                                                    theorem Auto.Embedding.pushs_pops_eq {α : Type u_1} {lvl : Nat} (lctx : Nat → α) :
                                                    (pushLCtxs (List.ofFun lctx lvl) fun (n : Nat) => lctx (n + lvl)) = lctx
                                                    theorem Auto.Embedding.ofFun_pushs {n : Nat} {α✝ : Type u_1} {xs : List α✝} {lctx : Nat → α✝} (heq : xs.length = n) :
                                                    List.ofFun (pushLCtxs xs lctx) n = xs
                                                    theorem Auto.Embedding.pushDep_popDep_eq {α : Sort u_1} {lctxty : α → Sort u} {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                                    (pushLCtxDep (lctx 0) fun (n : Nat) => lctx n.succ) ≍ lctx
                                                    theorem Auto.Embedding.pushsDep_popsDep_eq {α : Type u_1} {lvl : Nat} {lctxty : α → Sort u} {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) :
                                                    (pushLCtxsDep (HList.ofFun lctx lvl) fun (n : Nat) => lctx (n + lvl)) ≍ lctx
                                                    @[reducible]
                                                    def Auto.Embedding.addAt (lvl pos n : Nat) :
                                                    Equations
                                                    Instances For
                                                      @[reducible]
                                                      Equations
                                                      Instances For
                                                        theorem Auto.Embedding.addAt_succ_zero (lvl pos : Nat) :
                                                        addAt lvl pos.succ 0 = 0
                                                        theorem Auto.Embedding.addAt_succ_succ (lvl pos n : Nat) :
                                                        addAt lvl pos.succ n.succ = (addAt lvl pos n).succ
                                                        def Auto.Embedding.addAt_succ_l (lvl pos n : Nat) :
                                                        addAt lvl.succ pos n = succAt pos (addAt lvl pos n)
                                                        Equations
                                                        • ⋯ = ⋯
                                                        Instances For
                                                          def Auto.Embedding.addAt_succ_r (lvl pos n : Nat) :
                                                          addAt lvl.succ pos n = addAt lvl pos (succAt pos n)
                                                          Equations
                                                          • ⋯ = ⋯
                                                          Instances For
                                                            Equations
                                                            • ⋯ = ⋯
                                                            Instances For
                                                              def Auto.Embedding.add.one (pos : Nat) :
                                                              addAt 1 pos = succAt pos
                                                              Equations
                                                              • ⋯ = ⋯
                                                              Instances For
                                                                theorem Auto.Embedding.restoreAt_succ_pushLCtx {α : Sort u_1} (restore : (Nat → α) → Nat → α) (x : α) (pos : Nat) (lctx : Nat → α) (n : Nat) :
                                                                restoreAt pos.succ restore (pushLCtx x lctx) n = pushLCtx x (restoreAt pos restore lctx) n
                                                                theorem Auto.Embedding.restoreAt_succ_pushLCtx_Fn {α : Sort u_1} (restore : (Nat → α) → Nat → α) (x : α) (pos : Nat) (lctx : Nat → α) :
                                                                restoreAt pos.succ restore (pushLCtx x lctx) = pushLCtx x (restoreAt pos restore lctx)
                                                                theorem Auto.Embedding.restoreAtDep_succ_pushLCtxDep {α : Sort u_1} {lctxty : α → Sort u} (restore : (Nat → α) → Nat → α) (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) {rty : Nat → α} {xty : α} (x : lctxty xty) (pos : Nat) (lctx : (n : Nat) → lctxty (rty n)) (n : Nat) :
                                                                restoreAtDep pos.succ (fun {rty : Nat → α} => restoreDep) (pushLCtxDep x lctx) n ≍ pushLCtxDep x (restoreAtDep pos (fun {rty : Nat → α} => restoreDep) lctx) n
                                                                theorem Auto.Embedding.restoreAtDep_succ_pushLCtxDep_Fn {α : Sort u_1} {lctxty : α → Sort u} (restore : (Nat → α) → Nat → α) (restoreDep : {rty : Nat → α} → ((n : Nat) → lctxty (rty n)) → (n : Nat) → lctxty (restore rty n)) {rty : Nat → α} {xty : α} (x : lctxty xty) (pos : Nat) (lctx : (n : Nat) → lctxty (rty n)) :
                                                                restoreAtDep pos.succ (fun {rty : Nat → α} => restoreDep) (pushLCtxDep x lctx) ≍ pushLCtxDep x (restoreAtDep pos (fun {rty : Nat → α} => restoreDep) lctx)
                                                                theorem Auto.Embedding.contraPair.ofPushPop {α : Sort u_1} (x : α) :
                                                                contraPair Nat.succ (fun (lctx : Nat → α) => lctx 0 = x) (pushLCtx x)
                                                                theorem Auto.Embedding.coPairDep.ofPushDepPopDep {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) :
                                                                coPairDep lctxty Nat.succ (pushLCtx xty) fun {rty : Nat → α} => pushLCtxDep x
                                                                theorem Auto.Embedding.contraPairDep.ofPushDepPopDep {α : Sort u_1} {lctxty : α → Sort u} {xty : α} (x : lctxty xty) :
                                                                contraPairDep lctxty Nat.succ (fun (lctxty : Nat → α) => lctxty 0 = xty) (pushLCtx xty) (fun {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) => lctx 0 ≍ x) fun {rty : Nat → α} => pushLCtxDep x
                                                                theorem Auto.Embedding.coPair.ofPushsPops {α : Type u_1} (lvl : Nat) (xs : List α) (heq : xs.length = lvl) :
                                                                coPair (fun (x : Nat) => x + lvl) (pushLCtxs xs)
                                                                theorem Auto.Embedding.contraPair.ofPushsPops {α : Type u_1} (lvl : Nat) (xs : List α) (heq : xs.length = lvl) :
                                                                contraPair (fun (n : Nat) => n + lvl) (fun (lctx : Nat → α) => List.ofFun lctx lvl = xs) (pushLCtxs xs)
                                                                theorem Auto.Embedding.coPairDep.ofPushsDepPopsDep {α : Type u_1} {lctxty : α → Sort u} (lvl : Nat) {tys : List α} (xs : HList lctxty tys) (heq : tys.length = lvl) :
                                                                coPairDep lctxty (fun (x : Nat) => x + lvl) (pushLCtxs tys) fun {rty : Nat → α} => pushLCtxsDep xs
                                                                theorem Auto.Embedding.contraPairDep.ofPushsDepPopsDep {α : Type u_1} {lctxty : α → Sort u} (lvl : Nat) {tys : List α} (xs : HList lctxty tys) (heq : tys.length = lvl) :
                                                                contraPairDep lctxty (fun (n : Nat) => n + lvl) (fun (lctxty : Nat → α) => List.ofFun lctxty lvl = tys) (pushLCtxs tys) (fun {rty : Nat → α} (lctx : (n : Nat) → lctxty (rty n)) => HList.ofFun lctx lvl ≍ xs) fun {rty : Nat → α} => pushLCtxsDep xs