import Pretty.Defs.Basic
import Pretty.Claims.Render
import Pretty.Supports.FactoryMath

/-!
## Theorems about the measure computation/rendering relation ($⇓_\mathbb{M}$)
-/

/--
Determinism of the measure computation relation (Section 5.3)
-/
theorem MeasRender_deterministic: ∀ {α : Type} {d : Doc} {c i : ℕ} {F : Factory α} {m₁ m₂ : Meas}, MeasRender F d c i m₁ → MeasRender F d c i m₂ → m₁ = m₂
MeasRender_deterministic {F: Factory α
F : Factory: Type → Type
Factory α: ?m.3
α} {m₁: Meas
m₁ m₂: Meas
m₂ : Meas: {α : Type} → Type
Meas}
  (h₁: MeasRender F d c i m₁
h₁ : @MeasRender: {α : Type} → Factory α → Doc → ℕ → ℕ → Meas → Prop
MeasRender α: ?m.3
α F: Factory α
F d: ?m.15
d c: ?m.27
c i: ?m.39
i m₁: Meas
m₁) (h₂: MeasRender F d c i m₂
h₂ : @MeasRender: {α : Type} → Factory α → Doc → ℕ → ℕ → Meas → Prop
MeasRender α: ?m.3
α F: Factory α
F d: ?m.15
d c: ?m.27
c i: ?m.39
i m₂: Meas
m₂) : m₁: Meas
m₁ = m₂: Meas
m₂ := by
Goals accomplished! 🐙 
  α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁, m₂: Meas

h₁: MeasRender F d c i m₁

h₂: MeasRender F d c i m₂

m₁ = m₂induction h₁: MeasRender F d c i m₁
h₁ generalizing m₂: Meas
m₂α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

c✝, i✝: ℕ

s✝: String

m₂: Meas

h₂: MeasRender F (Doc.text s✝) c✝ i✝ m₂

text{ last := c✝ + String.length s✝, cost := Factory.text F c✝ (String.length s✝), doc := Doc.text s✝,
    x := c✝ + String.length s✝, y := i✝ } =   m₂
α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

c✝, i✝: ℕ

m₂: Meas

h₂: MeasRender F Doc.nl c✝ i✝ m₂

nl{ last := i✝, cost := Factory.nl F i✝, doc := Doc.nl, x := max c✝ i✝, y := i✝ } = m₂
α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝: Meas

d₂✝: Doc

m₂✝, m✝: Meas

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝

h₂✝: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h✝: m✝ = Meas.concat F m₁✝ m₂✝

h₁_ih✝: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝ = m₂

h₂_ih✝: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝.last i✝ m₂ → m₂✝ = m₂

m₂: Meas

h₂: MeasRender F (Doc.concat d₁✝ d₂✝) c✝ i✝ m₂

concatm✝ = m₂
α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d✝: Doc

c✝, i✝, n✝, last✝: ℕ

cost✝: α

x✝, y✝: ℕ

h✝: MeasRender F d✝ c✝ (i✝ + n✝) { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ }

h_ih✝: ∀ {m₂ : Meas}, MeasRender F d✝ c✝ (i✝ + n✝) m₂ → { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ } = m₂

m₂: Meas

h₂: MeasRender F (Doc.nest n✝ d✝) c✝ i✝ m₂

nest{ last := last✝, cost := cost✝, doc := Doc.nest n✝ d✝, x := x✝, y := y✝ } = m₂
α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d✝: Doc

c✝, last✝: ℕ

cost✝: α

x✝, y✝, i✝: ℕ

h✝: MeasRender F d✝ c✝ c✝ { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ }

h_ih✝: ∀ {m₂ : Meas}, MeasRender F d✝ c✝ c✝ m₂ → { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ } = m₂

m₂: Meas

h₂: MeasRender F (Doc.align d✝) c✝ i✝ m₂

align{ last := last✝, cost := cost✝, doc := Doc.align d✝, x := x✝, y := max i✝ y✝ } = m₂
  α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁, m₂: Meas

h₁: MeasRender F d c i m₁

h₂: MeasRender F d c i m₂

m₁ = m₂case text | nl => α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

c✝, i✝: ℕ

s✝: String

m₂: Meas

h₂: MeasRender F (Doc.text s✝) c✝ i✝ m₂

{ last := c✝ + String.length s✝, cost := Factory.text F c✝ (String.length s✝), doc := Doc.text s✝,
    x := c✝ + String.length s✝, y := i✝ } =   m₂dwi { α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

c✝, i✝: ℕ

s✝: String

m₂: Meas

h₂: MeasRender F (Doc.text s✝) c✝ i✝ m₂

{ last := c✝ + String.length s✝, cost := Factory.text F c✝ (String.length s✝), doc := Doc.text s✝,
    x := c✝ + String.length s✝, y := i✝ } =   m₂cases h₂: MeasRender F (Doc.text s✝) c✝ i✝ m₂
h₂α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

c✝, i✝: ℕ

nl{ last := i✝, cost := Factory.nl F i✝, doc := Doc.nl, x := max c✝ i✝, y := i✝ } =   { last := i✝, cost := Factory.nl F i✝, doc := Doc.nl, x := max c✝ i✝, y := i✝ } }
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁, m₂: Meas

h₁: MeasRender F d c i m₁

h₂: MeasRender F d c i m₂

m₁ = m₂case nest ih: ?m.145 d✝ c✝ (i✝ + n✝) { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ } h✝
ih | align ih: ?m.145 d✝ c✝ c✝ { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ } h✝
ih => 
    α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d✝: Doc

c✝, last✝: ℕ

cost✝: α

x✝, y✝, i✝: ℕ

h✝: MeasRender F d✝ c✝ c✝ { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ }

ih: ∀ {m₂ : Meas}, MeasRender F d✝ c✝ c✝ m₂ → { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ } = m₂

m₂: Meas

h₂: MeasRender F (Doc.align d✝) c✝ i✝ m₂

{ last := last✝, cost := cost✝, doc := Doc.align d✝, x := x✝, y := max i✝ y✝ } = m₂rename Doc: Type
Doc => dα: Type

d✝: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d: Doc

c✝, last✝: ℕ

cost✝: α

x✝, y✝, i✝: ℕ

h✝: MeasRender F d c✝ c✝ { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ }

ih: ∀ {m₂ : Meas}, MeasRender F d c✝ c✝ m₂ → { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ } = m₂

m₂: Meas

h₂: MeasRender F (Doc.align d) c✝ i✝ m₂

{ last := last✝, cost := cost✝, doc := Doc.align d, x := x✝, y := max i✝ y✝ } = m₂
    α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d✝: Doc

c✝, last✝: ℕ

cost✝: α

x✝, y✝, i✝: ℕ

h✝: MeasRender F d✝ c✝ c✝ { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ }

ih: ∀ {m₂ : Meas}, MeasRender F d✝ c✝ c✝ m₂ → { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ } = m₂

m₂: Meas

h₂: MeasRender F (Doc.align d✝) c✝ i✝ m₂

{ last := last✝, cost := cost✝, doc := Doc.align d✝, x := x✝, y := max i✝ y✝ } = m₂cases h₂: MeasRender F (Doc.align d) c✝ i✝ m₂
h₂α: Type

d✝: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d: Doc

c✝, i✝, n✝, last✝¹: ℕ

cost✝¹: α

x✝¹, y✝¹: ℕ

h✝¹: MeasRender F d c✝ (i✝ + n✝) { last := last✝¹, cost := cost✝¹, doc := d, x := x✝¹, y := y✝¹ }

ih: ∀ {m₂ : Meas}, MeasRender F d c✝ (i✝ + n✝) m₂ → { last := last✝¹, cost := cost✝¹, doc := d, x := x✝¹, y := y✝¹ } = m₂

last✝: ℕ

cost✝: α

x✝, y✝: ℕ

h✝: MeasRender F d c✝ (i✝ + n✝) { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ }

nest{ last := last✝¹, cost := cost✝¹, doc := Doc.nest n✝ d, x := x✝¹, y := y✝¹ } =   { last := last✝, cost := cost✝, doc := Doc.nest n✝ d, x := x✝, y := y✝ }
    α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d✝: Doc

c✝, last✝: ℕ

cost✝: α

x✝, y✝, i✝: ℕ

h✝: MeasRender F d✝ c✝ c✝ { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ }

ih: ∀ {m₂ : Meas}, MeasRender F d✝ c✝ c✝ m₂ → { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ } = m₂

m₂: Meas

h₂: MeasRender F (Doc.align d✝) c✝ i✝ m₂

{ last := last✝, cost := cost✝, doc := Doc.align d✝, x := x✝, y := max i✝ y✝ } = m₂rename_i last₂: ℕ
last₂ cost₂: ?m.3943
cost₂ x₂: ℕ
x₂ y₂: ℕ
y₂ h₂: MeasRender F d c✝ (i✝ + n✝) { last := last₂, cost := cost₂, doc := d, x := x₂, y := y₂ }
h₂α: Type

d✝: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d: Doc

c✝, last✝: ℕ

cost✝: α

x✝, y✝, i✝: ℕ

h✝: MeasRender F d c✝ c✝ { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ }

ih: ∀ {m₂ : Meas}, MeasRender F d c✝ c✝ m₂ → { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ } = m₂

last₂: ℕ

cost₂: α

x₂, y₂: ℕ

h₂: MeasRender F d c✝ c✝ { last := last₂, cost := cost₂, doc := d, x := x₂, y := y₂ }

align{ last := last✝, cost := cost✝, doc := Doc.align d, x := x✝, y := max i✝ y✝ } =   { last := last₂, cost := cost₂, doc := Doc.align d, x := x₂, y := max i✝ y₂ } 
    α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d✝: Doc

c✝, last✝: ℕ

cost✝: α

x✝, y✝, i✝: ℕ

h✝: MeasRender F d✝ c✝ c✝ { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ }

ih: ∀ {m₂ : Meas}, MeasRender F d✝ c✝ c✝ m₂ → { last := last✝, cost := cost✝, doc := d✝, x := x✝, y := y✝ } = m₂

m₂: Meas

h₂: MeasRender F (Doc.align d✝) c✝ i✝ m₂

{ last := last✝, cost := cost✝, doc := Doc.align d✝, x := x✝, y := max i✝ y✝ } = m₂dwi { α: Type

d✝: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d: Doc

c✝, i✝, n✝, last✝: ℕ

cost✝: α

x✝, y✝: ℕ

h✝: MeasRender F d c✝ (i✝ + n✝) { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ }

ih: ∀ {m₂ : Meas}, MeasRender F d c✝ (i✝ + n✝) m₂ → { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ } = m₂

last₂: ℕ

cost₂: α

x₂, y₂: ℕ

h₂: MeasRender F d c✝ (i✝ + n✝) { last := last₂, cost := cost₂, doc := d, x := x₂, y := y₂ }

nest{ last := last✝, cost := cost✝, doc := Doc.nest n✝ d, x := x✝, y := y✝ } =   { last := last₂, cost := cost₂, doc := Doc.nest n✝ d, x := x₂, y := y₂ }cases ih: ?m.145 d c✝ (i✝ + n✝) { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ } h✝
ih h₂: MeasRender F d c✝ c✝ { last := last₂, cost := cost₂, doc := d, x := x₂, y := y₂ }
h₂α: Type

d✝: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d: Doc

c✝, last✝: ℕ

cost✝: α

x✝, y✝, i✝: ℕ

h✝: MeasRender F d c✝ c✝ { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ }

ih: ∀ {m₂ : Meas}, MeasRender F d c✝ c✝ m₂ → { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ } = m₂

h₂: MeasRender F d c✝ c✝ { last := last✝, cost := cost✝, doc := d, x := x✝, y := y✝ }

align.refl{ last := last✝, cost := cost✝, doc := Doc.align d, x := x✝, y := max i✝ y✝ } =   { last := last✝, cost := cost✝, doc := Doc.align d, x := x✝, y := max i✝ y✝ } }
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁, m₂: Meas

h₁: MeasRender F d c i m₁

h₂: MeasRender F d c i m₂

m₁ = m₂case concat ihₗ: ?m.145 d₁✝ c✝ i✝ m₁✝ h₁✝
ihₗ ihᵣ: ?m.145 d₂✝ m₁✝.last i✝ m₂✝ h₂✝
ihᵣ => 
    α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝: Meas

d₂✝: Doc

m₂✝, m✝: Meas

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝

h₂✝: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h✝: m✝ = Meas.concat F m₁✝ m₂✝

ihₗ: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝ = m₂

ihᵣ: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝.last i✝ m₂ → m₂✝ = m₂

m₂: Meas

h₂: MeasRender F (Doc.concat d₁✝ d₂✝) c✝ i✝ m₂

m✝ = m₂cases h₂: MeasRender F (Doc.concat d₁✝ d₂✝) c✝ i✝ m₂
h₂α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝¹: Meas

d₂✝: Doc

m₂✝¹, m✝: Meas

h₁✝¹: MeasRender F d₁✝ c✝ i✝ m₁✝¹

h₂✝¹: MeasRender F d₂✝ m₁✝¹.last i✝ m₂✝¹

h✝¹: m✝ = Meas.concat F m₁✝¹ m₂✝¹

ihₗ: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝¹ = m₂

ihᵣ: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝¹.last i✝ m₂ → m₂✝¹ = m₂

m₂, m₁✝, m₂✝: Meas

h₂✝: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝

h✝: m₂ = Meas.concat F m₁✝ m₂✝

concatm✝ = m₂ 
    α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝: Meas

d₂✝: Doc

m₂✝, m✝: Meas

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝

h₂✝: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h✝: m✝ = Meas.concat F m₁✝ m₂✝

ihₗ: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝ = m₂

ihᵣ: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝.last i✝ m₂ → m₂✝ = m₂

m₂: Meas

h₂: MeasRender F (Doc.concat d₁✝ d₂✝) c✝ i✝ m₂

m✝ = m₂case concat h₂: MeasRender F d₂✝ m₁✝.last i✝ m₂✝
h₂ h₁: MeasRender F d₁✝ c✝ i✝ m₁✝
h₁ h: m₂ = Meas.concat F m₁✝ m₂✝
h => 
      α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝¹: Meas

d₂✝: Doc

m₂✝¹, m✝: Meas

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝¹

h₂✝: MeasRender F d₂✝ m₁✝¹.last i✝ m₂✝¹

h✝: m✝ = Meas.concat F m₁✝¹ m₂✝¹

ihₗ: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝¹ = m₂

ihᵣ: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝¹.last i✝ m₂ → m₂✝¹ = m₂

m₂, m₁✝, m₂✝: Meas

h₂: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h₁: MeasRender F d₁✝ c✝ i✝ m₁✝

h: m₂ = Meas.concat F m₁✝ m₂✝

m✝ = m₂cases ihₗ: ?m.145 d₁✝ c✝ i✝ m₁✝¹ h₁✝
ihₗ h₁: MeasRender F d₁✝ c✝ i✝ m₁✝
h₁α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝: Meas

d₂✝: Doc

m₂✝¹, m✝: Meas

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝

h₂✝: MeasRender F d₂✝ m₁✝.last i✝ m₂✝¹

h✝: m✝ = Meas.concat F m₁✝ m₂✝¹

ihₗ: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝ = m₂

ihᵣ: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝.last i✝ m₂ → m₂✝¹ = m₂

m₂, m₂✝: Meas

h₂: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h₁: MeasRender F d₁✝ c✝ i✝ m₁✝

h: m₂ = Meas.concat F m₁✝ m₂✝

reflm✝ = m₂
      α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝¹: Meas

d₂✝: Doc

m₂✝¹, m✝: Meas

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝¹

h₂✝: MeasRender F d₂✝ m₁✝¹.last i✝ m₂✝¹

h✝: m✝ = Meas.concat F m₁✝¹ m₂✝¹

ihₗ: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝¹ = m₂

ihᵣ: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝¹.last i✝ m₂ → m₂✝¹ = m₂

m₂, m₁✝, m₂✝: Meas

h₂: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h₁: MeasRender F d₁✝ c✝ i✝ m₁✝

h: m₂ = Meas.concat F m₁✝ m₂✝

m✝ = m₂cases ihᵣ: ?m.145 d₂✝ m₁✝.last i✝ m₂✝¹ h₂✝
ihᵣ h₂: MeasRender F d₂✝ m₁✝.last i✝ m₂✝
h₂α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝: Meas

d₂✝: Doc

m₂✝, m✝: Meas

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝

h₂✝: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h✝: m✝ = Meas.concat F m₁✝ m₂✝

ihₗ: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝ = m₂

ihᵣ: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝.last i✝ m₂ → m₂✝ = m₂

m₂: Meas

h₁: MeasRender F d₁✝ c✝ i✝ m₁✝

h₂: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h: m₂ = Meas.concat F m₁✝ m₂✝

refl.reflm✝ = m₂
      α: Type

d: Doc

c, i: ℕ

F: Factory α

m₁: Meas

d₁✝: Doc

c✝, i✝: ℕ

m₁✝¹: Meas

d₂✝: Doc

m₂✝¹, m✝: Meas

h₁✝: MeasRender F d₁✝ c✝ i✝ m₁✝¹

h₂✝: MeasRender F d₂✝ m₁✝¹.last i✝ m₂✝¹

h✝: m✝ = Meas.concat F m₁✝¹ m₂✝¹

ihₗ: ∀ {m₂ : Meas}, MeasRender F d₁✝ c✝ i✝ m₂ → m₁✝¹ = m₂

ihᵣ: ∀ {m₂ : Meas}, MeasRender F d₂✝ m₁✝¹.last i✝ m₂ → m₂✝¹ = m₂

m₂, m₁✝, m₂✝: Meas

h₂: MeasRender F d₂✝ m₁✝.last i✝ m₂✝

h₁: MeasRender F d₁✝ c✝ i✝ m₁✝

h: m₂ = Meas.concat F m₁✝ m₂✝

m✝ = m₂simp [*]
Goals accomplished! 🐙

/--
Correctness of the measure computation relation 
when it results in one line (first part of Theorem 5.3)
-/
theorem MeasRender_single_correct: ∀ {α : Type} {d : Doc} {c i : ℕ} {s : String} (F : Factory α),
  Render d c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }
MeasRender_single_correct (F: Factory α
F : Factory: Type → Type
Factory α: ?m.8192
α) 
    (h_render: Render d c i { fst := s, rst := [] }
h_render : Render: Doc → ℕ → ℕ → Layout → Prop
Render d: ?m.8198
d c: ?m.8204
c i: ?m.8210
i ⟨s: ?m.8218
s, []: List ?m.8226
[]⟩) : 
    ∃ cost: ?m.8233
cost y: ?m.8238
y, MeasRender: {α : Type} → Factory α → Doc → ℕ → ℕ → Meas → Prop
MeasRender F: Factory α
F d: ?m.8198
d c: ?m.8204
c i: ?m.8210
i ⟨c: ?m.8204
c + s: ?m.8218
s.length: String → ℕ
length, cost: ?m.8233
cost, d: ?m.8198
d, c: ?m.8204
c + s: ?m.8218
s.length: String → ℕ
length, y: ?m.8238
y⟩ := by
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

F: Factory α

h_render: Render d c i { fst := s, rst := [] }

∃ cost y, MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }induction d: Doc
d generalizing c: ℕ
c i: ℕ
i s: String
sα: Type

F: Factory α

s✝: String

c, i: ℕ

s: String

h_render: Render (Doc.text s✝) c i { fst := s, rst := [] }

text∃ cost y,
  MeasRender F (Doc.text s✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.text s✝, x := c + String.length s, y := y }
α: Type

F: Factory α

c, i: ℕ

s: String

h_render: Render Doc.nl c i { fst := s, rst := [] }

nl∃ cost y,
  MeasRender F Doc.nl c i { last := c + String.length s, cost := cost, doc := Doc.nl, x := c + String.length s, y := y }
α: Type

F: Factory α

d₁✝, d₂✝: Doc

d₁_ih✝: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

d₂_ih✝: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := [] }

concat∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }
α: Type

F: Factory α

n✝: ℕ

d✝: Doc

d_ih✝: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := [] }

nest∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }
α: Type

F: Factory α

d✝: Doc

d_ih✝: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.align d✝) c i { fst := s, rst := [] }

align∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }
α: Type

F: Factory α

d₁✝, d₂✝: Doc

d₁_ih✝: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

d₂_ih✝: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.choice d₁✝ d₂✝) c i { fst := s, rst := [] }

choice∃ cost y,
  MeasRender F (Doc.choice d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.choice d₁✝ d₂✝, x := c + String.length s, y := y }
  α: Type

d: Doc

c, i: ℕ

s: String

F: Factory α

h_render: Render d c i { fst := s, rst := [] }

∃ cost y, MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }case text => 
    α: Type

F: Factory α

s✝: String

c, i: ℕ

s: String

h_render: Render (Doc.text s✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.text s✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.text s✝, x := c + String.length s, y := y }exists F: Factory α
F.text: {α : Type} → Factory α → ℕ → ℕ → α
text c: ℕ
c s: String
s.length: String → ℕ
length, i: ℕ
iα: Type

F: Factory α

s✝: String

c, i: ℕ

s: String

h_render: Render (Doc.text s✝) c i { fst := s, rst := [] }

MeasRender F (Doc.text s✝) c i
  { last := c + String.length s, cost := Factory.text F c (String.length s), doc := Doc.text s✝,
    x := c + String.length s, y := i }
    α: Type

F: Factory α

s✝: String

c, i: ℕ

s: String

h_render: Render (Doc.text s✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.text s✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.text s✝, x := c + String.length s, y := y }cases h_render: Render (Doc.text s✝) c i { fst := s, rst := [] }
h_renderα: Type

F: Factory α

s✝: String

c, i: ℕ

textMeasRender F (Doc.text s✝) c i
  { last := c + String.length s✝, cost := Factory.text F c (String.length s✝), doc := Doc.text s✝,
    x := c + String.length s✝, y := i } 
    α: Type

F: Factory α

s✝: String

c, i: ℕ

s: String

h_render: Render (Doc.text s✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.text s✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.text s✝, x := c + String.length s, y := y }constructor
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

F: Factory α

h_render: Render d c i { fst := s, rst := [] }

∃ cost y, MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }case nl => α: Type

F: Factory α

c, i: ℕ

s: String

h_render: Render Doc.nl c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F Doc.nl c i { last := c + String.length s, cost := cost, doc := Doc.nl, x := c + String.length s, y := y }exists F: Factory α
F.text: {α : Type} → Factory α → ℕ → ℕ → α
text c: ℕ
c s: String
s.length: String → ℕ
length, i: ℕ
i
Goals accomplished! 🐙 
  α: Type

d: Doc

c, i: ℕ

s: String

F: Factory α

h_render: Render d c i { fst := s, rst := [] }

∃ cost y, MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }case nest ih: ?m.8363 d✝
ih  => 
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }cases h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := [] }
h_renderα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h✝: Render d✝ c (i + n✝) { fst := s, rst := [] }

nest∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }rename_i h: Render d✝ c (i + n✝) { fst := s, rst := [] }
hα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h: Render d✝ c (i + n✝) { fst := s, rst := [] }

nest∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }  
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }let ⟨cost: α
cost, y: ℕ
y, hh: MeasRender F d✝ c (i + n✝) { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }
hh⟩ := ih: ?m.8363 d✝
ih h: Render d✝ c (i + n✝) { fst := s, rst := [] }
hα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h: Render d✝ c (i + n✝) { fst := s, rst := [] }

cost: α

y: ℕ

hh: MeasRender F d✝ c (i + n✝) { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

nest∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }exists cost: α
cost, y: ℕ
yα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h: Render d✝ c (i + n✝) { fst := s, rst := [] }

cost: α

y: ℕ

hh: MeasRender F d✝ c (i + n✝) { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

nestMeasRender F (Doc.nest n✝ d✝) c i
  { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y } 
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }constructorα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h: Render d✝ c (i + n✝) { fst := s, rst := [] }

cost: α

y: ℕ

hh: MeasRender F d✝ c (i + n✝) { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

nest.hMeasRender F d✝ c (i + n✝) { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.nest n✝ d✝, x := c + String.length s, y := y }assumption
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

F: Factory α

h_render: Render d c i { fst := s, rst := [] }

∃ cost y, MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }case align ih: ?m.8363 d✝
ih => 
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.align d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }cases h_render: Render (Doc.align d✝) c i { fst := s, rst := [] }
h_renderα: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h✝: Render d✝ c c { fst := s, rst := [] }

align∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.align d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }rename_i h: Render d✝ c c { fst := s, rst := [] }
hα: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h: Render d✝ c c { fst := s, rst := [] }

align∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }  
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.align d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }let ⟨cost: α
cost, y: ℕ
y, hh: MeasRender F d✝ c c { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }
hh⟩ := ih: ?m.8363 d✝
ih h: Render d✝ c c { fst := s, rst := [] }
hα: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h: Render d✝ c c { fst := s, rst := [] }

cost: α

y: ℕ

hh: MeasRender F d✝ c c { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

align∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.align d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }exists cost: α
cost, (max: {α : Type ?u.11587} → [self : Max α] → α → α → α
max i: ℕ
i y: ℕ
y)α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h: Render d✝ c c { fst := s, rst := [] }

cost: α

y: ℕ

hh: MeasRender F d✝ c c { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

alignMeasRender F (Doc.align d✝) c i
  { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := max i y } 
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.align d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }constructorα: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h: Render d✝ c c { fst := s, rst := [] }

cost: α

y: ℕ

hh: MeasRender F d✝ c c { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

align.hMeasRender F d✝ c c { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String},
  Render d✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d✝ c i { last := c + String.length s, cost := cost, doc := d✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.align d✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.align d✝, x := c + String.length s, y := y }assumption
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

F: Factory α

h_render: Render d c i { fst := s, rst := [] }

∃ cost y, MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }case concat ih₁: ?m.8363 d₁✝
ih₁ ih₂: ?m.8363 d₂✝
ih₂ =>
    α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }generalize h_layout : Layout.mk: String → List String → Layout
Layout.mk s: String
s []: List ?m.12843
[] = L at h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := [] }
h_renderα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

L: Layout

h_layout: { fst := s, rst := [] } = L

h_render: Render (Doc.concat d₁✝ d₂✝) c i L

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }
    α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }cases h_render: Render (Doc.concat d₁✝ d₂✝) c i L
h_renderα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s, s✝, t✝: String

ts✝: List String

h₁✝: Render d₁✝ c i { fst := s✝, rst := [] }

h₂✝: Render d₂✝ (c + String.length s✝) i { fst := t✝, rst := ts✝ }

h_layout: { fst := s, rst := [] } = { fst := s✝ ++ t✝, rst := ts✝ }

concat_one∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

ss✝: List String

slast✝, s✝, t✝: String

ts✝: List String

h_non_empty✝: ss✝ ≠ []

h_last✝: slast✝ = List.getLast ss✝ h_non_empty✝

h₂✝: Render d₂✝ (String.length slast✝) i { fst := t✝, rst := ts✝ }

h₁✝: Render d₁✝ c i { fst := s✝, rst := ss✝ }

h_layout: { fst := s, rst := [] } = { fst := s✝, rst := List.dropLast ss✝ ++ [slast✝ ++ t✝] ++ ts✝ }

concat_multi∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }
    α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }case concat_one d₁: Doc
d₁ d₂: Doc
d₂ s₁: String
s₁ s₂: String
s₂ _ h₁: Render d₁ c i { fst := s₁, rst := [] }
h₁ h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := ts✝ }
h₂ => 
      α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s, s₁, s₂: String

ts✝: List String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := ts✝ }

h_layout: { fst := s, rst := [] } = { fst := s₁ ++ s₂, rst := ts✝ }

∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length s, y := y }cases h_layout: { fst := s, rst := [] } = { fst := s₁ ++ s₂, rst := ts✝ }
h_layoutα: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

refl∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length (s₁ ++ s₂), cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length (s₁ ++ s₂),
      y := y }
      α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s, s₁, s₂: String

ts✝: List String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := ts✝ }

h_layout: { fst := s, rst := [] } = { fst := s₁ ++ s₂, rst := ts✝ }

∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length s, y := y }let ⟨cost₁: α
cost₁, y₁: ℕ
y₁, _⟩ := ih₁: ?m.8363 d₁
ih₁ h₁: Render d₁ c i { fst := s₁, rst := [] }
h₁α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

refl∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length (s₁ ++ s₂), cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length (s₁ ++ s₂),
      y := y }
      α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s, s₁, s₂: String

ts✝: List String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := ts✝ }

h_layout: { fst := s, rst := [] } = { fst := s₁ ++ s₂, rst := ts✝ }

∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length s, y := y }let ⟨cost₂: α
cost₂, y₂: ℕ
y₂, _⟩ := ih₂: ?m.8363 d₂
ih₂ h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }
h₂α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

refl∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length (s₁ ++ s₂), cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length (s₁ ++ s₂),
      y := y }
      α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s, s₁, s₂: String

ts✝: List String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := ts✝ }

h_layout: { fst := s, rst := [] } = { fst := s₁ ++ s₂, rst := ts✝ }

∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length s, y := y }exists F: Factory α
F.concat: {α : Type} → Factory α → α → α → α
concat cost₁: α
cost₁ cost₂: α
cost₂, max: {α : Type ?u.13779} → [self : Max α] → α → α → α
max y₁: ℕ
y₁ y₂: ℕ
y₂α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

reflMeasRender F (Doc.concat d₁ d₂) c i
  { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ }
      α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s, s₁, s₂: String

ts✝: List String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := ts✝ }

h_layout: { fst := s, rst := [] } = { fst := s₁ ++ s₂, rst := ts✝ }

∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length s, y := y }have h_ans: ?m.15959 =   Meas.concat F { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }
    { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
      x := c + String.length s₁ + String.length s₂, y := y₂ }
h_ans : { last := c: ℕ
c + String.length: String → ℕ
String.length (s₁: String
s₁ ++ s₂: String
s₂), 
                     cost := F: Factory α
F.concat: {α : Type} → Factory α → α → α → α
concat cost₁: α
cost₁ cost₂: α
cost₂, 
                     doc := Doc.concat: Doc → Doc → Doc
Doc.concat d₁: Doc
d₁ d₂: Doc
d₂,
                     x := c: ℕ
c + String.length: String → ℕ
String.length (s₁: String
s₁ ++ s₂: String
s₂), y := max: {α : Type ?u.16231} → [self : Max α] → α → α → α
max y₁: ℕ
y₁ y₂: ℕ
y₂ } = 
       Meas.concat: {α : Type} → Factory α → Meas → Meas → Meas
Meas.concat F: Factory α
F 
         { last := c: ℕ
c + String.length: String → ℕ
String.length s₁: String
s₁, 
           cost := cost₁: α
cost₁, 
           doc := d₁: Doc
d₁, x := c: ℕ
c + String.length: String → ℕ
String.length s₁: String
s₁,
           y := y₁: ℕ
y₁ } 
         { last := c: ℕ
c + String.length: String → ℕ
String.length s₁: String
s₁ + String.length: String → ℕ
String.length s₂: String
s₂, 
           cost := cost₂: α
cost₂,
           doc := d₂: Doc
d₂, 
           x := c: ℕ
c + String.length: String → ℕ
String.length s₁: String
s₁ + String.length: String → ℕ
String.length s₂: String
s₂, 
           y := y₂: ℕ
y₂ } := α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

reflMeasRender F (Doc.concat d₁ d₂) c i
  { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ }by
Goals accomplished! 🐙 
        α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

{ last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ } =   Meas.concat F { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }
    { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
      x := c + String.length s₁ + String.length s₂, y := y₂ }simp_arith [Meas.concat: {α : Type} → Factory α → Meas → Meas → Meas
Meas.concat]
Goals accomplished! 🐙
      α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s, s₁, s₂: String

ts✝: List String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := ts✝ }

h_layout: { fst := s, rst := [] } = { fst := s₁ ++ s₂, rst := ts✝ }

∃ cost y,
  MeasRender F (Doc.concat d₁ d₂) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁ d₂, x := c + String.length s, y := y }dwi { α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

h_ans: { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ } =   Meas.concat F { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }
    { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
      x := c + String.length s₁ + String.length s₂, y := y₂ }

reflMeasRender F (Doc.concat d₁ d₂) c i
  { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ }constructorα: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

h_ans: { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ } =   Meas.concat F { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }
    { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
      x := c + String.length s₁ + String.length s₂, y := y₂ }

refl.h₁MeasRender F d₁ c i ?refl.m₁
α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

h_ans: { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ } =   Meas.concat F { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }
    { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
      x := c + String.length s₁ + String.length s₂, y := y₂ }

refl.h₂MeasRender F d₂ ?refl.m₁.last i ?refl.m₂
α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

h_ans: { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ } =   Meas.concat F { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }
    { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
      x := c + String.length s₁ + String.length s₂, y := y₂ }

refl.h{ last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ } =   Meas.concat F ?refl.m₁ ?refl.m₂
α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

h_ans: { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ } =   Meas.concat F { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }
    { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
      x := c + String.length s₁ + String.length s₂, y := y₂ }

refl.m₁Meas
α: Type

F: Factory α

d₁, d₂: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁ c i { last := c + String.length s, cost := cost, doc := d₁, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂ c i { last := c + String.length s, cost := cost, doc := d₂, x := c + String.length s, y := y }

c, i: ℕ

s₁, s₂: String

h₁: Render d₁ c i { fst := s₁, rst := [] }

h₂: Render d₂ (c + String.length s₁) i { fst := s₂, rst := [] }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁ c i { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂ (c + String.length s₁) i
  { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
    x := c + String.length s₁ + String.length s₂, y := y₂ }

h_ans: { last := c + String.length (s₁ ++ s₂), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁ d₂,
    x := c + String.length (s₁ ++ s₂), y := max y₁ y₂ } =   Meas.concat F { last := c + String.length s₁, cost := cost₁, doc := d₁, x := c + String.length s₁, y := y₁ }
    { last := c + String.length s₁ + String.length s₂, cost := cost₂, doc := d₂,
      x := c + String.length s₁ + String.length s₂, y := y₂ }

refl.m₂Meas }
Goals accomplished! 🐙
    α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }case concat_multi => 
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

ss✝: List String

slast✝, s✝, t✝: String

ts✝: List String

h_non_empty✝: ss✝ ≠ []

h_last✝: slast✝ = List.getLast ss✝ h_non_empty✝

h₂✝: Render d₂✝ (String.length slast✝) i { fst := t✝, rst := ts✝ }

h₁✝: Render d₁✝ c i { fst := s✝, rst := ss✝ }

h_layout: { fst := s, rst := [] } = { fst := s✝, rst := List.dropLast ss✝ ++ [slast✝ ++ t✝] ++ ts✝ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }injection h_layout: { fst := s, rst := [] } = { fst := s✝, rst := List.dropLast ss✝ ++ [slast✝ ++ t✝] ++ ts✝ }
h_layoutα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

ss✝: List String

slast✝, s✝, t✝: String

ts✝: List String

h_non_empty✝: ss✝ ≠ []

h_last✝: slast✝ = List.getLast ss✝ h_non_empty✝

h₂✝: Render d₂✝ (String.length slast✝) i { fst := t✝, rst := ts✝ }

h₁✝: Render d₁✝ c i { fst := s✝, rst := ss✝ }

fst_eq✝: s = s✝

rst_eq✝: [] = List.dropLast ss✝ ++ [slast✝ ++ t✝] ++ ts✝

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y } 
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

ih₂: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

ss✝: List String

slast✝, s✝, t✝: String

ts✝: List String

h_non_empty✝: ss✝ ≠ []

h_last✝: slast✝ = List.getLast ss✝ h_non_empty✝

h₂✝: Render d₂✝ (String.length slast✝) i { fst := t✝, rst := ts✝ }

h₁✝: Render d₁✝ c i { fst := s✝, rst := ss✝ }

h_layout: { fst := s, rst := [] } = { fst := s✝, rst := List.dropLast ss✝ ++ [slast✝ ++ t✝] ++ ts✝ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.concat d₁✝ d₂✝, x := c + String.length s, y := y }simp at *
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

F: Factory α

h_render: Render d c i { fst := s, rst := [] }

∃ cost y, MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }case choice =>
    α: Type

F: Factory α

d₁✝, d₂✝: Doc

d₁_ih✝: ∀ {c i : ℕ} {s : String},
  Render d₁✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₁✝ c i { last := c + String.length s, cost := cost, doc := d₁✝, x := c + String.length s, y := y }

d₂_ih✝: ∀ {c i : ℕ} {s : String},
  Render d₂✝ c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d₂✝ c i { last := c + String.length s, cost := cost, doc := d₂✝, x := c + String.length s, y := y }

c, i: ℕ

s: String

h_render: Render (Doc.choice d₁✝ d₂✝) c i { fst := s, rst := [] }

∃ cost y,
  MeasRender F (Doc.choice d₁✝ d₂✝) c i
    { last := c + String.length s, cost := cost, doc := Doc.choice d₁✝ d₂✝, x := c + String.length s, y := y }cases h_render: Render (Doc.choice d₁✝ d₂✝) c i { fst := s, rst := [] }
h_render
Goals accomplished! 🐙

/--
Correctness of the measure computation relation 
when it results in multiple lines (second part of Theorem 5.3)
-/
theorem MeasRender_multi_correct: ∀ {α : Type} {d : Doc} {c i : ℕ} {s : String} {ss : List String} (F : Factory α),
  Render d c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
MeasRender_multi_correct (F: Factory α
F : Factory: Type → Type
Factory α: ?m.28209
α) 
    (h_render: Render d c i { fst := s, rst := ss }
h_render : Render: Doc → ℕ → ℕ → Layout → Prop
Render d: ?m.28215
d c: ?m.28221
c i: ?m.28227
i ⟨s: ?m.28235
s, ss: ?m.28243
ss⟩) (h_non_empty: ss ≠ []
h_non_empty : ss: ?m.28243
ss ≠ []: List ?m.28255
[]) : 
    ∃ cost: ?m.28262
cost y: ?m.28267
y, MeasRender: {α : Type} → Factory α → Doc → ℕ → ℕ → Meas → Prop
MeasRender F: Factory α
F d: ?m.28215
d c: ?m.28221
c i: ?m.28227
i ⟨(List.getLast: {α : Type ?u.28279} → (as : List α) → as ≠ [] → α
List.getLast ss: ?m.28243
ss h_non_empty: ss ≠ []
h_non_empty).length: String → ℕ
length,
                                  cost: ?m.28262
cost, d: ?m.28215
d, 
                                  Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset c: ?m.28221
c ⟨s: ?m.28235
s, ss: ?m.28243
ss⟩, y: ?m.28267
y⟩ := by
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

ss: List String

F: Factory α

h_render: Render d c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F d c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }induction d: Doc
d generalizing c: ℕ
c i: ℕ
i s: String
s ss: List String
ssα: Type

F: Factory α

s✝: String

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.text s✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

text∃ cost y,
  MeasRender F (Doc.text s✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.text s✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
α: Type

F: Factory α

c, i: ℕ

s: String

ss: List String

h_render: Render Doc.nl c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

nl∃ cost y,
  MeasRender F Doc.nl c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nl,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
α: Type

F: Factory α

d₁✝, d₂✝: Doc

d₁_ih✝: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

d₂_ih✝: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

concat∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
α: Type

F: Factory α

n✝: ℕ

d✝: Doc

d_ih✝: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

nest∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
α: Type

F: Factory α

d✝: Doc

d_ih✝: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.align d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

align∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
α: Type

F: Factory α

d₁✝, d₂✝: Doc

d₁_ih✝: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

d₂_ih✝: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.choice d₁✝ d₂✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

choice∃ cost y,
  MeasRender F (Doc.choice d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.choice d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
  α: Type

d: Doc

c, i: ℕ

s: String

ss: List String

F: Factory α

h_render: Render d c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F d c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }case text => 
    α: Type

F: Factory α

s✝: String

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.text s✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.text s✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.text s✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }cases h_render: Render (Doc.text s✝) c i { fst := s, rst := ss }
h_renderα: Type

F: Factory α

s✝: String

c, i: ℕ

h_non_empty: [] ≠ []

text∃ cost y,
  MeasRender F (Doc.text s✝) c i
    { last := String.length (List.getLast [] h_non_empty), cost := cost, doc := Doc.text s✝,
      x := Layout.max_with_offset c { fst := s✝, rst := [] }, y := y } 
    α: Type

F: Factory α

s✝: String

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.text s✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.text s✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.text s✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }simp at h_non_empty: [] ≠ []
h_non_empty
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

ss: List String

F: Factory α

h_render: Render d c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F d c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }case nl =>
    α: Type

F: Factory α

c, i: ℕ

s: String

ss: List String

h_render: Render Doc.nl c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F Doc.nl c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nl,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }exists F: Factory α
F.nl: {α : Type} → Factory α → ℕ → α
nl i: ℕ
i, i: ℕ
iα: Type

F: Factory α

c, i: ℕ

s: String

ss: List String

h_render: Render Doc.nl c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

MeasRender F Doc.nl c i
  { last := String.length (List.getLast ss h_non_empty), cost := Factory.nl F i, doc := Doc.nl,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := i }
    α: Type

F: Factory α

c, i: ℕ

s: String

ss: List String

h_render: Render Doc.nl c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F Doc.nl c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nl,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }cases h_render: Render Doc.nl c i { fst := s, rst := ss }
h_renderα: Type

F: Factory α

c, i: ℕ

h_non_empty: [List.asString (List.replicate i (Char.ofNat 32))] ≠ []

nlMeasRender F Doc.nl c i
  { last := String.length (List.getLast [List.asString (List.replicate i (Char.ofNat 32))] h_non_empty),
    cost := Factory.nl F i, doc := Doc.nl,
    x := Layout.max_with_offset c { fst := "", rst := [List.asString (List.replicate i (Char.ofNat 32))] }, y := i } 
    α: Type

F: Factory α

c, i: ℕ

s: String

ss: List String

h_render: Render Doc.nl c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F Doc.nl c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nl,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }simp only [
      String.length: String → ℕ
String.length, List.asString: List Char → String
List.asString, ne_eq: ∀ {α : Sort ?u.29442} (a b : α), (a ≠ b) = ¬a = b
ne_eq, List.getLast_singleton': ∀ {α : Type ?u.29451} (a : α), List.getLast [a] (_ : [a] ≠ []) = a
List.getLast_singleton',
      List.length_replicate: ∀ {α : Type ?u.29465} (n : ℕ) (a : α), List.length (List.replicate n a) = n
List.length_replicate, Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset, List.length_nil: ∀ {α : Type ?u.29479}, List.length [] = 0
List.length_nil,
      add_zero: ∀ {M : Type ?u.29483} [inst : AddZeroClass M] (a : M), a + 0 = a
add_zero, List.foldl: {α : Type ?u.29501} → {β : Type ?u.29500} → (α → β → α) → α → List β → α
List.foldl, ge_iff_le: ∀ {α : Type ?u.29953} [inst : LE α] {a b : α}, a ≥ b ↔ b ≤ a
ge_iff_le, nonpos_iff_eq_zero: ∀ {α : Type ?u.29975} [inst : CanonicallyOrderedAddMonoid α] {a : α}, a ≤ 0 ↔ a = 0
nonpos_iff_eq_zero, zero_le: ∀ {α : Type ?u.29997} [inst : CanonicallyOrderedAddMonoid α] (a : α), 0 ≤ a
zero_le,
      max_eq_right: ∀ {α : Type ?u.30016} [inst : LinearOrder α] {a b : α}, a ≤ b → max a b = b
max_eq_right
    ]α: Type

F: Factory α

c, i: ℕ

h_non_empty: [List.asString (List.replicate i (Char.ofNat 32))] ≠ []

nlMeasRender F Doc.nl c i { last := i, cost := Factory.nl F i, doc := Doc.nl, x := max c i, y := i }
    α: Type

F: Factory α

c, i: ℕ

s: String

ss: List String

h_render: Render Doc.nl c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F Doc.nl c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nl,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }constructor
Goals accomplished! 🐙    
  α: Type

d: Doc

c, i: ℕ

s: String

ss: List String

F: Factory α

h_render: Render d c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F d c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }case nest ih: ?m.28338 d✝
ih  => 
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }cases h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := ss }
h_renderα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h✝: Render d✝ c (i + n✝) { fst := s, rst := ss }

nest∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }rename_i h: Render d✝ c (i + n✝) { fst := s, rst := ss }
hα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h: Render d✝ c (i + n✝) { fst := s, rst := ss }

nest∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }let ⟨cost: α
cost, ⟨y: ℕ
y, _⟩⟩ := ih: ?m.28338 d✝
ih h: Render d✝ c (i + n✝) { fst := s, rst := ss }
h h_non_empty: ss ≠ []
h_non_emptyα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h: Render d✝ c (i + n✝) { fst := s, rst := ss }

cost: α

y: ℕ

h✝: MeasRender F d✝ c (i + n✝)
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

nest∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }exists cost: α
cost, y: ℕ
yα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h: Render d✝ c (i + n✝) { fst := s, rst := ss }

cost: α

y: ℕ

h✝: MeasRender F d✝ c (i + n✝)
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

nestMeasRender F (Doc.nest n✝ d✝) c i
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }constructorα: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h: Render d✝ c (i + n✝) { fst := s, rst := ss }

cost: α

y: ℕ

h✝: MeasRender F d✝ c (i + n✝)
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

nest.hMeasRender F d✝ c (i + n✝)
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

n✝: ℕ

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.nest n✝ d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.nest n✝ d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.nest n✝ d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }assumption
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

ss: List String

F: Factory α

h_render: Render d c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F d c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }case align ih: ?m.28338 d✝
ih => 
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.align d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }cases h_render: Render (Doc.align d✝) c i { fst := s, rst := ss }
h_renderα: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h✝: Render d✝ c c { fst := s, rst := ss }

align∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.align d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }rename_i h: Render d✝ c c { fst := s, rst := ss }
hα: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h: Render d✝ c c { fst := s, rst := ss }

align∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.align d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }let ⟨cost: α
cost, ⟨y: ℕ
y, _⟩⟩ := ih: ?m.28338 d✝
ih h: Render d✝ c c { fst := s, rst := ss }
h h_non_empty: ss ≠ []
h_non_emptyα: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h: Render d✝ c c { fst := s, rst := ss }

cost: α

y: ℕ

h✝: MeasRender F d✝ c c
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

align∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.align d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }exists cost: α
cost, (max: {α : Type ?u.33046} → [self : Max α] → α → α → α
max i: ℕ
i y: ℕ
y)α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h: Render d✝ c c { fst := s, rst := ss }

cost: α

y: ℕ

h✝: MeasRender F d✝ c c
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

alignMeasRender F (Doc.align d✝) c i
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := max i y }
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.align d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }constructorα: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_non_empty: ss ≠ []

h: Render d✝ c c { fst := s, rst := ss }

cost: α

y: ℕ

h✝: MeasRender F d✝ c c
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

align.hMeasRender F d✝ c c
  { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
    α: Type

F: Factory α

d✝: Doc

ih: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.align d✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.align d✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.align d✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }assumption
Goals accomplished! 🐙
  α: Type

d: Doc

c, i: ℕ

s: String

ss: List String

F: Factory α

h_render: Render d c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F d c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }case choice => α: Type

F: Factory α

d₁✝, d₂✝: Doc

d₁_ih✝: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

d₂_ih✝: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.choice d₁✝ d₂✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.choice d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.choice d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }cases h_render: Render (Doc.choice d₁✝ d₂✝) c i { fst := s, rst := ss }
h_render
Goals accomplished! 🐙 
  α: Type

d: Doc

c, i: ℕ

s: String

ss: List String

F: Factory α

h_render: Render d c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F d c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }case concat ih₁: ?m.28338 d₁✝
ih₁ ih₂: ?m.28338 d₂✝
ih₂ => 
    α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }cases h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := ss }
h_renderα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s✝, t✝: String

h₁✝: Render d₁✝ c i { fst := s✝, rst := [] }

h₂✝: Render d₂✝ (c + String.length s✝) i { fst := t✝, rst := ss }

concat_one∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s✝ ++ t✝, rst := ss }, y := y }
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss✝: List String

slast✝, t✝: String

ts✝: List String

h_non_empty✝: ss✝ ≠ []

h_last✝: slast✝ = List.getLast ss✝ h_non_empty✝

h₂✝: Render d₂✝ (String.length slast✝) i { fst := t✝, rst := ts✝ }

h₁✝: Render d₁✝ c i { fst := s, rst := ss✝ }

h_non_empty: List.dropLast ss✝ ++ [slast✝ ++ t✝] ++ ts✝ ≠ []

concat_multi∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss✝ ++ [slast✝ ++ t✝] ++ ts✝) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss✝ ++ [slast✝ ++ t✝] ++ ts✝ }, y := y } 
    α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }case concat_one s: String
s t: String
t h₁: Render d₁✝ c i { fst := s, rst := [] }
h₁ h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }
h₂ => 
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := y }let ⟨cost₁: α
cost₁, ⟨y₁: ℕ
y₁, _⟩⟩ := MeasRender_single_correct: ∀ {α : Type} {d : Doc} {c i : ℕ} {s : String} (F : Factory α),
  Render d c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }
MeasRender_single_correct F: Factory α
F h₁: Render d₁✝ c i { fst := s, rst := [] }
h₁α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := y }
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := y }let ⟨cost₂: α
cost₂, ⟨y₂: ℕ
y₂, _⟩⟩ := ih₂: ?m.28338 d₂✝
ih₂ h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }
h₂ h_non_empty: ss ≠ []
h_non_emptyα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := y }
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := y }exists F: Factory α
F.concat: {α : Type} → Factory α → α → α → α
concat cost₁: α
cost₁ cost₂: α
cost₂, max: {α : Type ?u.35617} → [self : Max α] → α → α → α
max y₁: ℕ
y₁ y₂: ℕ
y₂α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast ss h_non_empty), cost := Factory.concat F cost₁ cost₂,
    doc := Doc.concat d₁✝ d₂✝, x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := max y₁ y₂ }
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := y }have h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })
h_x : Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset c: ℕ
c ⟨s: String
s ++ t: String
t, ss: List String
ss⟩ = 
          max: {α : Type ?u.38128} → [self : Max α] → α → α → α
max (c: ℕ
c + s: String
s.length: String → ℕ
length) (Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset (c: ℕ
c + s: String
s.length: String → ℕ
length) ⟨t: String
t, ss: List String
ss⟩) := α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast ss h_non_empty), cost := Factory.concat F cost₁ cost₂,
    doc := Doc.concat d₁✝ d₂✝, x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := max y₁ y₂ }by
Goals accomplished! 🐙 α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }){α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })simp [Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset, String.length: String → ℕ
String.length, String.append: String → String → String
String.append, Nat.add_assoc: ∀ (n m k : ℕ), n + m + k = n + (m + k)
Nat.add_assoc]
Goals accomplished! 🐙
      }
Goals accomplished! 🐙
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := y }rw [α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast ss h_non_empty), cost := Factory.concat F cost₁ cost₂,
    doc := Doc.concat d₁✝ d₂✝, x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := max y₁ y₂ }h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })
h_xα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast ss h_non_empty), cost := Factory.concat F cost₁ cost₂,
    doc := Doc.concat d₁✝ d₂✝,
    x := max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }),
    y := max y₁ y₂ }]α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast ss h_non_empty), cost := Factory.concat F cost₁ cost₂,
    doc := Doc.concat d₁✝ d₂✝,
    x := max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }),
    y := max y₁ y₂ }
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s ++ t, rst := ss }, y := y }dwi { α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast ss h_non_empty), cost := Factory.concat F cost₁ cost₂,
    doc := Doc.concat d₁✝ d₂✝,
    x := max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }),
    y := max y₁ y₂ }apply MeasRender.concat: ∀ {α : Type} {F : Factory α} {d₁ : Doc} {c i : ℕ} {m₁ : Meas} {d₂ : Doc} {m₂ m : Meas},
  MeasRender F d₁ c i m₁ →
    MeasRender F d₂ m₁.last i m₂ → m = Meas.concat F m₁ m₂ → MeasRender F (Doc.concat d₁ d₂) c i m
MeasRender.concatα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

h₁MeasRender F d₁✝ c i ?m₁
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

h₂MeasRender F d₂✝ ?m₁.last i ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

h{ last := String.length (List.getLast ss h_non_empty), cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }),
    y := max y₁ y₂ } =   Meas.concat F ?m₁ ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

m₁Meas
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

ss: List String

h_non_empty: ss ≠ []

s, t: String

h₁: Render d₁✝ c i { fst := s, rst := [] }

h₂: Render d₂✝ (c + String.length s) i { fst := t, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i { last := c + String.length s, cost := cost₁, doc := d₁✝, x := c + String.length s, y := y₁ }

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (c + String.length s) i
  { last := String.length (List.getLast ss h_non_empty), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (c + String.length s) { fst := t, rst := ss }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s ++ t, rst := ss } =   max (c + String.length s) (Layout.max_with_offset (c + String.length s) { fst := t, rst := ss })

m₂Meas }
Goals accomplished! 🐙
    α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

h_render: Render (Doc.concat d₁✝ d₂✝) c i { fst := s, rst := ss }

h_non_empty: ss ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }case concat_multi ss: List String
ss slast: String
slast t: String
t ts: List String
ts _ h_last: slast = List.getLast ss h_non_empty✝
h_last h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }
h₂ h₁: Render d₁✝ c i { fst := s, rst := ss }
h₁ => 
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }let ⟨cost₁: α
cost₁, ⟨y₁: ℕ
y₁, _⟩⟩ := ih₁: ?m.28338 d₁✝
ih₁ h₁: Render d₁✝ c i { fst := s, rst := ss }
h₁ (α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }by
Goals accomplished! 🐙 α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

ss ≠ []assumption
Goals accomplished! 🐙)α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }have h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss ?m.59426])
h_droplast : List.map: {α : Type ?u.59401} → {β : Type ?u.59400} → (α → β) → List α → List β
List.map String.length: String → ℕ
String.length ss: List String
ss = 
          List.map: {α : Type ?u.59409} → {β : Type ?u.59408} → (α → β) → List α → List β
List.map String.length: String → ℕ
String.length 
                   (List.dropLast: {α : Type ?u.59418} → List α → List α
List.dropLast ss: List String
ss ++ [List.getLast: {α : Type ?u.59423} → (as : List α) → as ≠ [] → α
List.getLast ss: List String
ss (α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }by
Goals accomplished! 🐙 α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

ss ≠ []assumption
Goals accomplished! 🐙)]) := α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }by
Goals accomplished! 🐙
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])simp [List.dropLast_append_getLast: ∀ {α : Type ?u.59527} {l : List α} (h : l ≠ []), List.dropLast l ++ [List.getLast l h] = l
List.dropLast_append_getLast]
Goals accomplished! 🐙
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }cases ts: List String
tsα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

nil∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

head✝: String

tail✝: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := head✝ :: tail✝ }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ head✝ :: tail✝ ≠ []

cons∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ head✝ :: tail✝) h_non_empty),
      cost := cost, doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ head✝ :: tail✝ }, y := y }
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }case nil => 
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }let ⟨cost₂: α
cost₂, ⟨y₂: ℕ
y₂, _⟩⟩ := MeasRender_single_correct: ∀ {α : Type} {d : Doc} {c i : ℕ} {s : String} (F : Factory α),
  Render d c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }
MeasRender_single_correct F: Factory α
F h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }
h₂α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }exists F: Factory α
F.concat: {α : Type} → Factory α → α → α → α
concat cost₁: α
cost₁ cost₂: α
cost₂, max: {α : Type ?u.59969} → [self : Max α] → α → α → α
max y₁: ℕ
y₁ y₂: ℕ
y₂α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := max y₁ y₂ }
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }have h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)
h_x : Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset c: ℕ
c ⟨s: String
s, List.dropLast: {α : Type ?u.62543} → List α → List α
List.dropLast ss: List String
ss ++ [slast: String
slast ++ t: String
t] ++ []: List ?m.62586
[]⟩ = 
            max: {α : Type ?u.62650} → [self : Max α] → α → α → α
max (Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset c: ℕ
c ⟨s: String
s, ss: List String
ss⟩) (slast: String
slast.length: String → ℕ
length + t: String
t.length: String → ℕ
length) := α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := max y₁ y₂ }by
Goals accomplished! 🐙 α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t){α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)simp [Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset]α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t)) =   max (max (c + String.length s) (List.foldl max 0 (List.map String.length ss))) (String.length slast + String.length t)
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)rw [α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t)) =   max (max (c + String.length s) (List.foldl max 0 (List.map String.length ss))) (String.length slast + String.length t)h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])
h_droplast,α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t)) =   max
    (max (c + String.length s)
      (List.foldl max 0 (List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝]))))
    (String.length slast + String.length t) α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t)) =   max (max (c + String.length s) (List.foldl max 0 (List.map String.length ss))) (String.length slast + String.length t)List.map_append: ∀ {α : Type ?u.93713} {β : Type ?u.93714} (f : α → β) (l₁ l₂ : List α),
  List.map f (l₁ ++ l₂) = List.map f l₁ ++ List.map f l₂
List.map_append,α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t)) =   max
    (max (c + String.length s)
      (List.foldl max 0
        (List.map String.length (List.dropLast ss) ++ List.map String.length [List.getLast ss h_non_empty✝])))
    (String.length slast + String.length t) α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t)) =   max (max (c + String.length s) (List.foldl max 0 (List.map String.length ss))) (String.length slast + String.length t)List.foldl_append: ∀ {α : Type ?u.93728} {β : Type ?u.93729} (f : β → α → β) (b : β) (l l' : List α),
  List.foldl f b (l ++ l') = List.foldl f (List.foldl f b l) l'
List.foldl_appendα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t)) =   max
    (max (c + String.length s)
      (List.foldl max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
        (List.map String.length [List.getLast ss h_non_empty✝])))
    (String.length slast + String.length t)]α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t)) =   max
    (max (c + String.length s)
      (List.foldl max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
        (List.map String.length [List.getLast ss h_non_empty✝])))
    (String.length slast + String.length t)
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)subst h_last: slast = List.getLast ss h_non_empty✝
h_lastα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ [] ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast ss h_non_empty✝) + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length (List.getLast ss h_non_empty✝) + String.length t, y := y₂ }

max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
      (String.length (List.getLast ss h_non_empty✝) + String.length t)) =   max
    (max (c + String.length s)
      (List.foldl max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
        (List.map String.length [List.getLast ss h_non_empty✝])))
    (String.length (List.getLast ss h_non_empty✝) + String.length t)
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)simp [max_assoc: ∀ {α : Type ?u.93781} [inst : LinearOrder α] (a b c : α), max (max a b) c = max a (max b c)
max_assoc]
Goals accomplished! 🐙
        }
Goals accomplished! 🐙
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }rw [α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := max y₁ y₂ }h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)
h_xα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t),
    y := max y₁ y₂ }]α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t),
    y := max y₁ y₂ }
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }dwi { α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t),
    y := max y₁ y₂ }apply MeasRender.concat: ∀ {α : Type} {F : Factory α} {d₁ : Doc} {c i : ℕ} {m₁ : Meas} {d₂ : Doc} {m₂ m : Meas},
  MeasRender F d₁ c i m₁ →
    MeasRender F d₂ m₁.last i m₂ → m = Meas.concat F m₁ m₂ → MeasRender F (Doc.concat d₁ d₂) c i m
MeasRender.concatα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

h₁MeasRender F d₁✝ c i ?m₁
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

h₂MeasRender F d₂✝ ?m₁.last i ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

h{ last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t),
    y := max y₁ y₂ } =   Meas.concat F ?m₁ ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

m₁Meas
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

m₂Meas }α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

h₂MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

h{ last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t),
    y := max y₁ y₂ } =   Meas.concat F
    { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }
    ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

m₂Meas
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }case h₂ => α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i ?m₂subst h_last: slast = List.getLast ss h_non_empty✝
h_lastα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ [] ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast ss h_non_empty✝) + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length (List.getLast ss h_non_empty✝) + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (String.length (List.getLast ss h_non_empty✝) + String.length t)

MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i (?m.143627 (_ : List.getLast ss h_non_empty✝ = List.getLast ss h_non_empty✝) h₂ h_non_empty h✝ h_x);α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ [] ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast ss h_non_empty✝) + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length (List.getLast ss h_non_empty✝) + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (String.length (List.getLast ss h_non_empty✝) + String.length t)

MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i (?m.143627 (_ : List.getLast ss h_non_empty✝ = List.getLast ss h_non_empty✝) h₂ h_non_empty h✝ h_x) α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i ?m₂simpa
Goals accomplished! 🐙 
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] }, y := y }case h => α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := [] }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ [] ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length slast + String.length t, cost := cost₂, doc := d₂✝,
    x := String.length slast + String.length t, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ [] } =   max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t)

{ last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ []) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := max (Layout.max_with_offset c { fst := s, rst := ss }) (String.length slast + String.length t),
    y := max y₁ y₂ } =   Meas.concat F
    { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }
    { last := String.length (List.getLast ss h_non_empty✝) + String.length t, cost := cost₂, doc := d₂✝,
      x := String.length (List.getLast ss h_non_empty✝) + String.length t, y := y₂ }simp [Meas.concat: {α : Type} → Factory α → Meas → Meas → Meas
Meas.concat, *]
Goals accomplished! 🐙
            
      α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

ts: List String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := ts }

h₁: Render d₁✝ c i { fst := s, rst := ss }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ ts ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ ts) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ ts }, y := y }case cons hd: ?m.59716
hd tl: List ?m.59716
tl => 
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }let ⟨cost₂: α
cost₂, ⟨y₂: ℕ
y₂, _⟩⟩ := ih₂: ?m.28338 d₂✝
ih₂ h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }
h₂ (α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }by
Goals accomplished! 🐙 α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

hd :: tl ≠ []simp
Goals accomplished! 🐙)α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }exists F: Factory α
F.concat: {α : Type} → Factory α → α → α → α
concat cost₁: α
cost₁ cost₂: α
cost₂, max: {α : Type ?u.147126} → [self : Max α] → α → α → α
max y₁: ℕ
y₁ y₂: ℕ
y₂α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := max y₁ y₂ }
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }have h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })
h_x : Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset c: ℕ
c ⟨s: String
s, List.dropLast: {α : Type ?u.149815} → List α → List α
List.dropLast ss: List String
ss ++ [slast: String
slast ++ t: String
t] ++ hd: ?m.59716
hd :: tl: List ?m.59716
tl⟩ = 
            max: {α : Type ?u.149907} → [self : Max α] → α → α → α
max (Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset c: ℕ
c ⟨s: String
s, ss: List String
ss⟩) 
                (Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset slast: String
slast.length: String → ℕ
length ⟨t: String
t, hd: ?m.59716
hd :: tl: List ?m.59716
tl⟩) := α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := max y₁ y₂ }by
Goals accomplished! 🐙 α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }){α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })simp only [
            Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset, List.append_assoc: ∀ {α : Type ?u.149934} (as bs cs : List α), as ++ bs ++ cs = as ++ (bs ++ cs)
List.append_assoc, List.singleton_append: ∀ {α : Type ?u.149951} {x : α} {l : List α}, [x] ++ l = x :: l
List.singleton_append,
            List.map_append: ∀ {α : Type ?u.149970} {β : Type ?u.149971} (f : α → β) (l₁ l₂ : List α),
  List.map f (l₁ ++ l₂) = List.map f l₁ ++ List.map f l₂
List.map_append, List.map: {α : Type ?u.149989} → {β : Type ?u.149988} → (α → β) → List α → List β
List.map, String.length_append: ∀ (as bs : String), String.length (as ++ bs) = String.length as + String.length bs
String.length_append, List.foldl_append: ∀ {α : Type ?u.150299} {β : Type ?u.150300} (f : β → α → β) (b : β) (l l' : List α),
  List.foldl f b (l ++ l') = List.foldl f (List.foldl f b l) l'
List.foldl_append,
            List.foldl: {α : Type ?u.150329} → {β : Type ?u.150328} → (α → β → α) → α → List β → α
List.foldl, ge_iff_le: ∀ {α : Type ?u.150369} [inst : LE α] {a b : α}, a ≥ b ↔ b ≤ a
ge_iff_le, le_max_iff: ∀ {α : Type ?u.150391} [inst : LinearOrder α] {a b c : α}, a ≤ max b c ↔ a ≤ b ∨ a ≤ c
le_max_iff, max_le_iff: ∀ {α : Type ?u.150418} [inst : LinearOrder α] {a b c : α}, max a b ≤ c ↔ a ≤ c ∧ b ≤ c
max_le_iff, nonpos_iff_eq_zero: ∀ {α : Type ?u.150447} [inst : CanonicallyOrderedAddMonoid α] {a : α}, a ≤ 0 ↔ a = 0
nonpos_iff_eq_zero, 
            zero_le: ∀ {α : Type ?u.150465} [inst : CanonicallyOrderedAddMonoid α] (a : α), 0 ≤ a
zero_le, max_eq_right: ∀ {α : Type ?u.150477} [inst : LinearOrder α] {a b : α}, a ≤ b → max a b = b
max_eq_right
          ]α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max (max (c + String.length s) (List.foldl max 0 (List.map String.length ss)))
    (max (String.length slast + String.length t) (List.foldl max (String.length hd) (List.map String.length tl)))
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })rw [α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max (max (c + String.length s) (List.foldl max 0 (List.map String.length ss)))
    (max (String.length slast + String.length t) (List.foldl max (String.length hd) (List.map String.length tl)))h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])
h_droplast,α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max
    (max (c + String.length s)
      (List.foldl max 0 (List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝]))))
    (max (String.length slast + String.length t) (List.foldl max (String.length hd) (List.map String.length tl))) α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max (max (c + String.length s) (List.foldl max 0 (List.map String.length ss)))
    (max (String.length slast + String.length t) (List.foldl max (String.length hd) (List.map String.length tl)))List.map_append: ∀ {α : Type ?u.152905} {β : Type ?u.152906} (f : α → β) (l₁ l₂ : List α),
  List.map f (l₁ ++ l₂) = List.map f l₁ ++ List.map f l₂
List.map_append,α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max
    (max (c + String.length s)
      (List.foldl max 0
        (List.map String.length (List.dropLast ss) ++ List.map String.length [List.getLast ss h_non_empty✝])))
    (max (String.length slast + String.length t) (List.foldl max (String.length hd) (List.map String.length tl))) α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max (max (c + String.length s) (List.foldl max 0 (List.map String.length ss)))
    (max (String.length slast + String.length t) (List.foldl max (String.length hd) (List.map String.length tl)))List.foldl_append: ∀ {α : Type ?u.152921} {β : Type ?u.152922} (f : β → α → β) (b : β) (l l' : List α),
  List.foldl f b (l ++ l') = List.foldl f (List.foldl f b l) l'
List.foldl_appendα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max
    (max (c + String.length s)
      (List.foldl max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
        (List.map String.length [List.getLast ss h_non_empty✝])))
    (max (String.length slast + String.length t) (List.foldl max (String.length hd) (List.map String.length tl)))]α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (max (List.foldl max 0 (List.map String.length (List.dropLast ss))) (String.length slast + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max
    (max (c + String.length s)
      (List.foldl max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
        (List.map String.length [List.getLast ss h_non_empty✝])))
    (max (String.length slast + String.length t) (List.foldl max (String.length hd) (List.map String.length tl)))
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })subst h_last: slast = List.getLast ss h_non_empty✝
h_lastα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max
        (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
          (String.length (List.getLast ss h_non_empty✝) + String.length t))
        (String.length hd))
      (List.map String.length tl)) =   max
    (max (c + String.length s)
      (List.foldl max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
        (List.map String.length [List.getLast ss h_non_empty✝])))
    (max (String.length (List.getLast ss h_non_empty✝) + String.length t)
      (List.foldl max (String.length hd) (List.map String.length tl)))
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })simp only [
            ge_iff_le: ∀ {α : Type ?u.152992} [inst : LE α] {a b : α}, a ≥ b ↔ b ≤ a
ge_iff_le, le_max_iff: ∀ {α : Type ?u.153008} [inst : LinearOrder α] {a b c : α}, a ≤ max b c ↔ a ≤ b ∨ a ≤ c
le_max_iff, max_le_iff: ∀ {α : Type ?u.153027} [inst : LinearOrder α] {a b c : α}, max a b ≤ c ↔ a ≤ c ∧ b ≤ c
max_le_iff, max_assoc: ∀ {α : Type ?u.153046} [inst : LinearOrder α] (a b c : α), max (max a b) c = max a (max b c)
max_assoc, List.foldl: {α : Type ?u.153059} → {β : Type ?u.153058} → (α → β → α) → α → List β → α
List.foldl, 
            add_le_iff_nonpos_right: ∀ {α : Type ?u.153099} [inst : AddZeroClass α] [inst_1 : LE α]
  [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
  [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b : α}, a + b ≤ a ↔ b ≤ 0
add_le_iff_nonpos_right, nonpos_iff_eq_zero: ∀ {α : Type ?u.153134} [inst : CanonicallyOrderedAddMonoid α] {a : α}, a ≤ 0 ↔ a = 0
nonpos_iff_eq_zero, le_add_iff_nonneg_right: ∀ {α : Type ?u.153156} [inst : AddZeroClass α] [inst_1 : LE α]
  [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
  [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b : α}, a ≤ a + b ↔ 0 ≤ b
le_add_iff_nonneg_right,
            zero_le: ∀ {α : Type ?u.153191} [inst : CanonicallyOrderedAddMonoid α] (a : α), 0 ≤ a
zero_le, and_true: ∀ (p : Prop), (p ∧ True) = p
and_true, true_or: ∀ (p : Prop), (True ∨ p) = True
true_or, max_eq_right: ∀ {α : Type ?u.153220} [inst : LinearOrder α] {a b : α}, a ≤ b → max a b = b
max_eq_right
          ]α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
        (max (String.length (List.getLast ss h_non_empty✝) + String.length t) (String.length hd)))
      (List.map String.length tl)) =   max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
      (max (String.length (List.getLast ss h_non_empty✝) + String.length t)
        (List.foldl max (String.length hd) (List.map String.length tl))))
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })dwi { α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl }, y := y₂ }

max (c + String.length s)
    (List.foldl max
      (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
        (max (String.length (List.getLast ss h_non_empty✝) + String.length t) (String.length hd)))
      (List.map String.length tl)) =   max (c + String.length s)
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
      (max (String.length (List.getLast ss h_non_empty✝) + String.length t)
        (List.foldl max (String.length hd) (List.map String.length tl))))apply congr: ∀ {α : Sort ?u.159710} {β : Sort ?u.159709} {f₁ f₂ : α → β} {a₁ a₂ : α}, f₁ = f₂ → a₁ = a₂ → f₁ a₁ = f₂ a₂
congrα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl }, y := y₂ }

h₁max (c + String.length s) = max (c + String.length s)
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl }, y := y₂ }

h₂List.foldl max
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
      (max (String.length (List.getLast ss h_non_empty✝) + String.length t) (String.length hd)))
    (List.map String.length tl) =   max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
    (max (String.length (List.getLast ss h_non_empty✝) + String.length t)
      (List.foldl max (String.length hd) (List.map String.length tl))) }α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl }, y := y₂ }

h₂List.foldl max
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
      (max (String.length (List.getLast ss h_non_empty✝) + String.length t) (String.length hd)))
    (List.map String.length tl) =   max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
    (max (String.length (List.getLast ss h_non_empty✝) + String.length t)
      (List.foldl max (String.length hd) (List.map String.length tl)))
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })case h₂ => α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl }, y := y₂ }

List.foldl max
    (max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
      (max (String.length (List.getLast ss h_non_empty✝) + String.length t) (String.length hd)))
    (List.map String.length tl) =   max (List.foldl max 0 (List.map String.length (List.dropLast ss)))
    (max (String.length (List.getLast ss h_non_empty✝) + String.length t)
      (List.foldl max (String.length hd) (List.map String.length tl)))simp [List.fold_max_max_eq_max_fold_max: ∀ {xs : List ℕ} {a b : ℕ}, List.foldl max (max a b) xs = max a (List.foldl max b xs)
List.fold_max_max_eq_max_fold_max]
Goals accomplished! 🐙
        }
Goals accomplished! 🐙
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }rw [α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := max y₁ y₂ }h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })
h_xα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x :=
      max (Layout.max_with_offset c { fst := s, rst := ss })
        (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }),
    y := max y₁ y₂ }]α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x :=
      max (Layout.max_with_offset c { fst := s, rst := ss })
        (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }),
    y := max y₁ y₂ }
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }dwi { α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

MeasRender F (Doc.concat d₁✝ d₂✝) c i
  { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x :=
      max (Layout.max_with_offset c { fst := s, rst := ss })
        (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }),
    y := max y₁ y₂ }constructorα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

h₁MeasRender F d₁✝ c i ?m₁
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

h₂MeasRender F d₂✝ ?m₁.last i ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

h{ last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x :=
      max (Layout.max_with_offset c { fst := s, rst := ss })
        (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }),
    y := max y₁ y₂ } =   Meas.concat F ?m₁ ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

m₁Meas
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

m₂Meas }α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

h₂MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

h{ last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x :=
      max (Layout.max_with_offset c { fst := s, rst := ss })
        (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }),
    y := max y₁ y₂ } =   Meas.concat F
    { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }
    ?m₂
α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

m₂Meas
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }case h₂ => 
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i ?m₂subst h_last: slast = List.getLast ss h_non_empty✝
h_lastα: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

t: String

h_non_empty✝: ss ≠ []

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

cost₂: α

y₂: ℕ

h₂: Render d₂✝ (String.length (List.getLast ss h_non_empty✝)) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl ≠ []

h✝: MeasRender F d₂✝ (String.length (List.getLast ss h_non_empty✝)) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [List.getLast ss h_non_empty✝ ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl })

MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i (?m.206236 (_ : List.getLast ss h_non_empty✝ = List.getLast ss h_non_empty✝) h₂ h_non_empty h✝ h_x)
          α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

MeasRender F d₂✝
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }.last
  i ?m₂simpa [List.getLast_append': ∀ {α : Type ?u.206258} (l₁ l₂ : List α) (h : l₂ ≠ []), List.getLast (l₁ ++ l₂) (_ : l₁ ++ l₂ ≠ []) = List.getLast l₂ h
List.getLast_append']
Goals accomplished! 🐙
        α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

∃ cost y,
  MeasRender F (Doc.concat d₁✝ d₂✝) c i
    { last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty), cost := cost,
      doc := Doc.concat d₁✝ d₂✝,
      x := Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl }, y := y }case h => α: Type

F: Factory α

d₁✝, d₂✝: Doc

ih₁: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₁✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₁✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₁✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

ih₂: ∀ {c i : ℕ} {s : String} {ss : List String},
  Render d₂✝ c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d₂✝ c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d₂✝,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }

c, i: ℕ

s: String

ss: List String

slast, t: String

h_non_empty✝: ss ≠ []

h_last: slast = List.getLast ss h_non_empty✝

h₁: Render d₁✝ c i { fst := s, rst := ss }

cost₁: α

y₁: ℕ

h✝¹: MeasRender F d₁✝ c i
  { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
    x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }

h_droplast: List.map String.length ss = List.map String.length (List.dropLast ss ++ [List.getLast ss h_non_empty✝])

hd: String

tl: List String

h₂: Render d₂✝ (String.length slast) i { fst := t, rst := hd :: tl }

h_non_empty: List.dropLast ss ++ [slast ++ t] ++ hd :: tl ≠ []

cost₂: α

y₂: ℕ

h✝: MeasRender F d₂✝ (String.length slast) i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
    x := Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }, y := y₂ }

h_x: Layout.max_with_offset c { fst := s, rst := List.dropLast ss ++ [slast ++ t] ++ hd :: tl } =   max (Layout.max_with_offset c { fst := s, rst := ss })
    (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl })

{ last := String.length (List.getLast (List.dropLast ss ++ [slast ++ t] ++ hd :: tl) h_non_empty),
    cost := Factory.concat F cost₁ cost₂, doc := Doc.concat d₁✝ d₂✝,
    x :=
      max (Layout.max_with_offset c { fst := s, rst := ss })
        (Layout.max_with_offset (String.length slast) { fst := t, rst := hd :: tl }),
    y := max y₁ y₂ } =   Meas.concat F
    { last := String.length (List.getLast ss h_non_empty✝), cost := cost₁, doc := d₁✝,
      x := Layout.max_with_offset c { fst := s, rst := ss }, y := y₁ }
    { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost₂, doc := d₂✝,
      x := Layout.max_with_offset (String.length (List.getLast ss h_non_empty✝)) { fst := t, rst := hd :: tl },
      y := y₂ }simp_arith [Meas.concat: {α : Type} → Factory α → Meas → Meas → Meas
Meas.concat, *, List.getLast_append': ∀ {α : Type ?u.206705} (l₁ l₂ : List α) (h : l₂ ≠ []), List.getLast (l₁ ++ l₂) (_ : l₁ ++ l₂ ≠ []) = List.getLast l₂ h
List.getLast_append']
Goals accomplished! 🐙

/--
Totality of the measure computation relation (Section 5.3)
-/
theorem MeasRender_total: ∀ {α : Type} (F : Factory α) (d : Doc) (c i : ℕ), Choiceless d → ∃ m, MeasRender F d c i m
MeasRender_total (F: Factory α
F : Factory: Type → Type
Factory α: ?m.210313
α) (d: Doc
d : Doc: Type
Doc) (c: ℕ
c i: ℕ
i : ℕ: Type
ℕ) (h: Choiceless d
h : Choiceless: Doc → Prop
Choiceless d: Doc
d) : 
    ∃ m: ?m.210329
m, MeasRender: {α : Type} → Factory α → Doc → ℕ → ℕ → Meas → Prop
MeasRender F: Factory α
F d: Doc
d c: ℕ
c i: ℕ
i m: ?m.210329
m := by
Goals accomplished! 🐙 
  α: Type

F: Factory α

d: Doc

c, i: ℕ

h: Choiceless d

∃ m, MeasRender F d c i mlet ⟨⟨s: String
s, ss: List String
ss⟩, h: Render d c i { fst := s, rst := ss }
h⟩ := Render_total: ∀ {d : Doc} (c i : ℕ), Choiceless d → ∃ L, Render d c i L
Render_total c: ℕ
c i: ℕ
i h: Choiceless d
hα: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s: String

ss: List String

h: Render d c i { fst := s, rst := ss }

∃ m, MeasRender F d c i m
  α: Type

F: Factory α

d: Doc

c, i: ℕ

h: Choiceless d

∃ m, MeasRender F d c i mcases ss: List String
ssα: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s: String

h: Render d c i { fst := s, rst := [] }

nil∃ m, MeasRender F d c i m
α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s, head✝: String

tail✝: List String

h: Render d c i { fst := s, rst := head✝ :: tail✝ }

cons∃ m, MeasRender F d c i m 
  α: Type

F: Factory α

d: Doc

c, i: ℕ

h: Choiceless d

∃ m, MeasRender F d c i mcase nil => 
    α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s: String

h: Render d c i { fst := s, rst := [] }

∃ m, MeasRender F d c i mlet ⟨cost: α
cost, ⟨y: ℕ
y, _⟩⟩ := MeasRender_single_correct: ∀ {α : Type} {d : Doc} {c i : ℕ} {s : String} (F : Factory α),
  Render d c i { fst := s, rst := [] } →
    ∃ cost y,
      MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }
MeasRender_single_correct F: Factory α
F h: Render d c i { fst := s, rst := [] }
hα: Type

F: Factory α

d: Doc

c, i: ℕ

h✝¹: Choiceless d

s: String

h: Render d c i { fst := s, rst := [] }

cost: α

y: ℕ

h✝: MeasRender F d c i { last := c + String.length s, cost := cost, doc := d, x := c + String.length s, y := y }

∃ m, MeasRender F d c i m 
    α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s: String

h: Render d c i { fst := s, rst := [] }

∃ m, MeasRender F d c i mexists ⟨c: ℕ
c + s: String
s.length: String → ℕ
length, cost: α
cost, d: Doc
d, c: ℕ
c + s: String
s.length: String → ℕ
length, y: ℕ
y⟩
Goals accomplished! 🐙
  α: Type

F: Factory α

d: Doc

c, i: ℕ

h: Choiceless d

∃ m, MeasRender F d c i mcase cons hd: ?m.210506
hd tl: List ?m.210506
tl => 
    α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s, hd: String

tl: List String

h: Render d c i { fst := s, rst := hd :: tl }

∃ m, MeasRender F d c i mlet ⟨cost: α
cost, ⟨y: ℕ
y, _⟩⟩ := MeasRender_multi_correct: ∀ {α : Type} {d : Doc} {c i : ℕ} {s : String} {ss : List String} (F : Factory α),
  Render d c i { fst := s, rst := ss } →
    ∀ (h_non_empty : ss ≠ []),
      ∃ cost y,
        MeasRender F d c i
          { last := String.length (List.getLast ss h_non_empty), cost := cost, doc := d,
            x := Layout.max_with_offset c { fst := s, rst := ss }, y := y }
MeasRender_multi_correct F: Factory α
F h: Render d c i { fst := s, rst := hd :: tl }
h (α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s, hd: String

tl: List String

h: Render d c i { fst := s, rst := hd :: tl }

∃ m, MeasRender F d c i mby
Goals accomplished! 🐙 α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s, hd: String

tl: List String

h: Render d c i { fst := s, rst := hd :: tl }

hd :: tl ≠ []simp
Goals accomplished! 🐙)α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝¹: Choiceless d

s, hd: String

tl: List String

h: Render d c i { fst := s, rst := hd :: tl }

cost: α

y: ℕ

h✝: MeasRender F d c i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost, doc := d,
    x := Layout.max_with_offset c { fst := s, rst := hd :: tl }, y := y }

∃ m, MeasRender F d c i m
    α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝: Choiceless d

s, hd: String

tl: List String

h: Render d c i { fst := s, rst := hd :: tl }

∃ m, MeasRender F d c i mexists ⟨(List.getLast: {α : Type ?u.212538} → (as : List α) → as ≠ [] → α
List.getLast (hd: ?m.210506
hd :: tl: List ?m.210506
tl) (α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝¹: Choiceless d

s, hd: String

tl: List String

h: Render d c i { fst := s, rst := hd :: tl }

cost: α

y: ℕ

h✝: MeasRender F d c i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost, doc := d,
    x := Layout.max_with_offset c { fst := s, rst := hd :: tl }, y := y }

∃ m, MeasRender F d c i mby
Goals accomplished! 🐙 α: Type

F: Factory α

d: Doc

c, i: ℕ

h✝¹: Choiceless d

s, hd: String

tl: List String

h: Render d c i { fst := s, rst := hd :: tl }

cost: α

y: ℕ

h✝: MeasRender F d c i
  { last := String.length (List.getLast (hd :: tl) (_ : ¬hd :: tl = [])), cost := cost, doc := d,
    x := Layout.max_with_offset c { fst := s, rst := hd :: tl }, y := y }

hd :: tl ≠ []simp
Goals accomplished! 🐙)).length: String → ℕ
length, cost: α
cost, 
            d: Doc
d, Layout.max_with_offset: ℕ → Layout → ℕ
Layout.max_with_offset c: ℕ
c (Layout.mk: String → List String → Layout
Layout.mk s: String
s (hd: ?m.210506
hd :: tl: List ?m.210506
tl)), y: ℕ
y⟩
Goals accomplished! 🐙