File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Grind/Types.lean

full_name: Lean.Meta.Grind.Context.mainDeclName
code: structure Context where
  mainDeclName : Name
goal: Lean.Name

full_name: Lean.Meta.Grind.Context
code: structure Context where
  mainDeclName : Name
goal: Type

full_name: Lean.Meta.Grind.State.nextThmIdx
code: structure State where
  canon      : Canonicalizer.State := {}
  /-- `ShareCommon` (aka `Hashconsing`) state. -/
  scState    : ShareCommon.State.{0} ShareCommon.objectFactory := ShareCommon.State.mk _
  /-- Next index for creating auxiliary theorems. -/
  nextThmIdx : Nat := 1
goal: Nat

full_name: Lean.Meta.Grind.State.scState
code: structure State where
  canon      : Canonicalizer.State := {}
  /-- `ShareCommon` (aka `Hashconsing`) state. -/
  scState    : ShareCommon.State.{0} ShareCommon.objectFactory := ShareCommon.State.mk _
  /-- Next index for creating auxiliary theorems. -/
  nextThmIdx : Nat := 1
goal: ShareCommon.State Lean.ShareCommon.objectFactory

full_name: Lean.Meta.Grind.State.canon
code: structure State where
  canon      : Canonicalizer.State := {}
  /-- `ShareCommon` (aka `Hashconsing`) state. -/
  scState    : ShareCommon.State.{0} ShareCommon.objectFactory := ShareCommon.State.mk _
  /-- Next index for creating auxiliary theorems. -/
  nextThmIdx : Nat := 1
goal: Lean.Meta.Canonicalizer.State

full_name: Lean.Meta.Grind.State
code: structure State where
  canon      : Canonicalizer.State := {}
  /-- `ShareCommon` (aka `Hashconsing`) state. -/
  scState    : ShareCommon.State.{0} ShareCommon.objectFactory := ShareCommon.State.mk _
  /-- Next index for creating auxiliary theorems. -/
  nextThmIdx : Nat := 1
goal: Type

full_name: Lean.Meta.Grind.GrindM
code: abbrev GrindM 
goal: Type

full_name: Lean.Meta.Grind.GrindM.run
code: @[inline] def GrindM.run (x : GrindM α) (mainDeclName : Name) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.Grind.abstractNestedProofs
code: def abstractNestedProofs (e : Expr) : GrindM Expr 
goal: Lean.Meta.Grind.GrindM Lean.Expr

full_name: Lean.Meta.Grind.shareCommon
code: def shareCommon (e : Expr) : GrindM Expr 
goal: Lean.Meta.Grind.GrindM Lean.Expr

full_name: Lean.Meta.Grind.canon.canonRec
code: def canon (e : Expr) : GrindM Expr 
goal: Lean.Meta.CanonM Lean.Expr

full_name: Lean.Meta.Grind.canon
code: def canon (e : Expr) : GrindM Expr 
goal: Lean.Meta.Grind.GrindM Lean.Expr

full_name: Lean.Meta.Grind.ENode.size
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Nat

full_name: Lean.Meta.Grind.ENode.heqProofs
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Bool

full_name: Lean.Meta.Grind.ENode.proof?
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Option Lean.Expr

full_name: Lean.Meta.Grind.ENode.root
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Lean.Expr

full_name: Lean.Meta.Grind.ENode.cgRoot
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Lean.Expr

full_name: Lean.Meta.Grind.ENode.interpreted
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Bool

full_name: Lean.Meta.Grind.ENode.mt
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Nat

full_name: Lean.Meta.Grind.ENode
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Type

full_name: Lean.Meta.Grind.ENode.next
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Lean.Expr

full_name: Lean.Meta.Grind.ENode.ctor
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Bool

full_name: Lean.Meta.Grind.ENode.generation
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Nat

full_name: Lean.Meta.Grind.ENode.flipped
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Bool

full_name: Lean.Meta.Grind.ENode.hasLambdas
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Bool

full_name: Lean.Meta.Grind.ENode.target?
code: /--
Stores information for a node in the egraph.
Each internalized expression `e` has an `ENode` associated with it.
-/
structure ENode where
  /-- Next element in the equivalence class. -/
  next : Expr
  /-- Root (aka canonical representative) of the equivalence class -/
  root : Expr
  /-- Root of the congruence class. This is field is a don't care if `e` is not an application. -/
  cgRoot : Expr
  /--
  When `e` was added to this equivalence class because of an equality `h : e = target`,
  then we store `target` here, and `h` at `proof?`.
  -/
  target? : Option Expr := none
  proof? : Option Expr := none
  /-- Proof has been flipped. -/
  flipped : Bool := false
  /-- Number of elements in the equivalence class, this field is meaningless if node is not the root. -/
  size : Nat := 1
  /-- `interpreted := true` if node should be viewed as an abstract value. -/
  interpreted : Bool := false
  /-- `ctor := true` if the head symbol is a constructor application. -/
  ctor : Bool := false
  /-- `hasLambdas := true` if equivalence class contains lambda expressions. -/
  hasLambdas : Bool := false
  /--
  If `heqProofs := true`, then some proofs in the equivalence class are based
  on heterogeneous equality.
  -/
  heqProofs : Bool := false
  generation : Nat := 0
  /-- Modification time -/
  mt : Nat := 0
goal: Option Lean.Expr

full_name: Lean.Meta.Grind.Clause.proof
code: structure Clause where
  expr  : Expr
  proof : Expr
  deriving Inhabited
goal: Lean.Expr

full_name: Lean.Meta.Grind.Clause.expr
code: structure Clause where
  expr  : Expr
  proof : Expr
  deriving Inhabited
goal: Lean.Expr

full_name: Lean.Meta.Grind.Clause
code: structure Clause where
  expr  : Expr
  proof : Expr
  deriving Inhabited
goal: Type

full_name: Lean.Meta.Grind.instInhabitedClause
code: structure Clause where
  expr  : Expr
  proof : Expr
  deriving Inhabited
goal: Inhabited Lean.Meta.Grind.Clause

full_name: Lean.Meta.Grind.mkInputClause
code: def mkInputClause (fvarId : FVarId) : MetaM Clause 
goal: Lean.MetaM Lean.Meta.Grind.Clause

full_name: Lean.Meta.Grind.NewEq
code: structure NewEq where
  lhs   : Expr
  rhs   : Expr
  proof : Expr
  isHEq : Bool
goal: Type

full_name: Lean.Meta.Grind.NewEq.rhs
code: structure NewEq where
  lhs   : Expr
  rhs   : Expr
  proof : Expr
  isHEq : Bool
goal: Lean.Expr

full_name: Lean.Meta.Grind.NewEq.lhs
code: structure NewEq where
  lhs   : Expr
  rhs   : Expr
  proof : Expr
  isHEq : Bool
goal: Lean.Expr

full_name: Lean.Meta.Grind.NewEq.proof
code: structure NewEq where
  lhs   : Expr
  rhs   : Expr
  proof : Expr
  isHEq : Bool
goal: Lean.Expr

full_name: Lean.Meta.Grind.NewEq.isHEq
code: structure NewEq where
  lhs   : Expr
  rhs   : Expr
  proof : Expr
  isHEq : Bool
goal: Bool

full_name: Lean.Meta.Grind.Goal.enodes
code: structure Goal where
  mvarId       : MVarId
  clauses      : PArray Clause := {}
  enodes       : PHashMap USize ENode := {}
  newEqs       : Array NewEq := #[]
  /-- `inconsistent := true` if `ENode`s for `True` and `False` are in the same equivalence class. -/
  inconsistent : Bool := false
  /-- Goal modification time. -/
  gmt          : Nat := 0
  deriving Inhabited
goal: Lean.PHashMap USize Lean.Meta.Grind.ENode

full_name: Lean.Meta.Grind.instInhabitedGoal
code: structure Goal where
  mvarId       : MVarId
  clauses      : PArray Clause := {}
  enodes       : PHashMap USize ENode := {}
  newEqs       : Array NewEq := #[]
  /-- `inconsistent := true` if `ENode`s for `True` and `False` are in the same equivalence class. -/
  inconsistent : Bool := false
  /-- Goal modification time. -/
  gmt          : Nat := 0
  deriving Inhabited
goal: Inhabited Lean.Meta.Grind.Goal

full_name: Lean.Meta.Grind.Goal.inconsistent
code: structure Goal where
  mvarId       : MVarId
  clauses      : PArray Clause := {}
  enodes       : PHashMap USize ENode := {}
  newEqs       : Array NewEq := #[]
  /-- `inconsistent := true` if `ENode`s for `True` and `False` are in the same equivalence class. -/
  inconsistent : Bool := false
  /-- Goal modification time. -/
  gmt          : Nat := 0
  deriving Inhabited
goal: Bool

full_name: Lean.Meta.Grind.Goal.newEqs
code: structure Goal where
  mvarId       : MVarId
  clauses      : PArray Clause := {}
  enodes       : PHashMap USize ENode := {}
  newEqs       : Array NewEq := #[]
  /-- `inconsistent := true` if `ENode`s for `True` and `False` are in the same equivalence class. -/
  inconsistent : Bool := false
  /-- Goal modification time. -/
  gmt          : Nat := 0
  deriving Inhabited
goal: Array Lean.Meta.Grind.NewEq

full_name: Lean.Meta.Grind.Goal
code: structure Goal where
  mvarId       : MVarId
  clauses      : PArray Clause := {}
  enodes       : PHashMap USize ENode := {}
  newEqs       : Array NewEq := #[]
  /-- `inconsistent := true` if `ENode`s for `True` and `False` are in the same equivalence class. -/
  inconsistent : Bool := false
  /-- Goal modification time. -/
  gmt          : Nat := 0
  deriving Inhabited
goal: Type

full_name: Lean.Meta.Grind.Goal.clauses
code: structure Goal where
  mvarId       : MVarId
  clauses      : PArray Clause := {}
  enodes       : PHashMap USize ENode := {}
  newEqs       : Array NewEq := #[]
  /-- `inconsistent := true` if `ENode`s for `True` and `False` are in the same equivalence class. -/
  inconsistent : Bool := false
  /-- Goal modification time. -/
  gmt          : Nat := 0
  deriving Inhabited
goal: Lean.PArray Lean.Meta.Grind.Clause

full_name: Lean.Meta.Grind.Goal.gmt
code: structure Goal where
  mvarId       : MVarId
  clauses      : PArray Clause := {}
  enodes       : PHashMap USize ENode := {}
  newEqs       : Array NewEq := #[]
  /-- `inconsistent := true` if `ENode`s for `True` and `False` are in the same equivalence class. -/
  inconsistent : Bool := false
  /-- Goal modification time. -/
  gmt          : Nat := 0
  deriving Inhabited
goal: Nat

full_name: Lean.Meta.Grind.Goal.mvarId
code: structure Goal where
  mvarId       : MVarId
  clauses      : PArray Clause := {}
  enodes       : PHashMap USize ENode := {}
  newEqs       : Array NewEq := #[]
  /-- `inconsistent := true` if `ENode`s for `True` and `False` are in the same equivalence class. -/
  inconsistent : Bool := false
  /-- Goal modification time. -/
  gmt          : Nat := 0
  deriving Inhabited
goal: Lean.MVarId

full_name: Lean.Meta.Grind.Goal.admit
code: def Goal.admit (goal : Goal) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.Meta.Grind.GoalM
code: abbrev GoalM 
goal: Type

full_name: Lean.Meta.Grind.GoalM.run
code: @[inline] def GoalM.run (goal : Goal) (x : GoalM α) : GrindM (α × Goal) 
goal: Lean.Meta.Grind.GrindM (α × Lean.Meta.Grind.Goal)

full_name: Lean.Meta.Grind.GoalM.run'
code: @[inline] def GoalM.run' (goal : Goal) (x : GoalM Unit) : GrindM Goal 
goal: Lean.Meta.Grind.GrindM Lean.Meta.Grind.Goal

full_name: Lean.Meta.Grind.getENode?
code: /--
Returns `some n` if `e` has already been "internalized" into the
Otherwise, returns `none`s.
-/
def getENode? (e : Expr) : GoalM (Option ENode) 
goal: Lean.Meta.Grind.GoalM (Option Lean.Meta.Grind.ENode)

full_name: Lean.Meta.Grind.setENode
code: def setENode (e : Expr) (n : ENode) : GoalM Unit 
goal: Lean.Meta.Grind.GoalM Unit

full_name: Lean.Meta.Grind.mkENodeCore
code: def mkENodeCore (e : Expr) (interpreted ctor : Bool) (generation : Nat) : GoalM Unit 
goal: Lean.Meta.Grind.GoalM Unit

full_name: Lean.Meta.Grind.mkGoal
code: def mkGoal (mvarId : MVarId) : GrindM Goal 
goal: Lean.Meta.Grind.GrindM Lean.Meta.Grind.Goal