File: .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean

full_name: Nat.Linear.Var
code: abbrev Var 
goal: Type

full_name: Nat.Linear.Context
code: abbrev Context 
goal: Type

full_name: Nat.Linear.fixedVar
code: /--
  When encoding polynomials. We use `fixedVar` for encoding numerals.
  The denotation of `fixedVar` is always `1`. -/
def fixedVar 
goal: Nat

full_name: Nat.Linear.Var.denote
code: def Var.denote (ctx : Context) (v : Var) : Nat 
goal: Nat

full_name: Nat.Linear.Var.denote.go
code: def Var.denote (ctx : Context) (v : Var) : Nat 
goal: List Nat → Nat → Nat

full_name: Nat.Linear.Expr.add
code: inductive Expr where
  | num  (v : Nat)
  | var  (i : Var)
  | add  (a b : Expr)
  | mulL (k : Nat) (a : Expr)
  | mulR (a : Expr) (k : Nat)
  deriving Inhabited
goal: Nat.Linear.Expr

full_name: Nat.Linear.Expr.num
code: inductive Expr where
  | num  (v : Nat)
  | var  (i : Var)
  | add  (a b : Expr)
  | mulL (k : Nat) (a : Expr)
  | mulR (a : Expr) (k : Nat)
  deriving Inhabited
goal: Nat.Linear.Expr

full_name: Nat.Linear.Expr.var
code: inductive Expr where
  | num  (v : Nat)
  | var  (i : Var)
  | add  (a b : Expr)
  | mulL (k : Nat) (a : Expr)
  | mulR (a : Expr) (k : Nat)
  deriving Inhabited
goal: Nat.Linear.Expr

full_name: Nat.Linear.instInhabitedExpr
code: inductive Expr where
  | num  (v : Nat)
  | var  (i : Var)
  | add  (a b : Expr)
  | mulL (k : Nat) (a : Expr)
  | mulR (a : Expr) (k : Nat)
  deriving Inhabited
goal: Inhabited Nat.Linear.Expr

full_name: Nat.Linear.Expr.mulR
code: inductive Expr where
  | num  (v : Nat)
  | var  (i : Var)
  | add  (a b : Expr)
  | mulL (k : Nat) (a : Expr)
  | mulR (a : Expr) (k : Nat)
  deriving Inhabited
goal: Nat.Linear.Expr

full_name: Nat.Linear.Expr.mulL
code: inductive Expr where
  | num  (v : Nat)
  | var  (i : Var)
  | add  (a b : Expr)
  | mulL (k : Nat) (a : Expr)
  | mulR (a : Expr) (k : Nat)
  deriving Inhabited
goal: Nat.Linear.Expr

full_name: Nat.Linear.Expr
code: inductive Expr where
  | num  (v : Nat)
  | var  (i : Var)
  | add  (a b : Expr)
  | mulL (k : Nat) (a : Expr)
  | mulR (a : Expr) (k : Nat)
  deriving Inhabited
goal: Type

full_name: Nat.Linear.Expr.denote
code: def Expr.denote (ctx : Context) : Expr → Nat
  
goal: Nat.Linear.Expr → Nat

full_name: Nat.Linear.Poly
code: abbrev Poly 
goal: Type

full_name: Nat.Linear.Poly.denote
code: def Poly.denote (ctx : Context) (p : Poly) : Nat 
goal: Nat

full_name: Nat.Linear.Poly.insertSorted
code: def Poly.insertSorted (k : Nat) (v : Var) (p : Poly) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Poly.sort
code: def Poly.sort (p : Poly) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Poly.sort.go
code: def Poly.sort (p : Poly) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Poly.fuse
code: def Poly.fuse (p : Poly) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Poly.mul
code: def Poly.mul (k : Nat) (p : Poly) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Poly.mul.go
code: def Poly.mul (k : Nat) (p : Poly) : Poly 
goal: Nat.Linear.Poly → Nat.Linear.Poly

full_name: Nat.Linear.Poly.cancelAux
code: def Poly.cancelAux (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly) : Poly × Poly 
goal: Nat.Linear.Poly × Nat.Linear.Poly

full_name: Nat.Linear.hugeFuel
code: def hugeFuel 
goal: Nat

full_name: Nat.Linear.Poly.cancel
code: def Poly.cancel (p₁ p₂ : Poly) : Poly × Poly 
goal: Nat.Linear.Poly × Nat.Linear.Poly

full_name: Nat.Linear.Poly.isNum?
code: def Poly.isNum? (p : Poly) : Option Nat 
goal: Option Nat

full_name: Nat.Linear.Poly.isZero
code: def Poly.isZero (p : Poly) : Bool 
goal: Bool

full_name: Nat.Linear.Poly.isNonZero
code: def Poly.isNonZero (p : Poly) : Bool 
goal: Bool

full_name: Nat.Linear.Poly.denote_eq
code: def Poly.denote_eq (ctx : Context) (mp : Poly × Poly) : Prop 
goal: Prop

full_name: Nat.Linear.Poly.denote_le
code: def Poly.denote_le (ctx : Context) (mp : Poly × Poly) : Prop 
goal: Prop

full_name: Nat.Linear.Poly.combineAux
code: def Poly.combineAux (fuel : Nat) (p₁ p₂ : Poly) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Poly.combine
code: def Poly.combine (p₁ p₂ : Poly) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Expr.toPoly
code: def Expr.toPoly : Expr → Poly
  
goal: Nat.Linear.Expr → Nat.Linear.Poly

full_name: Nat.Linear.Poly.norm
code: def Poly.norm (p : Poly) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Expr.toNormPoly
code: def Expr.toNormPoly (e : Expr) : Poly 
goal: Nat.Linear.Poly

full_name: Nat.Linear.Expr.inc
code: def Expr.inc (e : Expr) : Expr 
goal: Nat.Linear.Expr

full_name: Nat.Linear.PolyCnstr.rhs
code: structure PolyCnstr  where
  eq  : Bool
  lhs : Poly
  rhs : Poly
  deriving BEq
goal: Nat.Linear.Poly

full_name: Nat.Linear.instBEqPolyCnstr
code: structure PolyCnstr  where
  eq  : Bool
  lhs : Poly
  rhs : Poly
  deriving BEq
goal: BEq Nat.Linear.PolyCnstr

full_name: Nat.Linear.PolyCnstr
code: structure PolyCnstr  where
  eq  : Bool
  lhs : Poly
  rhs : Poly
  deriving BEq
goal: Type

full_name: Nat.Linear.PolyCnstr.eq
code: structure PolyCnstr  where
  eq  : Bool
  lhs : Poly
  rhs : Poly
  deriving BEq
goal: Bool

full_name: Nat.Linear.PolyCnstr.lhs
code: structure PolyCnstr  where
  eq  : Bool
  lhs : Poly
  rhs : Poly
  deriving BEq
goal: Nat.Linear.Poly

full_name: Nat.Linear.instLawfulBEqPolyCnstr
code: instance : LawfulBEq PolyCnstr 
goal: LawfulBEq Nat.Linear.PolyCnstr

full_name: Nat.Linear.PolyCnstr.mul
code: def PolyCnstr.mul (k : Nat) (c : PolyCnstr) : PolyCnstr 
goal: Nat.Linear.PolyCnstr

full_name: Nat.Linear.PolyCnstr.combine
code: def PolyCnstr.combine (c₁ c₂ : PolyCnstr) : PolyCnstr 
goal: Nat.Linear.PolyCnstr

full_name: Nat.Linear.ExprCnstr.lhs
code: structure ExprCnstr where
  eq  : Bool
  lhs : Expr
  rhs : Expr
goal: Nat.Linear.Expr

full_name: Nat.Linear.ExprCnstr
code: structure ExprCnstr where
  eq  : Bool
  lhs : Expr
  rhs : Expr
goal: Type

full_name: Nat.Linear.ExprCnstr.rhs
code: structure ExprCnstr where
  eq  : Bool
  lhs : Expr
  rhs : Expr
goal: Nat.Linear.Expr

full_name: Nat.Linear.ExprCnstr.eq
code: structure ExprCnstr where
  eq  : Bool
  lhs : Expr
  rhs : Expr
goal: Bool

full_name: Nat.Linear.PolyCnstr.denote
code: def PolyCnstr.denote (ctx : Context) (c : PolyCnstr) : Prop 
goal: Prop

full_name: Nat.Linear.PolyCnstr.norm
code: def PolyCnstr.norm (c : PolyCnstr) : PolyCnstr 
goal: Nat.Linear.PolyCnstr

full_name: Nat.Linear.PolyCnstr.isUnsat
code: def PolyCnstr.isUnsat (c : PolyCnstr) : Bool 
goal: Bool

full_name: Nat.Linear.PolyCnstr.isValid
code: def PolyCnstr.isValid (c : PolyCnstr) : Bool 
goal: Bool

full_name: Nat.Linear.ExprCnstr.denote
code: def ExprCnstr.denote (ctx : Context) (c : ExprCnstr) : Prop 
goal: Prop

full_name: Nat.Linear.ExprCnstr.toPoly
code: def ExprCnstr.toPoly (c : ExprCnstr) : PolyCnstr 
goal: Nat.Linear.PolyCnstr

full_name: Nat.Linear.ExprCnstr.toNormPoly
code: def ExprCnstr.toNormPoly (c : ExprCnstr) : PolyCnstr 
goal: Nat.Linear.PolyCnstr

full_name: Nat.Linear.Certificate
code: abbrev Certificate 
goal: Type

full_name: Nat.Linear.Certificate.combineHyps
code: def Certificate.combineHyps (c : PolyCnstr) (hs : Certificate) : PolyCnstr 
goal: Nat.Linear.PolyCnstr

full_name: Nat.Linear.Certificate.combine
code: def Certificate.combine (hs : Certificate) : PolyCnstr 
goal: Nat.Linear.PolyCnstr

full_name: Nat.Linear.Certificate.denote
code: def Certificate.denote (ctx : Context) (c : Certificate) : Prop 
goal: Prop

full_name: Nat.Linear.monomialToExpr
code: def monomialToExpr (k : Nat) (v : Var) : Expr 
goal: Nat.Linear.Expr

full_name: Nat.Linear.Poly.toExpr
code: def Poly.toExpr (p : Poly) : Expr 
goal: Nat.Linear.Expr

full_name: Nat.Linear.Poly.toExpr.go
code: def Poly.toExpr (p : Poly) : Expr 
goal: Nat.Linear.Expr

full_name: Nat.Linear.PolyCnstr.toExpr
code: def PolyCnstr.toExpr (c : PolyCnstr) : ExprCnstr 
goal: Nat.Linear.ExprCnstr

full_name: Nat.Linear.Poly.denote_insertSorted
code: theorem Poly.denote_insertSorted (ctx : Context) (k : Nat) (v : Var) (p : Poly) : (p.insertSorted k v).denote ctx = p.denote ctx + k * v.denote ctx 
goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.insertSorted k v p) =
  Nat.Linear.Poly.denote ctx p + k * Nat.Linear.Var.denote ctx v

full_name: Nat.Linear.Poly.denote_sort_go
code: theorem Poly.denote_sort_go (ctx : Context) (p : Poly) (r : Poly) : (sort.go p r).denote ctx = p.denote ctx + r.denote ctx 
goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.sort.go p r) = Nat.Linear.Poly.denote ctx p + Nat.Linear.Poly.denote ctx r

full_name: Nat.Linear.Poly.denote_sort
code: theorem Poly.denote_sort (ctx : Context) (m : Poly) : m.sort.denote ctx = m.denote ctx 
goal: Nat.Linear.Poly.denote ctx m.sort = Nat.Linear.Poly.denote ctx m

full_name: Nat.Linear.Poly.denote_append
code: theorem Poly.denote_append (ctx : Context) (p q : Poly) : (p ++ q).denote ctx = p.denote ctx + q.denote ctx 
goal: Nat.Linear.Poly.denote ctx (p ++ q) = Nat.Linear.Poly.denote ctx p + Nat.Linear.Poly.denote ctx q

full_name: Nat.Linear.Poly.denote_cons
code: theorem Poly.denote_cons (ctx : Context) (k : Nat) (v : Var) (p : Poly) : denote ctx ((k, v) :: p) = k * v.denote ctx + p.denote ctx 
goal: Nat.Linear.Poly.denote ctx ((k, v) :: p) = k * Nat.Linear.Var.denote ctx v + Nat.Linear.Poly.denote ctx p

full_name: Nat.Linear.Poly.denote_reverseAux
code: theorem Poly.denote_reverseAux (ctx : Context) (p q : Poly) : denote ctx (List.reverseAux p q) = denote ctx (p ++ q) 
goal: Nat.Linear.Poly.denote ctx (List.reverseAux p q) = Nat.Linear.Poly.denote ctx (p ++ q)

full_name: Nat.Linear.Poly.denote_reverse
code: theorem Poly.denote_reverse (ctx : Context) (p : Poly) : denote ctx (List.reverse p) = denote ctx p 
goal: Nat.Linear.Poly.denote ctx (List.reverse p) = Nat.Linear.Poly.denote ctx p

full_name: Nat.Linear.Poly.denote_fuse
code: theorem Poly.denote_fuse (ctx : Context) (p : Poly) : p.fuse.denote ctx = p.denote ctx 
goal: Nat.Linear.Poly.denote ctx p.fuse = Nat.Linear.Poly.denote ctx p

full_name: Nat.Linear.Poly.denote_mul
code: theorem Poly.denote_mul (ctx : Context) (k : Nat) (p : Poly) : (p.mul k).denote ctx = k * p.denote ctx 
goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.mul k p) = k * Nat.Linear.Poly.denote ctx p

full_name: _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Linear.0.Nat.Linear.eq_of_not_blt_eq_true
code: private theorem eq_of_not_blt_eq_true (h₁ : ¬ (Nat.blt x y = true)) (h₂ : ¬ (Nat.blt y x = true)) : x = y 
goal: x = y

full_name: Nat.Linear.Poly.denote_eq_cancelAux
code: theorem Poly.denote_eq_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_eq ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂)) : denote_eq ctx (cancelAux fuel m₁ m₂ r₁ r₂) 
goal: Nat.Linear.Poly.denote_eq ctx (Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂)

full_name: Nat.Linear.Poly.of_denote_eq_cancelAux
code: theorem Poly.of_denote_eq_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_eq ctx (cancelAux fuel m₁ m₂ r₁ r₂)) : denote_eq ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂) 
goal: Nat.Linear.Poly.denote_eq ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂)

full_name: Nat.Linear.Poly.denote_eq_cancel
code: theorem Poly.denote_eq_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_eq ctx (m₁, m₂)) : denote_eq ctx (cancel m₁ m₂) 
goal: Nat.Linear.Poly.denote_eq ctx (m₁.cancel m₂)

full_name: Nat.Linear.Poly.of_denote_eq_cancel
code: theorem Poly.of_denote_eq_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_eq ctx (cancel m₁ m₂)) : denote_eq ctx (m₁, m₂) 
goal: Nat.Linear.Poly.denote_eq ctx (m₁, m₂)

full_name: Nat.Linear.Poly.denote_eq_cancel_eq
code: theorem Poly.denote_eq_cancel_eq (ctx : Context) (m₁ m₂ : Poly) : denote_eq ctx (cancel m₁ m₂) = denote_eq ctx (m₁, m₂) 
goal: Nat.Linear.Poly.denote_eq ctx (m₁.cancel m₂) = Nat.Linear.Poly.denote_eq ctx (m₁, m₂)

full_name: Nat.Linear.Poly.denote_le_cancelAux
code: theorem Poly.denote_le_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_le ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂)) : denote_le ctx (cancelAux fuel m₁ m₂ r₁ r₂) 
goal: Nat.Linear.Poly.denote_le ctx (Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂)

full_name: Nat.Linear.Poly.of_denote_le_cancelAux
code: theorem Poly.of_denote_le_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_le ctx (cancelAux fuel m₁ m₂ r₁ r₂)) : denote_le ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂) 
goal: Nat.Linear.Poly.denote_le ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂)

full_name: Nat.Linear.Poly.denote_le_cancel
code: theorem Poly.denote_le_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_le ctx (m₁, m₂)) : denote_le ctx (cancel m₁ m₂) 
goal: Nat.Linear.Poly.denote_le ctx (m₁.cancel m₂)

full_name: Nat.Linear.Poly.of_denote_le_cancel
code: theorem Poly.of_denote_le_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_le ctx (cancel m₁ m₂)) : denote_le ctx (m₁, m₂) 
goal: Nat.Linear.Poly.denote_le ctx (m₁, m₂)

full_name: Nat.Linear.Poly.denote_le_cancel_eq
code: theorem Poly.denote_le_cancel_eq (ctx : Context) (m₁ m₂ : Poly) : denote_le ctx (cancel m₁ m₂) = denote_le ctx (m₁, m₂) 
goal: Nat.Linear.Poly.denote_le ctx (m₁.cancel m₂) = Nat.Linear.Poly.denote_le ctx (m₁, m₂)

full_name: Nat.Linear.Poly.denote_combineAux
code: theorem Poly.denote_combineAux (ctx : Context) (fuel : Nat) (p₁ p₂ : Poly) : (p₁.combineAux fuel p₂).denote ctx = p₁.denote ctx + p₂.denote ctx 
goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.combineAux fuel p₁ p₂) =
  Nat.Linear.Poly.denote ctx p₁ + Nat.Linear.Poly.denote ctx p₂

full_name: Nat.Linear.Poly.denote_combine
code: theorem Poly.denote_combine (ctx : Context) (p₁ p₂ : Poly) : (p₁.combine p₂).denote ctx = p₁.denote ctx + p₂.denote ctx 
goal: Nat.Linear.Poly.denote ctx (p₁.combine p₂) = Nat.Linear.Poly.denote ctx p₁ + Nat.Linear.Poly.denote ctx p₂

full_name: Nat.Linear.Expr.denote_toPoly
code: theorem Expr.denote_toPoly (ctx : Context) (e : Expr) : e.toPoly.denote ctx = e.denote ctx 
goal: Nat.Linear.Poly.denote ctx e.toPoly = Nat.Linear.Expr.denote ctx e

full_name: Nat.Linear.Expr.eq_of_toNormPoly
code: theorem Expr.eq_of_toNormPoly (ctx : Context) (a b : Expr) (h : a.toNormPoly = b.toNormPoly) : a.denote ctx = b.denote ctx 
goal: Nat.Linear.Expr.denote ctx a = Nat.Linear.Expr.denote ctx b

full_name: Nat.Linear.Expr.of_cancel_eq
code: theorem Expr.of_cancel_eq (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.toNormPoly b.toNormPoly = (c.toPoly, d.toPoly)) : (a.denote ctx = b.denote ctx) = (c.denote ctx = d.denote ctx) 
goal: (Nat.Linear.Expr.denote ctx a = Nat.Linear.Expr.denote ctx b) =
  (Nat.Linear.Expr.denote ctx c = Nat.Linear.Expr.denote ctx d)

full_name: Nat.Linear.Expr.of_cancel_le
code: theorem Expr.of_cancel_le (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.toNormPoly b.toNormPoly = (c.toPoly, d.toPoly)) : (a.denote ctx ≤ b.denote ctx) = (c.denote ctx ≤ d.denote ctx) 
goal: (Nat.Linear.Expr.denote ctx a ≤ Nat.Linear.Expr.denote ctx b) =
  (Nat.Linear.Expr.denote ctx c ≤ Nat.Linear.Expr.denote ctx d)

full_name: Nat.Linear.Expr.of_cancel_lt
code: theorem Expr.of_cancel_lt (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.inc.toNormPoly b.toNormPoly = (c.inc.toPoly, d.toPoly)) : (a.denote ctx < b.denote ctx) = (c.denote ctx < d.denote ctx) 
goal: (Nat.Linear.Expr.denote ctx a < Nat.Linear.Expr.denote ctx b) =
  (Nat.Linear.Expr.denote ctx c < Nat.Linear.Expr.denote ctx d)

full_name: Nat.Linear.ExprCnstr.toPoly_norm_eq
code: theorem ExprCnstr.toPoly_norm_eq (c : ExprCnstr) : c.toPoly.norm = c.toNormPoly 
goal: c.toPoly.norm = c.toNormPoly

full_name: Nat.Linear.ExprCnstr.denote_toPoly
code: theorem ExprCnstr.denote_toPoly (ctx : Context) (c : ExprCnstr) : c.toPoly.denote ctx = c.denote ctx 
goal: Nat.Linear.PolyCnstr.denote ctx c.toPoly = Nat.Linear.ExprCnstr.denote ctx c

full_name: Nat.Linear.ExprCnstr.denote_toNormPoly
code: theorem ExprCnstr.denote_toNormPoly (ctx : Context) (c : ExprCnstr) : c.toNormPoly.denote ctx = c.denote ctx 
goal: Nat.Linear.PolyCnstr.denote ctx c.toNormPoly = Nat.Linear.ExprCnstr.denote ctx c

full_name: Nat.Linear.Poly.mul.go_denote
code: theorem Poly.mul.go_denote (ctx : Context) (k : Nat) (p : Poly) : (Poly.mul.go k p).denote ctx = k * p.denote ctx 
goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.mul.go k p) = k * Nat.Linear.Poly.denote ctx p

full_name: Nat.Linear.PolyCnstr.denote_mul
code: theorem PolyCnstr.denote_mul (ctx : Context) (k : Nat) (c : PolyCnstr) : (c.mul (k+1)).denote ctx = c.denote ctx 
goal: Nat.Linear.PolyCnstr.denote ctx (Nat.Linear.PolyCnstr.mul (k + 1) c) = Nat.Linear.PolyCnstr.denote ctx c

full_name: Nat.Linear.PolyCnstr.denote_combine
code: theorem PolyCnstr.denote_combine {ctx : Context} {c₁ c₂ : PolyCnstr} (h₁ : c₁.denote ctx) (h₂ : c₂.denote ctx) : (c₁.combine c₂).denote ctx 
goal: Nat.Linear.PolyCnstr.denote ctx (c₁.combine c₂)

full_name: Nat.Linear.Poly.isNum?_eq_some
code: theorem Poly.isNum?_eq_some (ctx : Context) {p : Poly} {k : Nat} : p.isNum? = some k → p.denote ctx = k 
goal: p.isNum? = some k → Nat.Linear.Poly.denote ctx p = k

full_name: Nat.Linear.Poly.of_isZero
code: theorem Poly.of_isZero (ctx : Context) {p : Poly} (h : isZero p = true) : p.denote ctx = 0 
goal: Nat.Linear.Poly.denote ctx p = 0

full_name: Nat.Linear.Poly.of_isNonZero
code: theorem Poly.of_isNonZero (ctx : Context) {p : Poly} (h : isNonZero p = true) : p.denote ctx > 0 
goal: Nat.Linear.Poly.denote ctx p > 0

full_name: Nat.Linear.PolyCnstr.eq_false_of_isUnsat
code: theorem PolyCnstr.eq_false_of_isUnsat (ctx : Context) {c : PolyCnstr} : c.isUnsat → c.denote ctx = False 
goal: c.isUnsat = true → Nat.Linear.PolyCnstr.denote ctx c = False

full_name: Nat.Linear.PolyCnstr.eq_true_of_isValid
code: theorem PolyCnstr.eq_true_of_isValid (ctx : Context) {c : PolyCnstr} : c.isValid → c.denote ctx = True 
goal: c.isValid = true → Nat.Linear.PolyCnstr.denote ctx c = True

full_name: Nat.Linear.ExprCnstr.eq_false_of_isUnsat
code: theorem ExprCnstr.eq_false_of_isUnsat (ctx : Context) (c : ExprCnstr) (h : c.toNormPoly.isUnsat) : c.denote ctx = False 
goal: Nat.Linear.ExprCnstr.denote ctx c = False

full_name: Nat.Linear.ExprCnstr.eq_true_of_isValid
code: theorem ExprCnstr.eq_true_of_isValid (ctx : Context) (c : ExprCnstr) (h : c.toNormPoly.isValid) : c.denote ctx = True 
goal: Nat.Linear.ExprCnstr.denote ctx c = True

full_name: Nat.Linear.Certificate.of_combineHyps
code: theorem Certificate.of_combineHyps (ctx : Context) (c : PolyCnstr) (cs : Certificate) (h : (combineHyps c cs).denote ctx → False) : c.denote ctx → cs.denote ctx 
goal: Nat.Linear.PolyCnstr.denote ctx c → Nat.Linear.Certificate.denote ctx cs

full_name: Nat.Linear.Certificate.of_combine
code: theorem Certificate.of_combine (ctx : Context) (cs : Certificate) (h : cs.combine.denote ctx → False) : cs.denote ctx 
goal: Nat.Linear.Certificate.denote ctx cs

full_name: Nat.Linear.Certificate.of_combine_isUnsat
code: theorem Certificate.of_combine_isUnsat (ctx : Context) (cs : Certificate) (h : cs.combine.isUnsat) : cs.denote ctx 
goal: Nat.Linear.Certificate.denote ctx cs

full_name: Nat.Linear.denote_monomialToExpr
code: theorem denote_monomialToExpr (ctx : Context) (k : Nat) (v : Var) : (monomialToExpr k v).denote ctx = k * v.denote ctx 
goal: Nat.Linear.Expr.denote ctx (Nat.Linear.monomialToExpr k v) = k * Nat.Linear.Var.denote ctx v

full_name: Nat.Linear.Poly.denote_toExpr_go
code: theorem Poly.denote_toExpr_go (ctx : Context) (e : Expr) (p : Poly) : (toExpr.go e p).denote ctx = e.denote ctx + p.denote ctx 
goal: Nat.Linear.Expr.denote ctx (Nat.Linear.Poly.toExpr.go e p) = Nat.Linear.Expr.denote ctx e + Nat.Linear.Poly.denote ctx p

full_name: Nat.Linear.Poly.denote_toExpr
code: theorem Poly.denote_toExpr (ctx : Context) (p : Poly) : p.toExpr.denote ctx = p.denote ctx 
goal: Nat.Linear.Expr.denote ctx p.toExpr = Nat.Linear.Poly.denote ctx p

full_name: Nat.Linear.ExprCnstr.eq_of_toNormPoly_eq
code: theorem ExprCnstr.eq_of_toNormPoly_eq (ctx : Context) (c d : ExprCnstr) (h : c.toNormPoly == d.toPoly) : c.denote ctx = d.denote ctx 
goal: Nat.Linear.ExprCnstr.denote ctx c = Nat.Linear.ExprCnstr.denote ctx d

full_name: Nat.Linear.Expr.eq_of_toNormPoly_eq
code: theorem Expr.eq_of_toNormPoly_eq (ctx : Context) (e e' : Expr) (h : e.toNormPoly == e'.toPoly) : e.denote ctx = e'.denote ctx 
goal: Nat.Linear.Expr.denote ctx e = Nat.Linear.Expr.denote ctx e'

full_name: Nat.elimOffset
code: def elimOffset {α : Sort u} (a b k : Nat) (h₁ : a + k = b + k) (h₂ : a = b → α) : α 
goal: α