ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Tactic/SuppressCompilation.lean

full_name: elabSuppressCompilationDecl
code: /-- Replacing `def` and `instance` by `noncomputable def` and `noncomputable instance`, designed
to disable the compiler in a given file or a given section.
This is a hack to work around mathlib4#7103. -/
def elabSuppressCompilationDecl : CommandElab 
goal: Lean.Elab.Command.CommandElab

full_name: commandUnsuppress_compilationIn_
code: /-- The command `unsuppress_compilation in def foo : ...` makes sure that the definition is
compiled to executable code, even if `suppress_compilation` is active. -/
syntax "unsuppress_compilation" (" in " command)? : command
goal: Lean.ParserDescr

full_name: expandSuppressCompilationNotation
code: /-- Make sure that notations are compiled, even if `suppress_compilation` is active, by prepending
them with `unsuppress_compilation`. -/
def expandSuppressCompilationNotation : Macro 
goal: Lean.Macro

full_name: commandSuppress_compilation
code: macro "suppress_compilation" : command => do
  let declKind := mkIdent ``declaration
  let notaKind := mkIdent ``«notation»
  let declElab := mkCIdent ``elabSuppressCompilationDecl
  let notaMacro := mkCIdent ``expandSuppressCompilationNotation
  `(
  attribute [local command_elab $declKind] $declElab
  attribute [local macro $notaKind] $notaMacro
  )
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_SuppressCompilation___macroRules_commandSuppress_compilation_1
code: macro "suppress_compilation" : command => do
  let declKind := mkIdent ``declaration
  let notaKind := mkIdent ``«notation»
  let declElab := mkCIdent ``elabSuppressCompilationDecl
  let notaMacro := mkCIdent ``expandSuppressCompilationNotation
  `(
  attribute [local command_elab $declKind] $declElab
  attribute [local macro $notaKind] $notaMacro
  )
goal: Lean.Macro

full_name: _aux_Mathlib_Tactic_SuppressCompilation___macroRules_commandUnsuppress_compilationIn__1
code: macro_rules
| `(unsuppress_compilation $[in $cmd?]?) => do
  let declElab := mkCIdent ``elabSuppressCompilationDecl
  let notaMacro := mkCIdent ``expandSuppressCompilationNotation
  let attrCmds ← `(
    attribute [-command_elab] $declElab
    attribute [-macro] $notaMacro
  )
  if let some cmd := cmd? then
    `($attrCmds:command $cmd:command suppress_compilation)
  else
    return attrCmds
goal: Lean.Macro
File: Mathlib/Tactic/Clear_.lean

full_name: Mathlib.Tactic.clear_
code: /-- Clear all hypotheses starting with `_`, like `_match` and `_let_match`. -/
elab (name := clear_) "clear_" : tactic =>
  liftMetaTactic1 fun goal ↦ do
    let mut toClear := #[]
    for decl in ← getLCtx do
      if let Name.str _ str := decl.userName then
        if !str.isEmpty && str.front == '_' then
          if let none ← isClass? decl.type then
            toClear := toClear.push decl.fvarId
    goal.tryClearMany toClear
goal: Lean.ParserDescr

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_Clear____elabRules_Mathlib_Tactic_clear__1
code: /-- Clear all hypotheses starting with `_`, like `_match` and `_let_match`. -/
elab (name := clear_) "clear_" : tactic =>
  liftMetaTactic1 fun goal ↦ do
    let mut toClear := #[]
    for decl in ← getLCtx do
      if let Name.str _ str := decl.userName then
        if !str.isEmpty && str.front == '_' then
          if let none ← isClass? decl.type then
            toClear := toClear.push decl.fvarId
    goal.tryClearMany toClear
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/Check.lean

full_name: Mathlib.Tactic.elabCheckTactic
code: /--
Tactic version of `Lean.Elab.Command.elabCheck`.
Elaborates `term` without modifying tactic/elab/meta state.
Info messages are placed at `tk`.
-/
def elabCheckTactic (tk : Syntax) (ignoreStuckTC : Bool) (term : Term) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Mathlib.Tactic.«tactic#check__»
code: /--
The `#check t` tactic elaborates the term `t` and then pretty prints it with its type as `e : ty`.

If `t` is an identifier, then it pretty prints a type declaration form
for the global constant `t` instead.
Use `#check (t)` to pretty print it as an elaborated expression.

Like the `#check` command, the `#check` tactic allows stuck typeclass instance problems.
These become metavariables in the output.
-/
elab tk:"#check " colGt term:term : tactic => elabCheckTactic tk true term
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.«_aux_Mathlib_Tactic_Check___elabRules_Mathlib_Tactic_tactic#check___1»
code: /--
The `#check t` tactic elaborates the term `t` and then pretty prints it with its type as `e : ty`.

If `t` is an identifier, then it pretty prints a type declaration form
for the global constant `t` instead.
Use `#check (t)` to pretty print it as an elaborated expression.

Like the `#check` command, the `#check` tactic allows stuck typeclass instance problems.
These become metavariables in the output.
-/
elab tk:"#check " colGt term:term : tactic => elabCheckTactic tk true term
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/SudoSetOption.lean

full_name: _private.Mathlib.Tactic.SudoSetOption.0.setOption
code: private def setOption {m : Type → Type} [Monad m] [MonadError m]
    (name val : Syntax) (opts : Options) : m Options 
goal: m Lean.Options

full_name: _aux_Mathlib_Tactic_SudoSetOption___elabRules_commandSudoSet_option____1
code: /--
The command `sudo set_option name val` is similar to `set_option name val`,
but it also allows to set undeclared options.
-/
elab "sudo " "set_option " n:ident ppSpace val:term : command => do
  let options ← setOption n val (← getOptions)
  modify fun s ↦ { s with maxRecDepth := maxRecDepth.get options }
  modifyScope fun scope ↦ { scope with opts := options }
goal: Lean.Elab.Command.CommandElab

full_name: commandSudoSet_option___
code: /--
The command `sudo set_option name val` is similar to `set_option name val`,
but it also allows to set undeclared options.
-/
elab "sudo " "set_option " n:ident ppSpace val:term : command => do
  let options ← setOption n val (← getOptions)
  modify fun s ↦ { s with maxRecDepth := maxRecDepth.get options }
  modifyScope fun scope ↦ { scope with opts := options }
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_SudoSetOption___elabRules_termSudoSet_option___In__1
code: /--
The command `sudo set_option name val in term` is similar to `set_option name val in term`,
but it also allows to set undeclared options.
-/
elab "sudo " "set_option " n:ident ppSpace val:term " in " body:term : term <= expectedType => do
  let options ← setOption n val (← getOptions)
  withTheReader Core.Context (fun ctx ↦
      { ctx with maxRecDepth := maxRecDepth.get options, options := options }) do
    elabTerm body expectedType
goal: Lean.Elab.Term.TermElab

full_name: termSudoSet_option___In_
code: /--
The command `sudo set_option name val in term` is similar to `set_option name val in term`,
but it also allows to set undeclared options.
-/
elab "sudo " "set_option " n:ident ppSpace val:term " in " body:term : term <= expectedType => do
  let options ← setOption n val (← getOptions)
  withTheReader Core.Context (fun ctx ↦
      { ctx with maxRecDepth := maxRecDepth.get options, options := options }) do
    elabTerm body expectedType
goal: Lean.ParserDescr
File: Mathlib/Tactic/UnsetOption.lean

full_name: Lean.Elab.elabUnsetOption.unsetOption
code: /-- unset the option specified by id -/
def elabUnsetOption (id : Syntax) : m Options 
goal: m Lean.Options

full_name: Lean.Elab.elabUnsetOption
code: /-- unset the option specified by id -/
def elabUnsetOption (id : Syntax) : m Options 
goal: m Lean.Options

full_name: Lean.Elab.Command._aux_Mathlib_Tactic_UnsetOption___elabRules_Lean_Elab_Command_unsetOption_1
code: /-- Unset a user option -/
elab (name := unsetOption) "unset_option " opt:ident : command => do
  let options ← Elab.elabUnsetOption opt
  modify fun s ↦ { s with maxRecDepth := maxRecDepth.get options }
  modifyScope fun scope ↦ { scope with opts := options }
goal: Lean.Elab.Command.CommandElab

full_name: Lean.Elab.Command.unsetOption
code: /-- Unset a user option -/
elab (name := unsetOption) "unset_option " opt:ident : command => do
  let options ← Elab.elabUnsetOption opt
  modify fun s ↦ { s with maxRecDepth := maxRecDepth.get options }
  modifyScope fun scope ↦ { scope with opts := options }
goal: Lean.ParserDescr
File: Mathlib/Tactic/Nontriviality/Core.lean

full_name: Mathlib.Tactic.Nontriviality.subsingleton_or_nontrivial_elim
code: theorem subsingleton_or_nontrivial_elim {p : Prop} {α : Type u}
    (h₁ : Subsingleton α → p) (h₂ : Nontrivial α → p) : p 
goal: p

full_name: Mathlib.Tactic.Nontriviality.nontrivialityByElim
code: /--
Tries to generate a `Nontrivial α` instance by performing case analysis on
`subsingleton_or_nontrivial α`,
attempting to discharge the subsingleton branch using lemmas with `@[nontriviality]` attribute,
including `Subsingleton.le` and `eq_iff_true_of_subsingleton`.
-/
def nontrivialityByElim {u : Level} (α : Q(Type u)) (g : MVarId) (simpArgs : Array Syntax) :
    MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Mathlib.Tactic.Nontriviality.nontrivialityByAssumption
code: /--
Tries to generate a `Nontrivial α` instance using `nontrivial_of_ne` or `nontrivial_of_lt`
and local hypotheses.
-/
def nontrivialityByAssumption (g : MVarId) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Mathlib.Tactic.Nontriviality.nontriviality
code: /-- Attempts to generate a `Nontrivial α` hypothesis.

The tactic first checks to see that there is not already a `Nontrivial α` instance
before trying to synthesize one using other techniques.

If the goal is an (in)equality, the type `α` is inferred from the goal.
Otherwise, the type needs to be specified in the tactic invocation, as `nontriviality α`.

The `nontriviality` tactic will first look for strict inequalities amongst the hypotheses,
and use these to derive the `Nontrivial` instance directly.

Otherwise, it will perform a case split on `Subsingleton α ∨ Nontrivial α`, and attempt to discharge
the `Subsingleton` goal using `simp [h₁, h₂, ..., hₙ, nontriviality]`, where `[h₁, h₂, ..., hₙ]` is
a list of additional `simp` lemmas that can be passed to `nontriviality` using the syntax
`nontriviality α using h₁, h₂, ..., hₙ`.

```
example {R : Type} [OrderedRing R] {a : R} (h : 0 < a) : 0 < a := by
  nontriviality -- There is now a `Nontrivial R` hypothesis available.
  assumption
```

```
example {R : Type} [CommRing R] {r s : R} : r * s = s * r := by
  nontriviality -- There is now a `Nontrivial R` hypothesis available.
  apply mul_comm
```

```
example {R : Type} [OrderedRing R] {a : R} (h : 0 < a) : (2 : ℕ) ∣ 4 := by
  nontriviality R -- there is now a `Nontrivial R` hypothesis available.
  dec_trivial
```

```
def myeq {α : Type} (a b : α) : Prop := a = b

example {α : Type} (a b : α) (h : a = b) : myeq a b := by
  success_if_fail nontriviality α -- Fails
  nontriviality α using myeq -- There is now a `Nontrivial α` hypothesis available
  assumption
```
-/
syntax (name := nontriviality) "nontriviality" (ppSpace colGt term)?
  (" using " Parser.Tactic.simpArg,+)? : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.Nontriviality.elabNontriviality
code: /-- Elaborator for the `nontriviality` tactic. -/
@[tactic nontriviality] def elabNontriviality : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/SuccessIfFailWithMsg.lean

full_name: Mathlib.Tactic.successIfFailWithMsg
code: /-- `success_if_fail_with_msg msg tacs` runs `tacs` and succeeds only if they fail with the message
`msg`.

`msg` can be any term that evaluates to an explicit `String`. -/
syntax (name := successIfFailWithMsg) "success_if_fail_with_msg " term:max tacticSeq : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.successIfFailWithMessage
code: /-- Evaluates `tacs` and succeeds only if `tacs` both fails and throws an error equal (as a string)
to `msg`. -/
def successIfFailWithMessage {s α : Type} {m : Type → Type}
    [Monad m] [MonadLiftT IO m] [MonadBacktrack s m] [MonadError m]
    (msg : String) (tacs : m α) (ref : Option Syntax := none) : m Unit 
goal: m Unit

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_SuccessIfFailWithMsg___elabRules_Mathlib_Tactic_successIfFailWithMsg_1
code: elab_rules : tactic
| `(tactic| success_if_fail_with_msg $msg:term $tacs:tacticSeq) =>
  Term.withoutErrToSorry <| withoutRecover do
    let msg ← unsafe Term.evalTerm String (.const ``String []) msg
    successIfFailWithMessage msg (evalTacticSeq tacs) tacs
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/DeriveFintype.lean

full_name: Mathlib.Deriving.Fintype.«_aux_Mathlib_Tactic_DeriveFintype___macroRules_Mathlib_Deriving_Fintype_termDerive_fintype%__1»
code: macro "derive_fintype% " t:term : term => `(term| Fintype.ofEquiv _ (proxy_equiv% $t))
goal: Lean.Macro

full_name: Mathlib.Deriving.Fintype.«termDerive_fintype%_»
code: macro "derive_fintype% " t:term : term => `(term| Fintype.ofEquiv _ (proxy_equiv% $t))
goal: Lean.ParserDescr

full_name: Mathlib.Deriving.Fintype.mkFintype
code: def mkFintype (declName : Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Mathlib.Deriving.Fintype.mkFintypeEnum
code: /-- Derive a `Fintype` instance for enum types. These come with a `toCtorIdx` function.

We generate a more optimized instance than the one produced by `mkFintype`.
The strategy is to (1) create a list `enumList` of all the constructors, (2) prove that this
is in `toCtorIdx` order, (3) show that `toCtorIdx` maps `enumList` to `List.range numCtors` to show
the list has no duplicates, and (4) give the `Fintype` instance, using 2 for completeness.

The proofs are all linear complexity, and the main computation is that
`enumList.map toCtorIdx = List.range numCtors`, which is true by `refl`. -/
def mkFintypeEnum (declName : Name) : CommandElabM Unit 
goal: Lean.Elab.Command.CommandElabM Unit

full_name: Mathlib.Deriving.Fintype.mkFintypeInstanceHandler
code: def mkFintypeInstanceHandler (declNames : Array Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Mathlib.Deriving.Fintype.initFn._@.Mathlib.Tactic.DeriveFintype._hyg.2814
code: initialize
  registerDerivingHandler `Fintype mkFintypeInstanceHandler
  registerTraceClass `Elab.Deriving.fintype
goal: IO Unit
File: Mathlib/Tactic/Measurability.lean

full_name: _aux_Mathlib_Tactic_Measurability___macroRules_attrMeasurability_1
code: macro "measurability" : attr =>
  `(attr|aesop safe apply (rule_sets := [$(Lean.mkIdent `Measurable):ident]))
goal: Lean.Macro

full_name: attrMeasurability
code: macro "measurability" : attr =>
  `(attr|aesop safe apply (rule_sets := [$(Lean.mkIdent `Measurable):ident]))
goal: Lean.ParserDescr

full_name: tacticMeasurability_
code: macro "measurability" (config)? : tactic =>
  `(tactic| aesop (config := { terminal := true })
    (rule_sets := [$(Lean.mkIdent `Measurable):ident]))
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_Measurability___macroRules_tacticMeasurability__1
code: macro "measurability" (config)? : tactic =>
  `(tactic| aesop (config := { terminal := true })
    (rule_sets := [$(Lean.mkIdent `Measurable):ident]))
goal: Lean.Macro

full_name: tacticMeasurability?_
code: macro "measurability?" (config)? : tactic =>
  `(tactic| aesop? (config := { terminal := true })
    (rule_sets := [$(Lean.mkIdent `Measurable):ident]))
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_Measurability___macroRules_tacticMeasurability?__1
code: macro "measurability?" (config)? : tactic =>
  `(tactic| aesop? (config := { terminal := true })
    (rule_sets := [$(Lean.mkIdent `Measurable):ident]))
goal: Lean.Macro

full_name: measurability!
code: syntax (name := measurability!) "measurability!" (config)? : tactic
goal: Lean.ParserDescr

full_name: measurability!?
code: syntax (name := measurability!?) "measurability!?" (config)? : tactic
goal: Lean.ParserDescr
File: Mathlib/Tactic/FinCases.lean

full_name: Lean.Elab.Tactic.getMemType
code: /-- If `e` is of the form `x ∈ (A : List α)`, `x ∈ (A : Finset α)`, or `x ∈ (A : Multiset α)`,
return `some α`, otherwise `none`. -/
def getMemType {m : Type → Type} [Monad m] [MonadError m] (e : Expr) : m (Option Expr) 
goal: m (Option Lean.Expr)

full_name: Lean.Elab.Tactic.unfoldCases
code: /--
Recursively runs the `cases` tactic on a hypothesis `h`.
As long as two goals are produced, `cases` is called recursively on the second goal,
and we return a list of the first goals which appeared.

This is useful for hypotheses of the form `h : a ∈ [l₁, l₂, ...]`,
which will be transformed into a sequence of goals with hypotheses `h : a = l₁`, `h : a = l₂`,
and so on.
-/
partial def unfoldCases (g : MVarId) (h : FVarId) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.Elab.Tactic.finCasesAt
code: /-- Implementation of the `fin_cases` tactic. -/
partial def finCasesAt (g : MVarId) (hyp : FVarId) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.Elab.Tactic.finCases
code: /--
`fin_cases h` performs case analysis on a hypothesis of the form
`h : A`, where `[Fintype A]` is available, or
`h : a ∈ A`, where `A : Finset X`, `A : Multiset X` or `A : List X`.

As an example, in
```
example (f : ℕ → Prop) (p : Fin 3) (h0 : f 0) (h1 : f 1) (h2 : f 2) : f p.val := by
  fin_cases p; simp
  all_goals assumption
```
after `fin_cases p; simp`, there are three goals, `f 0`, `f 1`, and `f 2`.
-/
syntax (name := finCases) "fin_cases " ("*" <|> term,+) (" with " term,+)? : tactic
goal: Lean.ParserDescr

full_name: Lean.Elab.Tactic._aux_Mathlib_Tactic_FinCases___elabRules_Lean_Elab_Tactic_finCases_1
code: @[tactic finCases] elab_rules : tactic
  | `(tactic| fin_cases $[$hyps:ident],*) => withMainContext <| focus do
    for h in hyps do
      allGoals <| liftMetaTactic (finCasesAt · (← getFVarId h))
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/Linarith/Lemmas.lean

full_name: Linarith.lt_irrefl
code: theorem lt_irrefl {α : Type u} [Preorder α] {a : α} : ¬a < a 
goal: ¬a < a

full_name: Linarith.eq_of_eq_of_eq
code: theorem eq_of_eq_of_eq {α} [OrderedSemiring α] {a b : α} (ha : a = 0) (hb : b = 0) : a + b = 0 
goal: a + b = 0

full_name: Linarith.le_of_eq_of_le
code: theorem le_of_eq_of_le {α} [OrderedSemiring α] {a b : α} (ha : a = 0) (hb : b ≤ 0) : a + b ≤ 0 
goal: a + b ≤ 0

full_name: Linarith.lt_of_eq_of_lt
code: theorem lt_of_eq_of_lt {α} [OrderedSemiring α] {a b : α} (ha : a = 0) (hb : b < 0) : a + b < 0 
goal: a + b < 0

full_name: Linarith.le_of_le_of_eq
code: theorem le_of_le_of_eq {α} [OrderedSemiring α] {a b : α} (ha : a ≤ 0) (hb : b = 0) : a + b ≤ 0 
goal: a + b ≤ 0

full_name: Linarith.lt_of_lt_of_eq
code: theorem lt_of_lt_of_eq {α} [OrderedSemiring α] {a b : α} (ha : a < 0) (hb : b = 0) : a + b < 0 
goal: a + b < 0

full_name: Linarith.mul_neg
code: theorem mul_neg {α} [StrictOrderedRing α] {a b : α} (ha : a < 0) (hb : 0 < b) : b * a < 0 
goal: b * a < 0

full_name: Linarith.mul_nonpos
code: theorem mul_nonpos {α} [OrderedRing α] {a b : α} (ha : a ≤ 0) (hb : 0 < b) : b * a ≤ 0 
goal: b * a ≤ 0

full_name: Linarith.mul_eq
code: @[nolint unusedArguments]
theorem mul_eq {α} [OrderedSemiring α] {a b : α} (ha : a = 0) (_ : 0 < b) : b * a = 0 
goal: 0 < b → b * a = 0

full_name: Linarith.eq_of_not_lt_of_not_gt
code: lemma eq_of_not_lt_of_not_gt {α} [LinearOrder α] (a b : α) (h1 : ¬ a < b) (h2 : ¬ b < a) : a = b 
goal: a = b

full_name: Linarith.mul_zero_eq
code: @[nolint unusedArguments]
lemma mul_zero_eq {α} {R : α → α → Prop} [Semiring α] {a b : α} (_ : R a 0) (h : b = 0) :
    a * b = 0 
goal: R a 0 → b = 0 → a * b = 0

full_name: Linarith.zero_mul_eq
code: @[nolint unusedArguments]
lemma zero_mul_eq {α} {R : α → α → Prop} [Semiring α] {a b : α} (h : a = 0) (_ : R b 0) :
    a * b = 0 
goal: R b 0 → a * b = 0

full_name: Linarith.natCast_nonneg
code: lemma natCast_nonneg (α : Type u) [OrderedSemiring α] (n : ℕ) : (0 : α) ≤ n 
goal: 0 ≤ ↑n

full_name: lt_zero_of_zero_gt
code: theorem lt_zero_of_zero_gt {α : Type*} [Zero α] [LT α] {a : α} (h : 0 > a) : a < 0 
goal: a < 0

full_name: le_zero_of_zero_ge
code: theorem le_zero_of_zero_ge {α : Type*} [Zero α] [LE α] {a : α} (h : 0 ≥ a) : a ≤ 0 
goal: a ≤ 0
File: Mathlib/Tactic/Linarith/Oracle/SimplexAlgorithm/PositiveVector.lean

full_name: Linarith.SimplexAlgorithm.stateLP
code: /--
Given matrix `A` and list `strictIndexes` of strict inequalities' indexes, we want to state the
Linear Programming problem which solution would give us a solution for the initial problem (see
`findPositiveVector`).

As an objective function (that we are trying to maximize) we use sum of coordinates from
`strictIndexes`: it suffices to find the nonnegative vector that makes this function positive.

We introduce two auxiliary variables and one constraint:
* The variable `y` is interpreted as "homogenized" `1`. We need it because dealing with a
  homogenized problem is easier, but having some "unit" is necessary.
* To bound the problem we add the constraint `x₁ + ... + xₘ + z = y` introducing new variable `z`.

The objective function also interpreted as an auxiliary variable with constraint
`f = ∑ i ∈ strictIndexes, xᵢ`.

The variable `f` has to always be basic while `y` has to be free. Our Gauss method implementation
greedy collects basic variables moving from left to right. So we place `f` before `x`-s and `y`
after them. We place `z` between `f` and `x` because in this case `z` will be basic and
`Gauss.getTableau` produce tableau with nonnegative last column, meaning that we are starting from
a feasible point.
-/
def stateLP {n m : Nat} (A : matType n m) (strictIndexes : List Nat) : matType (n + 2) (m + 3) 
goal: matType (n + 2) (m + 3)

full_name: Linarith.SimplexAlgorithm.extractSolution
code: /-- Extracts target vector from the tableau, putting auxilary variables aside (see `stateLP`). -/
def extractSolution (tableau : Tableau matType) : Array Rat 
goal: Array Rat

full_name: Linarith.SimplexAlgorithm.findPositiveVector
code: /--
Finds a nonnegative vector `v`, such that `A v = 0` and some of its coordinates from
`strictCoords`
are positive, in the case such `v` exists. If not, throws the error. The latter prevents
`linarith` from doing useless post-processing.
-/
def findPositiveVector {n m : Nat} {matType : Nat → Nat → Type} [UsableInSimplexAlgorithm matType]
    (A : matType n m) (strictIndexes : List Nat) : Lean.Meta.MetaM <| Array Rat 
goal: Lean.MetaM (Array Rat)
File: Mathlib/Tactic/Linarith/Oracle/SimplexAlgorithm/Gauss.lean

full_name: Linarith.SimplexAlgorithm.Gauss.GaussM
code: /-- The monad for the Gaussian Elimination algorithm. -/
abbrev GaussM (n m : Nat) (matType : Nat → Nat → Type) 
goal: Type

full_name: Linarith.SimplexAlgorithm.Gauss.findNonzeroRow
code: /-- Finds the first row starting from the `rowStart` with nonzero element in the column `col`. -/
def findNonzeroRow (rowStart col : Nat) : GaussM n m matType <| Option Nat 
goal: Linarith.SimplexAlgorithm.Gauss.GaussM n m matType (Option Nat)

full_name: Linarith.SimplexAlgorithm.Gauss.getTableauImp
code: /-- Implementation of `getTableau` in `GaussM` monad. -/
def getTableauImp : GaussM n m matType <| Tableau matType 
goal: Linarith.SimplexAlgorithm.Gauss.GaussM n m matType (Linarith.SimplexAlgorithm.Tableau matType)

full_name: Linarith.SimplexAlgorithm.Gauss.getTableau
code: /--
Given matrix `A`, solves the linear equation `A x = 0` and returns the solution as a tableau where
some variables are free and others (basic) variable are expressed as linear combinations of the free
ones.
-/
def getTableau (A : matType n m) : Tableau matType 
goal: Linarith.SimplexAlgorithm.Tableau matType