File: Mathlib/Tactic/CC/Datatypes.lean

full_name: Mathlib.Tactic.CC.isValue
code: /-- Return true if `e` represents a constant value (numeral, character, or string). -/
def isValue (e : Expr) : Bool 
goal: Bool

full_name: Mathlib.Tactic.CC.isInterpretedValue
code: /-- Return true if `e` represents a value (nat/int numeral, character, or string).

In addition to the conditions in `Mathlib.Tactic.CC.isValue`, this also checks that
kernel computation can compare the values for equality. -/
def isInterpretedValue (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Mathlib.Tactic.CC.liftFromEq
code: /-- Given a reflexive relation `R`, and a proof `H : a = b`, build a proof for `R a b` -/
def liftFromEq (R : Name) (H : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Mathlib.Tactic.CC.instOrdExpr_mathlib
code: /-- Ordering on `Expr`. -/
scoped instance : Ord Expr 
goal: Ord Lean.Expr

full_name: Mathlib.Tactic.CC.RBExprMap
code: /-- Red-black maps whose keys are `Expr`s.

TODO: the choice between `RBMap` and `HashMap` is not obvious:
the current version follows the Lean 3 C++ implementation.
Once the `cc` tactic is used a lot in Mathlib, we should profile and see
if `HashMap` could be more optimal. -/
abbrev RBExprMap (α : Type u) 
goal: Type u

full_name: Mathlib.Tactic.CC.RBExprSet
code: /-- Red-black sets of `Expr`s.

TODO: the choice between `RBSet` and `HashSet` is not obvious:
the current version follows the Lean 3 C++ implementation.
Once the `cc` tactic is used a lot in Mathlib, we should profile and see
if `HashSet` could be more optimal. -/
abbrev RBExprSet 
goal: Type

full_name: Mathlib.Tactic.CC.CCCongrTheorem
code: /-- `CongrTheorem`s equiped with additional infos used by congruence closure modules. -/
structure CCCongrTheorem extends CongrTheorem where
  /-- If `heqResult` is true, then lemma is based on heterogeneous equality
      and the conclusion is a heterogeneous equality. -/
  heqResult : Bool := false
  /-- If `hcongrTheorem` is true, then lemma was created using `mkHCongrWithArity`. -/
  hcongrTheorem : Bool := false
goal: Type

full_name: Mathlib.Tactic.CC.CCCongrTheorem.hcongrTheorem
code: /-- `CongrTheorem`s equiped with additional infos used by congruence closure modules. -/
structure CCCongrTheorem extends CongrTheorem where
  /-- If `heqResult` is true, then lemma is based on heterogeneous equality
      and the conclusion is a heterogeneous equality. -/
  heqResult : Bool := false
  /-- If `hcongrTheorem` is true, then lemma was created using `mkHCongrWithArity`. -/
  hcongrTheorem : Bool := false
goal: Bool

full_name: Mathlib.Tactic.CC.CCCongrTheorem.heqResult
code: /-- `CongrTheorem`s equiped with additional infos used by congruence closure modules. -/
structure CCCongrTheorem extends CongrTheorem where
  /-- If `heqResult` is true, then lemma is based on heterogeneous equality
      and the conclusion is a heterogeneous equality. -/
  heqResult : Bool := false
  /-- If `hcongrTheorem` is true, then lemma was created using `mkHCongrWithArity`. -/
  hcongrTheorem : Bool := false
goal: Bool

full_name: Mathlib.Tactic.CC.mkCCHCongrWithArity
code: /-- Automatically generated congruence lemma based on heterogeneous equality.

This returns an annotated version of the result from `Lean.Meta.mkHCongrWithArity`. -/
def mkCCHCongrWithArity (fn : Expr) (nargs : Nat) : MetaM (Option CCCongrTheorem) 
goal: Lean.MetaM (Option Mathlib.Tactic.CC.CCCongrTheorem)

full_name: Mathlib.Tactic.CC.CCCongrTheoremKey.nargs
code: /-- Keys used to find corresponding `CCCongrTheorem`s. -/
structure CCCongrTheoremKey where
  /-- The function of the given `CCCongrTheorem`. -/
  fn : Expr
  /-- The number of arguments of `fn`. -/
  nargs : Nat
  deriving BEq, Hashable
goal: Nat

full_name: Mathlib.Tactic.CC.CCCongrTheoremKey
code: /-- Keys used to find corresponding `CCCongrTheorem`s. -/
structure CCCongrTheoremKey where
  /-- The function of the given `CCCongrTheorem`. -/
  fn : Expr
  /-- The number of arguments of `fn`. -/
  nargs : Nat
  deriving BEq, Hashable
goal: Type

full_name: Mathlib.Tactic.CC.CCCongrTheoremKey.fn
code: /-- Keys used to find corresponding `CCCongrTheorem`s. -/
structure CCCongrTheoremKey where
  /-- The function of the given `CCCongrTheorem`. -/
  fn : Expr
  /-- The number of arguments of `fn`. -/
  nargs : Nat
  deriving BEq, Hashable
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.instHashableCCCongrTheoremKey
code: /-- Keys used to find corresponding `CCCongrTheorem`s. -/
structure CCCongrTheoremKey where
  /-- The function of the given `CCCongrTheorem`. -/
  fn : Expr
  /-- The number of arguments of `fn`. -/
  nargs : Nat
  deriving BEq, Hashable
goal: Hashable Mathlib.Tactic.CC.CCCongrTheoremKey

full_name: Mathlib.Tactic.CC.instBEqCCCongrTheoremKey
code: /-- Keys used to find corresponding `CCCongrTheorem`s. -/
structure CCCongrTheoremKey where
  /-- The function of the given `CCCongrTheorem`. -/
  fn : Expr
  /-- The number of arguments of `fn`. -/
  nargs : Nat
  deriving BEq, Hashable
goal: BEq Mathlib.Tactic.CC.CCCongrTheoremKey

full_name: Mathlib.Tactic.CC.CCCongrTheoremCache
code: /-- Caches used to find corresponding `CCCongrTheorem`s. -/
abbrev CCCongrTheoremCache 
goal: Type

full_name: Mathlib.Tactic.CC.CCConfig.em
code: /-- Configs used in congruence closure modules. -/
structure CCConfig where
  /-- If `true`, congruence closure will treat implicit instance arguments as constants.

  This means that setting `ignoreInstances := false` will fail to unify two definitionally equal
  instances of the same class. -/
  ignoreInstances : Bool := true
  /-- If `true`, congruence closure modulo Associativity and Commutativity. -/
  ac : Bool := true
  /-- If `hoFns` is `some fns`, then full (and more expensive) support for higher-order functions is
     *only* considered for the functions in fns and local functions. The performance overhead is
     described in the paper "Congruence Closure in Intensional Type Theory". If `hoFns` is `none`,
     then full support is provided for *all* constants. -/
  hoFns : Option (List Name) := none
  /-- If `true`, then use excluded middle -/
  em : Bool := true
  /-- If `true`, we treat values as atomic symbols -/
  values : Bool := false
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.CCConfig
code: /-- Configs used in congruence closure modules. -/
structure CCConfig where
  /-- If `true`, congruence closure will treat implicit instance arguments as constants.

  This means that setting `ignoreInstances := false` will fail to unify two definitionally equal
  instances of the same class. -/
  ignoreInstances : Bool := true
  /-- If `true`, congruence closure modulo Associativity and Commutativity. -/
  ac : Bool := true
  /-- If `hoFns` is `some fns`, then full (and more expensive) support for higher-order functions is
     *only* considered for the functions in fns and local functions. The performance overhead is
     described in the paper "Congruence Closure in Intensional Type Theory". If `hoFns` is `none`,
     then full support is provided for *all* constants. -/
  hoFns : Option (List Name) := none
  /-- If `true`, then use excluded middle -/
  em : Bool := true
  /-- If `true`, we treat values as atomic symbols -/
  values : Bool := false
  deriving Inhabited
goal: Type

full_name: Mathlib.Tactic.CC.CCConfig.values
code: /-- Configs used in congruence closure modules. -/
structure CCConfig where
  /-- If `true`, congruence closure will treat implicit instance arguments as constants.

  This means that setting `ignoreInstances := false` will fail to unify two definitionally equal
  instances of the same class. -/
  ignoreInstances : Bool := true
  /-- If `true`, congruence closure modulo Associativity and Commutativity. -/
  ac : Bool := true
  /-- If `hoFns` is `some fns`, then full (and more expensive) support for higher-order functions is
     *only* considered for the functions in fns and local functions. The performance overhead is
     described in the paper "Congruence Closure in Intensional Type Theory". If `hoFns` is `none`,
     then full support is provided for *all* constants. -/
  hoFns : Option (List Name) := none
  /-- If `true`, then use excluded middle -/
  em : Bool := true
  /-- If `true`, we treat values as atomic symbols -/
  values : Bool := false
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.CCConfig.ignoreInstances
code: /-- Configs used in congruence closure modules. -/
structure CCConfig where
  /-- If `true`, congruence closure will treat implicit instance arguments as constants.

  This means that setting `ignoreInstances := false` will fail to unify two definitionally equal
  instances of the same class. -/
  ignoreInstances : Bool := true
  /-- If `true`, congruence closure modulo Associativity and Commutativity. -/
  ac : Bool := true
  /-- If `hoFns` is `some fns`, then full (and more expensive) support for higher-order functions is
     *only* considered for the functions in fns and local functions. The performance overhead is
     described in the paper "Congruence Closure in Intensional Type Theory". If `hoFns` is `none`,
     then full support is provided for *all* constants. -/
  hoFns : Option (List Name) := none
  /-- If `true`, then use excluded middle -/
  em : Bool := true
  /-- If `true`, we treat values as atomic symbols -/
  values : Bool := false
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.CCConfig.hoFns
code: /-- Configs used in congruence closure modules. -/
structure CCConfig where
  /-- If `true`, congruence closure will treat implicit instance arguments as constants.

  This means that setting `ignoreInstances := false` will fail to unify two definitionally equal
  instances of the same class. -/
  ignoreInstances : Bool := true
  /-- If `true`, congruence closure modulo Associativity and Commutativity. -/
  ac : Bool := true
  /-- If `hoFns` is `some fns`, then full (and more expensive) support for higher-order functions is
     *only* considered for the functions in fns and local functions. The performance overhead is
     described in the paper "Congruence Closure in Intensional Type Theory". If `hoFns` is `none`,
     then full support is provided for *all* constants. -/
  hoFns : Option (List Name) := none
  /-- If `true`, then use excluded middle -/
  em : Bool := true
  /-- If `true`, we treat values as atomic symbols -/
  values : Bool := false
  deriving Inhabited
goal: Option (List Lean.Name)

full_name: Mathlib.Tactic.CC.instInhabitedCCConfig
code: /-- Configs used in congruence closure modules. -/
structure CCConfig where
  /-- If `true`, congruence closure will treat implicit instance arguments as constants.

  This means that setting `ignoreInstances := false` will fail to unify two definitionally equal
  instances of the same class. -/
  ignoreInstances : Bool := true
  /-- If `true`, congruence closure modulo Associativity and Commutativity. -/
  ac : Bool := true
  /-- If `hoFns` is `some fns`, then full (and more expensive) support for higher-order functions is
     *only* considered for the functions in fns and local functions. The performance overhead is
     described in the paper "Congruence Closure in Intensional Type Theory". If `hoFns` is `none`,
     then full support is provided for *all* constants. -/
  hoFns : Option (List Name) := none
  /-- If `true`, then use excluded middle -/
  em : Bool := true
  /-- If `true`, we treat values as atomic symbols -/
  values : Bool := false
  deriving Inhabited
goal: Inhabited Mathlib.Tactic.CC.CCConfig

full_name: Mathlib.Tactic.CC.CCConfig.ac
code: /-- Configs used in congruence closure modules. -/
structure CCConfig where
  /-- If `true`, congruence closure will treat implicit instance arguments as constants.

  This means that setting `ignoreInstances := false` will fail to unify two definitionally equal
  instances of the same class. -/
  ignoreInstances : Bool := true
  /-- If `true`, congruence closure modulo Associativity and Commutativity. -/
  ac : Bool := true
  /-- If `hoFns` is `some fns`, then full (and more expensive) support for higher-order functions is
     *only* considered for the functions in fns and local functions. The performance overhead is
     described in the paper "Congruence Closure in Intensional Type Theory". If `hoFns` is `none`,
     then full support is provided for *all* constants. -/
  hoFns : Option (List Name) := none
  /-- If `true`, then use excluded middle -/
  em : Bool := true
  /-- If `true`, we treat values as atomic symbols -/
  values : Bool := false
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.ACApps.apps
code: /-- An `ACApps` represents either just an `Expr` or applications of an associative and commutative
  binary operator. -/
inductive ACApps where
  /-- An `ACApps` of just an `Expr`. -/
  | ofExpr (e : Expr) : ACApps
  /-- An `ACApps` of applications of a binary operator. `args` are assumed to be sorted.

    See also `ACApps.mkApps` if `args` are not yet sorted. -/
  | apps (op : Expr) (args : Array Expr) : ACApps
  deriving Inhabited, BEq
goal: Mathlib.Tactic.CC.ACApps

full_name: Mathlib.Tactic.CC.ACApps.ofExpr
code: /-- An `ACApps` represents either just an `Expr` or applications of an associative and commutative
  binary operator. -/
inductive ACApps where
  /-- An `ACApps` of just an `Expr`. -/
  | ofExpr (e : Expr) : ACApps
  /-- An `ACApps` of applications of a binary operator. `args` are assumed to be sorted.

    See also `ACApps.mkApps` if `args` are not yet sorted. -/
  | apps (op : Expr) (args : Array Expr) : ACApps
  deriving Inhabited, BEq
goal: Mathlib.Tactic.CC.ACApps

full_name: Mathlib.Tactic.CC.instInhabitedACApps
code: /-- An `ACApps` represents either just an `Expr` or applications of an associative and commutative
  binary operator. -/
inductive ACApps where
  /-- An `ACApps` of just an `Expr`. -/
  | ofExpr (e : Expr) : ACApps
  /-- An `ACApps` of applications of a binary operator. `args` are assumed to be sorted.

    See also `ACApps.mkApps` if `args` are not yet sorted. -/
  | apps (op : Expr) (args : Array Expr) : ACApps
  deriving Inhabited, BEq
goal: Inhabited Mathlib.Tactic.CC.ACApps

full_name: Mathlib.Tactic.CC.instBEqACApps
code: /-- An `ACApps` represents either just an `Expr` or applications of an associative and commutative
  binary operator. -/
inductive ACApps where
  /-- An `ACApps` of just an `Expr`. -/
  | ofExpr (e : Expr) : ACApps
  /-- An `ACApps` of applications of a binary operator. `args` are assumed to be sorted.

    See also `ACApps.mkApps` if `args` are not yet sorted. -/
  | apps (op : Expr) (args : Array Expr) : ACApps
  deriving Inhabited, BEq
goal: BEq Mathlib.Tactic.CC.ACApps

full_name: Mathlib.Tactic.CC.ACApps
code: /-- An `ACApps` represents either just an `Expr` or applications of an associative and commutative
  binary operator. -/
inductive ACApps where
  /-- An `ACApps` of just an `Expr`. -/
  | ofExpr (e : Expr) : ACApps
  /-- An `ACApps` of applications of a binary operator. `args` are assumed to be sorted.

    See also `ACApps.mkApps` if `args` are not yet sorted. -/
  | apps (op : Expr) (args : Array Expr) : ACApps
  deriving Inhabited, BEq
goal: Type

full_name: Mathlib.Tactic.CC.instCoeExprACApps
code: instance : Coe Expr ACApps 
goal: Coe Lean.Expr Mathlib.Tactic.CC.ACApps

full_name: Mathlib.Tactic.CC.instOrdACApps
code: /-- Ordering on `ACApps` sorts `.ofExpr` before `.apps`, and sorts `.apps` by function symbol,
  then by shortlex order. -/
scoped instance : Ord ACApps 
goal: Ord Mathlib.Tactic.CC.ACApps

full_name: Mathlib.Tactic.CC.ACApps.isSubset
code: /-- Return true iff `e₁` is a "subset" of `e₂`.

Example: The result is `true` for `e₁ := a*a*a*b*d` and `e₂ := a*a*a*a*b*b*c*d*d`.
The result is also `true` for `e₁ := a` and `e₂ := a*a*a*b*c`. -/
def ACApps.isSubset : (e₁ e₂ : ACApps) → Bool
  
goal: Bool

full_name: Mathlib.Tactic.CC.ACApps.diff
code: /-- Appends elements of the set difference `e₁ \ e₂` to `r`.
Example: given `e₁ := a*a*a*a*b*b*c*d*d*d` and `e₂ := a*a*a*b*b*d`,
the result is `#[a, c, d, d]`

Precondition: `e₂.isSubset e₁` -/
def ACApps.diff (e₁ e₂ : ACApps) (r : Array Expr := #[]) : Array Expr 
goal: Array Lean.Expr

full_name: Mathlib.Tactic.CC.ACApps.append
code: /-- Appends arguments of `e` to `r`. -/
def ACApps.append (op : Expr) (e : ACApps) (r : Array Expr := #[]) : Array Expr 
goal: Array Lean.Expr

full_name: Mathlib.Tactic.CC.ACApps.intersection
code: /-- Appends elements in the intersection of `e₁` and `e₂` to `r`. -/
def ACApps.intersection (e₁ e₂ : ACApps) (r : Array Expr := #[]) : Array Expr 
goal: Array Lean.Expr

full_name: Mathlib.Tactic.CC.ACApps.mkApps
code: /-- Sorts `args` and applies them to `ACApps.apps`. -/
def ACApps.mkApps (op : Expr) (args : Array Expr) : ACApps 
goal: Mathlib.Tactic.CC.ACApps

full_name: Mathlib.Tactic.CC.ACApps.mkFlatApps
code: /-- Flattens given two `ACApps`. -/
def ACApps.mkFlatApps (op : Expr) (e₁ e₂ : ACApps) : ACApps 
goal: Mathlib.Tactic.CC.ACApps

full_name: Mathlib.Tactic.CC.ACApps.toExpr
code: /-- Converts an `ACApps` to an `Expr`. This returns `none` when the empty applications are given. -/
def ACApps.toExpr : ACApps → Option Expr
  
goal: Mathlib.Tactic.CC.ACApps → Option Lean.Expr

full_name: Mathlib.Tactic.CC.RBACAppsMap
code: /-- Red-black maps whose keys are `ACApps`es.

TODO: the choice between `RBMap` and `HashMap` is not obvious:
the current version follows the Lean 3 C++ implementation.
Once the `cc` tactic is used a lot in Mathlib, we should profile and see
if `HashMap` could be more optimal. -/
abbrev RBACAppsMap (α : Type u) 
goal: Type u

full_name: Mathlib.Tactic.CC.RBACAppsSet
code: /-- Red-black sets of `ACApps`es.

TODO: the choice between `RBSet` and `HashSet` is not obvious:
the current version follows the Lean 3 C++ implementation.
Once the `cc` tactic is used a lot in Mathlib, we should profile and see
if `HashSet` could be more optimal. -/
abbrev RBACAppsSet 
goal: Type

full_name: Mathlib.Tactic.CC.DelayedExpr.eqTransOpt
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr.heqOfEq
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr.heqSymm
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Type

full_name: Mathlib.Tactic.CC.DelayedExpr.ofExpr
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr.eqSymmOpt
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr.eqTrans
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr.congrFun
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr.eqSymm
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr.congrArg
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.instInhabitedDelayedExpr
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Inhabited Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.DelayedExpr.eqProof
code: /-- For proof terms generated by AC congruence closure modules, we want a placeholder as an equality
  proof between given two terms which will be generated by non-AC congruence closure modules later.
  `DelayedExpr` represents it using `eqProof`. -/
inductive DelayedExpr where
  /-- A `DelayedExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : DelayedExpr
  /-- A placeholder as an equality proof between given two terms which will be generated by non-AC
  congruence closure modules later. -/
  | eqProof (lhs rhs : Expr) : DelayedExpr
  /-- Will be applied to `congr_arg`. -/
  | congrArg (f : Expr) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `congr_fun`. -/
  | congrFun (h : DelayedExpr) (a : ACApps) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymm (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.symm`. -/
  | eqSymmOpt (a₁ a₂ : ACApps) (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTrans (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `Eq.trans`. -/
  | eqTransOpt (a₁ a₂ a₃ : ACApps) (h₁ h₂ : DelayedExpr) : DelayedExpr
  /-- Will be applied to `heq_of_eq`. -/
  | heqOfEq (h : DelayedExpr) : DelayedExpr
  /-- Will be applied to `HEq.symm`. -/
  | heqSymm (h : DelayedExpr) : DelayedExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.instCoeExprDelayedExpr
code: instance : Coe Expr DelayedExpr 
goal: Coe Lean.Expr Mathlib.Tactic.CC.DelayedExpr

full_name: Mathlib.Tactic.CC.EntryExpr.congr
code: /-- This is used as a proof term in `Entry`s instead of `Expr`. -/
inductive EntryExpr
  /-- An `EntryExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : EntryExpr
  /-- dummy congruence proof, it is just a placeholder. -/
  | congr : EntryExpr
  /-- dummy eq_true proof, it is just a placeholder -/
  | eqTrue : EntryExpr
  /-- dummy refl proof, it is just a placeholder. -/
  | refl : EntryExpr
  /-- An `EntryExpr` of a `DelayedExpr`. -/
  | ofDExpr (e : DelayedExpr) : EntryExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.instInhabitedEntryExpr
code: /-- This is used as a proof term in `Entry`s instead of `Expr`. -/
inductive EntryExpr
  /-- An `EntryExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : EntryExpr
  /-- dummy congruence proof, it is just a placeholder. -/
  | congr : EntryExpr
  /-- dummy eq_true proof, it is just a placeholder -/
  | eqTrue : EntryExpr
  /-- dummy refl proof, it is just a placeholder. -/
  | refl : EntryExpr
  /-- An `EntryExpr` of a `DelayedExpr`. -/
  | ofDExpr (e : DelayedExpr) : EntryExpr
  deriving Inhabited
goal: Inhabited Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.EntryExpr
code: /-- This is used as a proof term in `Entry`s instead of `Expr`. -/
inductive EntryExpr
  /-- An `EntryExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : EntryExpr
  /-- dummy congruence proof, it is just a placeholder. -/
  | congr : EntryExpr
  /-- dummy eq_true proof, it is just a placeholder -/
  | eqTrue : EntryExpr
  /-- dummy refl proof, it is just a placeholder. -/
  | refl : EntryExpr
  /-- An `EntryExpr` of a `DelayedExpr`. -/
  | ofDExpr (e : DelayedExpr) : EntryExpr
  deriving Inhabited
goal: Type

full_name: Mathlib.Tactic.CC.EntryExpr.ofDExpr
code: /-- This is used as a proof term in `Entry`s instead of `Expr`. -/
inductive EntryExpr
  /-- An `EntryExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : EntryExpr
  /-- dummy congruence proof, it is just a placeholder. -/
  | congr : EntryExpr
  /-- dummy eq_true proof, it is just a placeholder -/
  | eqTrue : EntryExpr
  /-- dummy refl proof, it is just a placeholder. -/
  | refl : EntryExpr
  /-- An `EntryExpr` of a `DelayedExpr`. -/
  | ofDExpr (e : DelayedExpr) : EntryExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.EntryExpr.eqTrue
code: /-- This is used as a proof term in `Entry`s instead of `Expr`. -/
inductive EntryExpr
  /-- An `EntryExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : EntryExpr
  /-- dummy congruence proof, it is just a placeholder. -/
  | congr : EntryExpr
  /-- dummy eq_true proof, it is just a placeholder -/
  | eqTrue : EntryExpr
  /-- dummy refl proof, it is just a placeholder. -/
  | refl : EntryExpr
  /-- An `EntryExpr` of a `DelayedExpr`. -/
  | ofDExpr (e : DelayedExpr) : EntryExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.EntryExpr.ofExpr
code: /-- This is used as a proof term in `Entry`s instead of `Expr`. -/
inductive EntryExpr
  /-- An `EntryExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : EntryExpr
  /-- dummy congruence proof, it is just a placeholder. -/
  | congr : EntryExpr
  /-- dummy eq_true proof, it is just a placeholder -/
  | eqTrue : EntryExpr
  /-- dummy refl proof, it is just a placeholder. -/
  | refl : EntryExpr
  /-- An `EntryExpr` of a `DelayedExpr`. -/
  | ofDExpr (e : DelayedExpr) : EntryExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.EntryExpr.refl
code: /-- This is used as a proof term in `Entry`s instead of `Expr`. -/
inductive EntryExpr
  /-- An `EntryExpr` of just an `Expr`. -/
  | ofExpr (e : Expr) : EntryExpr
  /-- dummy congruence proof, it is just a placeholder. -/
  | congr : EntryExpr
  /-- dummy eq_true proof, it is just a placeholder -/
  | eqTrue : EntryExpr
  /-- dummy refl proof, it is just a placeholder. -/
  | refl : EntryExpr
  /-- An `EntryExpr` of a `DelayedExpr`. -/
  | ofDExpr (e : DelayedExpr) : EntryExpr
  deriving Inhabited
goal: Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.instToMessageDataEntryExpr
code: instance : ToMessageData EntryExpr 
goal: Lean.ToMessageData Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.instCoeExprEntryExpr
code: instance : Coe Expr EntryExpr 
goal: Coe Lean.Expr Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.Entry.root
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.Entry.target
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Option Lean.Expr

full_name: Mathlib.Tactic.CC.Entry.mt
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Nat

full_name: Mathlib.Tactic.CC.Entry.acVar
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Option Lean.Expr

full_name: Mathlib.Tactic.CC.Entry.size
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Nat

full_name: Mathlib.Tactic.CC.Entry.flipped
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.Entry.cgRoot
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.Entry.next
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.Entry
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Type

full_name: Mathlib.Tactic.CC.Entry.proof
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Option Mathlib.Tactic.CC.EntryExpr

full_name: Mathlib.Tactic.CC.Entry.hasLambdas
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.Entry.interpreted
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.Entry.constructor
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.Entry.heqProofs
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.Entry.fo
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.instInhabitedEntry
code: /-- Equivalence class data associated with an expression `e`. -/
structure Entry where
  /-- next element in the equivalence class. -/
  next : Expr
  /-- root (aka canonical) representative of the equivalence class. -/
  root : Expr
  /-- root of the congruence class, it is meaningless if `e` is not an application. -/
  cgRoot : Expr
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  target : Option Expr := none
  /-- When `e` was added to this equivalence class because of an equality `(H : e = tgt)`, then
      we store `tgt` at `target`, and `H` at `proof`. Both fields are none if `e == root` -/
  proof : Option EntryExpr := none
  /-- Variable in the AC theory. -/
  acVar : Option Expr := none
  /-- proof has been flipped -/
  flipped : Bool
  /-- `true` if the node should be viewed as an abstract value -/
  interpreted : Bool
  /-- `true` if head symbol is a constructor -/
  constructor : Bool
  /-- `true` if equivalence class contains lambda expressions -/
  hasLambdas : Bool
  /-- `heqProofs == true` iff some proofs in the equivalence class are based on heterogeneous
      equality. We represent equality and heterogeneous equality in a single equivalence class. -/
  heqProofs : Bool
  /-- If `fo == true`, then the expression associated with this entry is an application, and we are
      using first-order approximation to encode it. That is, we ignore its partial applications. -/
  fo : Bool
  /-- number of elements in the equivalence class, it is meaningless if `e != root` -/
  size : Nat
  /-- The field `mt` is used to implement the mod-time optimization introduce by the Simplify
      theorem prover. The basic idea is to introduce a counter gmt that records the number of
      heuristic instantiation that have occurred in the current branch. It is incremented after each
      round of heuristic instantiation. The field `mt` records the last time any proper descendant
      of of thie entry was involved in a merge. -/
  mt : Nat
  deriving Inhabited
goal: Inhabited Mathlib.Tactic.CC.Entry

full_name: Mathlib.Tactic.CC.Entries
code: /-- Stores equivalence class data associated with an expression `e`. -/
abbrev Entries 
goal: Type

full_name: Mathlib.Tactic.CC.ACEntry.idx
code: /-- Equivalence class data associated with an expression `e` used by AC congruence closure
modules. -/
structure ACEntry where
  /-- Natural number associated to an expression. -/
  idx : Nat
  /-- AC variables that occur on the left hand side of an equality which `e` occurs as the left hand
  side of in `CCState.acR`. -/
  RLHSOccs : RBACAppsSet := ∅
  /-- AC variables that occur on the **left** hand side of an equality which `e` occurs as the right
  hand side of in `CCState.acR`. Don't confuse. -/
  RRHSOccs : RBACAppsSet := ∅
  deriving Inhabited
goal: Nat

full_name: Mathlib.Tactic.CC.instInhabitedACEntry
code: /-- Equivalence class data associated with an expression `e` used by AC congruence closure
modules. -/
structure ACEntry where
  /-- Natural number associated to an expression. -/
  idx : Nat
  /-- AC variables that occur on the left hand side of an equality which `e` occurs as the left hand
  side of in `CCState.acR`. -/
  RLHSOccs : RBACAppsSet := ∅
  /-- AC variables that occur on the **left** hand side of an equality which `e` occurs as the right
  hand side of in `CCState.acR`. Don't confuse. -/
  RRHSOccs : RBACAppsSet := ∅
  deriving Inhabited
goal: Inhabited Mathlib.Tactic.CC.ACEntry

full_name: Mathlib.Tactic.CC.ACEntry
code: /-- Equivalence class data associated with an expression `e` used by AC congruence closure
modules. -/
structure ACEntry where
  /-- Natural number associated to an expression. -/
  idx : Nat
  /-- AC variables that occur on the left hand side of an equality which `e` occurs as the left hand
  side of in `CCState.acR`. -/
  RLHSOccs : RBACAppsSet := ∅
  /-- AC variables that occur on the **left** hand side of an equality which `e` occurs as the right
  hand side of in `CCState.acR`. Don't confuse. -/
  RRHSOccs : RBACAppsSet := ∅
  deriving Inhabited
goal: Type

full_name: Mathlib.Tactic.CC.ACEntry.RLHSOccs
code: /-- Equivalence class data associated with an expression `e` used by AC congruence closure
modules. -/
structure ACEntry where
  /-- Natural number associated to an expression. -/
  idx : Nat
  /-- AC variables that occur on the left hand side of an equality which `e` occurs as the left hand
  side of in `CCState.acR`. -/
  RLHSOccs : RBACAppsSet := ∅
  /-- AC variables that occur on the **left** hand side of an equality which `e` occurs as the right
  hand side of in `CCState.acR`. Don't confuse. -/
  RRHSOccs : RBACAppsSet := ∅
  deriving Inhabited
goal: Mathlib.Tactic.CC.RBACAppsSet

full_name: Mathlib.Tactic.CC.ACEntry.RRHSOccs
code: /-- Equivalence class data associated with an expression `e` used by AC congruence closure
modules. -/
structure ACEntry where
  /-- Natural number associated to an expression. -/
  idx : Nat
  /-- AC variables that occur on the left hand side of an equality which `e` occurs as the left hand
  side of in `CCState.acR`. -/
  RLHSOccs : RBACAppsSet := ∅
  /-- AC variables that occur on the **left** hand side of an equality which `e` occurs as the right
  hand side of in `CCState.acR`. Don't confuse. -/
  RRHSOccs : RBACAppsSet := ∅
  deriving Inhabited
goal: Mathlib.Tactic.CC.RBACAppsSet

full_name: Mathlib.Tactic.CC.ACEntry.ROccs
code: /-- Returns the occurrences of this entry in either the LHS or RHS. -/
def ACEntry.ROccs (ent : ACEntry) : (inLHS : Bool) → RBACAppsSet
  
goal: Mathlib.Tactic.CC.RBACAppsSet

full_name: Mathlib.Tactic.CC.ParentOcc.expr
code: /-- Used to record when an expression processed by `cc` occurs in another expression. -/
structure ParentOcc where
  expr : Expr
  /-- If `symmTable` is true, then we should use the `symmCongruences`, otherwise `congruences`.
      Remark: this information is redundant, it can be inferred from `expr`. We use store it for
      performance reasons. -/
  symmTable : Bool
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.ParentOcc.symmTable
code: /-- Used to record when an expression processed by `cc` occurs in another expression. -/
structure ParentOcc where
  expr : Expr
  /-- If `symmTable` is true, then we should use the `symmCongruences`, otherwise `congruences`.
      Remark: this information is redundant, it can be inferred from `expr`. We use store it for
      performance reasons. -/
  symmTable : Bool
goal: Bool

full_name: Mathlib.Tactic.CC.ParentOcc
code: /-- Used to record when an expression processed by `cc` occurs in another expression. -/
structure ParentOcc where
  expr : Expr
  /-- If `symmTable` is true, then we should use the `symmCongruences`, otherwise `congruences`.
      Remark: this information is redundant, it can be inferred from `expr`. We use store it for
      performance reasons. -/
  symmTable : Bool
goal: Type

full_name: Mathlib.Tactic.CC.ParentOccSet
code: /-- Red-black sets of `ParentOcc`s. -/
abbrev ParentOccSet 
goal: Type

full_name: Mathlib.Tactic.CC.Parents
code: /-- Used to map an expression `e` to another expression that contains `e`.

When `e` is normalized, its parents should also change. -/
abbrev Parents 
goal: Type

full_name: Mathlib.Tactic.CC.instHashableCongruencesKey
code: inductive CongruencesKey
  /-- `fn` is First-Order: we do not consider all partial applications. -/
  | fo (fn : Expr) (args : Array Expr) : CongruencesKey
  /-- `fn` is Higher-Order. -/
  | ho (fn : Expr) (arg : Expr) : CongruencesKey
  deriving BEq, Hashable
goal: Hashable Mathlib.Tactic.CC.CongruencesKey

full_name: Mathlib.Tactic.CC.CongruencesKey.ho
code: inductive CongruencesKey
  /-- `fn` is First-Order: we do not consider all partial applications. -/
  | fo (fn : Expr) (args : Array Expr) : CongruencesKey
  /-- `fn` is Higher-Order. -/
  | ho (fn : Expr) (arg : Expr) : CongruencesKey
  deriving BEq, Hashable
goal: Mathlib.Tactic.CC.CongruencesKey

full_name: Mathlib.Tactic.CC.instBEqCongruencesKey
code: inductive CongruencesKey
  /-- `fn` is First-Order: we do not consider all partial applications. -/
  | fo (fn : Expr) (args : Array Expr) : CongruencesKey
  /-- `fn` is Higher-Order. -/
  | ho (fn : Expr) (arg : Expr) : CongruencesKey
  deriving BEq, Hashable
goal: BEq Mathlib.Tactic.CC.CongruencesKey

full_name: Mathlib.Tactic.CC.CongruencesKey
code: inductive CongruencesKey
  /-- `fn` is First-Order: we do not consider all partial applications. -/
  | fo (fn : Expr) (args : Array Expr) : CongruencesKey
  /-- `fn` is Higher-Order. -/
  | ho (fn : Expr) (arg : Expr) : CongruencesKey
  deriving BEq, Hashable
goal: Type

full_name: Mathlib.Tactic.CC.CongruencesKey.fo
code: inductive CongruencesKey
  /-- `fn` is First-Order: we do not consider all partial applications. -/
  | fo (fn : Expr) (args : Array Expr) : CongruencesKey
  /-- `fn` is Higher-Order. -/
  | ho (fn : Expr) (arg : Expr) : CongruencesKey
  deriving BEq, Hashable
goal: Mathlib.Tactic.CC.CongruencesKey

full_name: Mathlib.Tactic.CC.Congruences
code: /-- Maps each expression (via `mkCongruenceKey`) to expressions it might be congruent to. -/
abbrev Congruences 
goal: Type

full_name: Mathlib.Tactic.CC.SymmCongruencesKey.h₁
code: structure SymmCongruencesKey where
  (h₁ h₂ : Expr)
  deriving BEq, Hashable
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.SymmCongruencesKey.h₂
code: structure SymmCongruencesKey where
  (h₁ h₂ : Expr)
  deriving BEq, Hashable
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.SymmCongruencesKey
code: structure SymmCongruencesKey where
  (h₁ h₂ : Expr)
  deriving BEq, Hashable
goal: Type

full_name: Mathlib.Tactic.CC.instBEqSymmCongruencesKey
code: structure SymmCongruencesKey where
  (h₁ h₂ : Expr)
  deriving BEq, Hashable
goal: BEq Mathlib.Tactic.CC.SymmCongruencesKey

full_name: Mathlib.Tactic.CC.instHashableSymmCongruencesKey
code: structure SymmCongruencesKey where
  (h₁ h₂ : Expr)
  deriving BEq, Hashable
goal: Hashable Mathlib.Tactic.CC.SymmCongruencesKey

full_name: Mathlib.Tactic.CC.SymmCongruences
code: /-- The symmetric variant of `Congruences`.

The `Name` identifies which relation the congruence is considered for.
Note that this only works for two-argument relations: `ModEq n` and `ModEq m` are considered the
same. -/
abbrev SymmCongruences 
goal: Type

full_name: Mathlib.Tactic.CC.SubsingletonReprs
code: /-- Stores the root representatives of subsingletons. -/
abbrev SubsingletonReprs 
goal: Type

full_name: Mathlib.Tactic.CC.InstImplicitReprs
code: /-- Stores the root representatives of `.instImplicit` arguments. -/
abbrev InstImplicitReprs 
goal: Type

full_name: Mathlib.Tactic.CC.TodoEntry
code: abbrev TodoEntry 
goal: Type

full_name: Mathlib.Tactic.CC.ACTodoEntry
code: abbrev ACTodoEntry 
goal: Type

full_name: Mathlib.Tactic.CC.CCState
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Type

full_name: Mathlib.Tactic.CC.CCState.parents
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.Parents

full_name: Mathlib.Tactic.CC.CCState.inconsistent
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.CCState.gmt
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Nat

full_name: Mathlib.Tactic.CC.CCState.subsingletonReprs
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.SubsingletonReprs

full_name: Mathlib.Tactic.CC.CCState.congruences
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.Congruences

full_name: Mathlib.Tactic.CC.CCState.frozePartitions
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Bool

full_name: Mathlib.Tactic.CC.CCState.canOps
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.RBExprMap Lean.Expr

full_name: Mathlib.Tactic.CC.CCState.opInfo
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.RBExprMap Bool

full_name: Mathlib.Tactic.CC.CCState.symmCongruences
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.SymmCongruences

full_name: Mathlib.Tactic.CC.CCState.acR
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.RBACAppsMap (Mathlib.Tactic.CC.ACApps × Mathlib.Tactic.CC.DelayedExpr)

full_name: Mathlib.Tactic.CC.instInhabitedCCState
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Inhabited Mathlib.Tactic.CC.CCState

full_name: Mathlib.Tactic.CC.CCState.acEntries
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.RBExprMap Mathlib.Tactic.CC.ACEntry

full_name: Mathlib.Tactic.CC.CCState.entries
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.Entries

full_name: Mathlib.Tactic.CC.CCState.instImplicitReprs
code: /-- Congruence closure state.
This may be considered to be a set of expressions and an equivalence class over this set.
The equivalence class is generated by the equational rules that are added to the `CCState` and
congruence, that is, if `a = b` then `f(a) = f(b)` and so on. -/
structure CCState extends CCConfig where
  /-- Maps known expressions to their equivalence class data. -/
  entries : Entries := ∅
  /-- Maps an expression `e` to the expressions `e` occurs in. -/
  parents : Parents := ∅
  /-- Maps each expression to a set of expressions it might be congruent to. -/
  congruences : Congruences := ∅
  /-- Maps each expression to a set of expressions it might be congruent to,
  via the symmetrical relation. -/
  symmCongruences : SymmCongruences := ∅
  subsingletonReprs : SubsingletonReprs := ∅
  /-- Records which instances of the same class are defeq. -/
  instImplicitReprs : InstImplicitReprs := ∅
  /-- The congruence closure module has a mode where the root of each equivalence class is marked as
      an interpreted/abstract value. Moreover, in this mode proof production is disabled.
      This capability is useful for heuristic instantiation. -/
  frozePartitions : Bool := false
  /-- Mapping from operators occurring in terms and their canonical
      representation in this module -/
  canOps : RBExprMap Expr := ∅
  /-- Whether the canonical operator is suppoted by AC. -/
  opInfo : RBExprMap Bool := ∅
  /-- Extra `Entry` information used by the AC part of the tactic. -/
  acEntries : RBExprMap ACEntry := ∅
  /-- Records equality between `ACApps`. -/
  acR : RBACAppsMap (ACApps × DelayedExpr) := ∅
  /-- Returns true if the `CCState` is inconsistent. For example if it had both `a = b` and `a ≠ b`
      in it.-/
  inconsistent : Bool := false
  /-- "Global Modification Time". gmt is a number stored on the `CCState`,
      it is compared with the modification time of a cc_entry in e-matching. See `CCState.mt`. -/
  gmt : Nat := 0
  deriving Inhabited
goal: Mathlib.Tactic.CC.InstImplicitReprs

full_name: Mathlib.Tactic.CC.CCState.mkEntryCore
code: /-- Update the `CCState` by constructing and inserting a new `Entry`. -/
def CCState.mkEntryCore (ccs : CCState) (e : Expr) (interpreted : Bool) (constructor : Bool) :
    CCState 
goal: Mathlib.Tactic.CC.CCState

full_name: Mathlib.Tactic.CC.CCState.root
code: /-- Get the root representative of the given expression. -/
def root (ccs : CCState) (e : Expr) : Expr 
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.CCState.next
code: /-- Get the next element in the equivalence class.
Note that if the given `Expr` `e` is not in the graph then it will just return `e`. -/
def next (ccs : CCState) (e : Expr) : Expr 
goal: Lean.Expr

full_name: Mathlib.Tactic.CC.CCState.isCgRoot
code: /-- Check if `e` is the root of the congruence class. -/
def isCgRoot (ccs : CCState) (e : Expr) : Bool 
goal: Bool

full_name: Mathlib.Tactic.CC.CCState.mt
code: /--
"Modification Time". The field `mt` is used to implement the mod-time optimization introduced by the
Simplify theorem prover. The basic idea is to introduce a counter `gmt` that records the number of
heuristic instantiation that have occurred in the current branch. It is incremented after each round
of heuristic instantiation. The field `mt` records the last time any proper descendant of of thie
entry was involved in a merge. -/
def mt (ccs : CCState) (e : Expr) : Nat 
goal: Nat

full_name: Mathlib.Tactic.CC.CCState.inSingletonEqc
code: /-- Is the expression in an equivalence class with only one element (namely, itself)? -/
def inSingletonEqc (ccs : CCState) (e : Expr) : Bool 
goal: Bool

full_name: Mathlib.Tactic.CC.CCState.getRoots
code: /-- Append to `roots` all the roots of equivalence classes in `ccs`.

If `nonsingletonOnly` is true, we skip all the singleton equivalence classes. -/
def getRoots (ccs : CCState) (roots : Array Expr) (nonsingletonOnly : Bool) : Array Expr 
goal: Array Lean.Expr

full_name: Mathlib.Tactic.CC.CCState.checkEqc
code: /-- Check for integrity of the `CCState`. -/
def checkEqc (ccs : CCState) (e : Expr) : Bool 
goal: Bool

full_name: Mathlib.Tactic.CC.CCState.checkInvariant
code: /-- Check for integrity of the `CCState`. -/
def checkInvariant (ccs : CCState) : Bool 
goal: Bool

full_name: Mathlib.Tactic.CC.CCState.getNumROccs
code: def getNumROccs (ccs : CCState) (e : Expr) (inLHS : Bool) : Nat 
goal: Nat

full_name: Mathlib.Tactic.CC.CCState.getVarWithLeastOccs
code: /-- Search for the AC-variable (`Entry.acVar`) with the least occurrences in the state. -/
def getVarWithLeastOccs (ccs : CCState) (e : ACApps) (inLHS : Bool) : Option Expr 
goal: Option Lean.Expr

full_name: Mathlib.Tactic.CC.CCState.getVarWithLeastLHSOccs
code: def getVarWithLeastLHSOccs (ccs : CCState) (e : ACApps) : Option Expr 
goal: Option Lean.Expr

full_name: Mathlib.Tactic.CC.CCState.getVarWithLeastRHSOccs
code: def getVarWithLeastRHSOccs (ccs : CCState) (e : ACApps) : Option Expr 
goal: Option Lean.Expr

full_name: Mathlib.Tactic.CC.CCState.ppEqc
code: /-- Pretty print the entry associated with the given expression. -/
def ppEqc (ccs : CCState) (e : Expr) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppEqcs
code: /-- Pretty print the entire cc graph.
If the `nonSingleton` argument is set to `true` then singleton equivalence classes will be
omitted. -/
def ppEqcs (ccs : CCState) (nonSingleton : Bool := true) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppParentOccsAux
code: def ppParentOccsAux (ccs : CCState) (e : Expr) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppParentOccs
code: def ppParentOccs (ccs : CCState) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppACDecl
code: def ppACDecl (ccs : CCState) (e : Expr) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppACDecls
code: def ppACDecls (ccs : CCState) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppACExpr
code: def ppACExpr (ccs : CCState) (e : Expr) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppACApps
code: partial def ppACApps (ccs : CCState) : ACApps → MessageData
  
goal: Mathlib.Tactic.CC.ACApps → Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppACR
code: def ppACR (ccs : CCState) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCState.ppAC
code: def ppAC (ccs : CCState) : MessageData 
goal: Lean.MessageData

full_name: Mathlib.Tactic.CC.CCNormalizer
code: /-- The congruence closure module (optionally) uses a normalizer.
    The idea is to use it (if available) to normalize auxiliary expressions
    produced by internal propagation rules (e.g., subsingleton propagator).  -/
structure CCNormalizer where
  normalize : Expr → MetaM Expr
goal: Type

full_name: Mathlib.Tactic.CC.CCNormalizer.normalize
code: /-- The congruence closure module (optionally) uses a normalizer.
    The idea is to use it (if available) to normalize auxiliary expressions
    produced by internal propagation rules (e.g., subsingleton propagator).  -/
structure CCNormalizer where
  normalize : Expr → MetaM Expr
goal: Lean.Expr → Lean.MetaM Lean.Expr

full_name: Mathlib.Tactic.CC.CCPropagationHandler.propagated
code: structure CCPropagationHandler where
  propagated : Array Expr → MetaM Unit
  /-- Congruence closure module invokes the following method when
      a new auxiliary term is created during propagation. -/
  newAuxCCTerm : Expr → MetaM Unit
goal: Array Lean.Expr → Lean.MetaM Unit

full_name: Mathlib.Tactic.CC.CCPropagationHandler.newAuxCCTerm
code: structure CCPropagationHandler where
  propagated : Array Expr → MetaM Unit
  /-- Congruence closure module invokes the following method when
      a new auxiliary term is created during propagation. -/
  newAuxCCTerm : Expr → MetaM Unit
goal: Lean.Expr → Lean.MetaM Unit

full_name: Mathlib.Tactic.CC.CCPropagationHandler
code: structure CCPropagationHandler where
  propagated : Array Expr → MetaM Unit
  /-- Congruence closure module invokes the following method when
      a new auxiliary term is created during propagation. -/
  newAuxCCTerm : Expr → MetaM Unit
goal: Type

full_name: Mathlib.Tactic.CC.CCStructure.normalizer
code: /-- `CCStructure` extends `CCState` (which records a set of facts derived by congruence closure)
by recording which steps still need to be taken to solve the goal.
-/
structure CCStructure extends CCState where
  /-- Equalities that have been discovered but not processed. -/
  todo : Array TodoEntry := #[]
  /-- AC-equalities that have been discovered but not processed. -/
  acTodo : Array ACTodoEntry := #[]
  normalizer : Option CCNormalizer := none
  phandler : Option CCPropagationHandler := none
  cache : CCCongrTheoremCache := ∅
  deriving Inhabited
goal: Option Mathlib.Tactic.CC.CCNormalizer

full_name: Mathlib.Tactic.CC.CCStructure.todo
code: /-- `CCStructure` extends `CCState` (which records a set of facts derived by congruence closure)
by recording which steps still need to be taken to solve the goal.
-/
structure CCStructure extends CCState where
  /-- Equalities that have been discovered but not processed. -/
  todo : Array TodoEntry := #[]
  /-- AC-equalities that have been discovered but not processed. -/
  acTodo : Array ACTodoEntry := #[]
  normalizer : Option CCNormalizer := none
  phandler : Option CCPropagationHandler := none
  cache : CCCongrTheoremCache := ∅
  deriving Inhabited
goal: Array Mathlib.Tactic.CC.TodoEntry

full_name: Mathlib.Tactic.CC.CCStructure
code: /-- `CCStructure` extends `CCState` (which records a set of facts derived by congruence closure)
by recording which steps still need to be taken to solve the goal.
-/
structure CCStructure extends CCState where
  /-- Equalities that have been discovered but not processed. -/
  todo : Array TodoEntry := #[]
  /-- AC-equalities that have been discovered but not processed. -/
  acTodo : Array ACTodoEntry := #[]
  normalizer : Option CCNormalizer := none
  phandler : Option CCPropagationHandler := none
  cache : CCCongrTheoremCache := ∅
  deriving Inhabited
goal: Type

full_name: Mathlib.Tactic.CC.instInhabitedCCStructure
code: /-- `CCStructure` extends `CCState` (which records a set of facts derived by congruence closure)
by recording which steps still need to be taken to solve the goal.
-/
structure CCStructure extends CCState where
  /-- Equalities that have been discovered but not processed. -/
  todo : Array TodoEntry := #[]
  /-- AC-equalities that have been discovered but not processed. -/
  acTodo : Array ACTodoEntry := #[]
  normalizer : Option CCNormalizer := none
  phandler : Option CCPropagationHandler := none
  cache : CCCongrTheoremCache := ∅
  deriving Inhabited
goal: Inhabited Mathlib.Tactic.CC.CCStructure

full_name: Mathlib.Tactic.CC.CCStructure.cache
code: /-- `CCStructure` extends `CCState` (which records a set of facts derived by congruence closure)
by recording which steps still need to be taken to solve the goal.
-/
structure CCStructure extends CCState where
  /-- Equalities that have been discovered but not processed. -/
  todo : Array TodoEntry := #[]
  /-- AC-equalities that have been discovered but not processed. -/
  acTodo : Array ACTodoEntry := #[]
  normalizer : Option CCNormalizer := none
  phandler : Option CCPropagationHandler := none
  cache : CCCongrTheoremCache := ∅
  deriving Inhabited
goal: Mathlib.Tactic.CC.CCCongrTheoremCache

full_name: Mathlib.Tactic.CC.CCStructure.phandler
code: /-- `CCStructure` extends `CCState` (which records a set of facts derived by congruence closure)
by recording which steps still need to be taken to solve the goal.
-/
structure CCStructure extends CCState where
  /-- Equalities that have been discovered but not processed. -/
  todo : Array TodoEntry := #[]
  /-- AC-equalities that have been discovered but not processed. -/
  acTodo : Array ACTodoEntry := #[]
  normalizer : Option CCNormalizer := none
  phandler : Option CCPropagationHandler := none
  cache : CCCongrTheoremCache := ∅
  deriving Inhabited
goal: Option Mathlib.Tactic.CC.CCPropagationHandler

full_name: Mathlib.Tactic.CC.CCStructure.acTodo
code: /-- `CCStructure` extends `CCState` (which records a set of facts derived by congruence closure)
by recording which steps still need to be taken to solve the goal.
-/
structure CCStructure extends CCState where
  /-- Equalities that have been discovered but not processed. -/
  todo : Array TodoEntry := #[]
  /-- AC-equalities that have been discovered but not processed. -/
  acTodo : Array ACTodoEntry := #[]
  normalizer : Option CCNormalizer := none
  phandler : Option CCPropagationHandler := none
  cache : CCCongrTheoremCache := ∅
  deriving Inhabited
goal: Array Mathlib.Tactic.CC.ACTodoEntry