name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.217797861._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO
(Lean.PersistentEnvExtension Lean.Name (Lean.Name × Lean.Linter.IgnoreFunction)
(List Lean.Name × Array Lean.Linter.IgnoreFunction)) | null | false |
Sublocale | Mathlib.Order.Sublocale | (X : Type u_2) → [Order.Frame X] → Type u_2 | A sublocale of a locale `X` is a set `S` which is closed under all meets and such that
`x ⇨ s ∈ S` for all `x : X` and `s ∈ S`.
Note that locales are the same thing as frames, but with reverse morphisms, which is why we assume
`Frame X`. We only need to define locales categorically. See `Locale`. | true |
FintypeCat.toLightProfiniteFullyFaithful._proof_1 | Mathlib.Topology.Category.LightProfinite.Basic | ∀ {X Y : FintypeCat} (x : FintypeCat.toLightProfinite.obj X ⟶ FintypeCat.toLightProfinite.obj Y),
FintypeCat.toLightProfinite.map (CategoryTheory.InducedCategory.homMk (TypeCat.ofHom (TopCat.Hom.hom x.hom).toFun)) =
FintypeCat.toLightProfinite.map (CategoryTheory.InducedCategory.homMk (TypeCat.ofHom (TopCat.Hom.h... | null | false |
Bornology.isVonNBounded_empty._simp_1 | Mathlib.Analysis.LocallyConvex.Bounded | ∀ (𝕜 : Type u_1) (E : Type u_3) [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : Zero E]
[inst_3 : TopologicalSpace E], Bornology.IsVonNBounded 𝕜 ∅ = True | null | false |
CategoryTheory.Sheaf.terminal_obj | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] {X : A} (hX : CategoryTheory.Limits.IsTerminal X),
(CategoryTheory.Sheaf.terminal J hX).obj = (CategoryTheory.Functor.const Cᵒᵖ).obj X | null | true |
MonoidWithZeroHom.toZeroHom_coe | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_2} {β : Type u_3} [inst : MulZeroOneClass α] [inst_1 : MulZeroOneClass β] (f : α →*₀ β), ⇑↑f = ⇑f | null | true |
CategoryTheory.Limits.isoOfπ._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} (s : CategoryTheory.Limits.Cofork f 0) (j : CategoryTheory.Limits.WalkingParallelPair),
CategoryTheory.CategoryStruct.comp (s.ι.app j) (CategoryTheory.Iso.refl s.pt).hom =
(Ca... | null | false |
WithVal.strictMono_valueGroupEquiv | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {R : Type u_3} [inst_1 : Ring R] (v : Valuation R Γ₀),
StrictMono ⇑(WithVal.valueGroupEquiv v) | null | true |
FixedPoints.instSMulCommClassSubtypeMemSubgroupSubgroup | Mathlib.GroupTheory.GroupAction.Defs | ∀ (M : Type u) (α : Type v) [inst : Monoid M] [inst_1 : Group α] [inst_2 : MulDistribMulAction M α],
SMulCommClass M (↥(FixedPoints.subgroup M α)) α | null | true |
Polynomial.add_comp | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] {p q r : Polynomial R}, (p + q).comp r = p.comp r + q.comp r | null | true |
_private.Batteries.Data.List.Interleave.0.List.interleave_flatten_flatten_of_length_eq_length._proof_3 | Batteries.Data.List.Interleave | ∀ {α : Type u_1} {L₁ L₂ : List (List α)}, L₁.length = L₂.length → ∀ (i : ℕ), i + 1 < L₁.length → ¬i < L₂.length → False | null | false |
instIsGaloisGroupRingOfIntegersOfNumberField | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [NumberField K] [NumberField L]
[inst_4 : Algebra K L] (G : Type u_3) [inst_5 : Group G] [inst_6 : MulSemiringAction G L] [IsGaloisGroup G K L],
IsGaloisGroup G (NumberField.RingOfIntegers K) (NumberField.RingOfIntegers L) | null | true |
Lean.Elab.DeprecatedArgEntry.text?._default | Lean.Elab.DeprecatedArg | Option String | null | false |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizeNonParametricLiteral | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → ℕ → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit | Internalizer for nonparametric literals (see `isNonParametricLitValue`).
For this kind of literal, we do **not** internalize its children nor
we activate theorems associated with their function symbol.
This is relevant because we do not want to internalize, for example,
the raw natural value in `OfNat.ofNat`. We also d... | true |
LowerSemicontinuous | Mathlib.Topology.Semicontinuity.Defs | {α : Type u_1} → {β : Type u_2} → [TopologicalSpace α] → [Preorder β] → (α → β) → Prop | A real function `f` is lower semicontinuous if, for any `ε > 0`, for any `x`, for all `x'` close
enough to `x`, then `f x'` is at least `f x - ε`. We formulate this in a general preordered space,
using an arbitrary `y < f x` instead of `f x - ε`. | true |
Nat.Partrec.Code.pappAck.eq_1 | Mathlib.Computability.Ackermann | Nat.Partrec.Code.pappAck 0 = Nat.Partrec.Code.succ | null | true |
Int.modEq_sub_modulus_mul_iff._simp_1 | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, (a ≡ b - n * c [ZMOD n]) = (a ≡ b [ZMOD n]) | null | false |
Lean.Lsp.CompletionParams.mk | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.TextDocumentPositionParams → Lean.Lsp.CompletionParams | null | true |
LinearOrderedAddCommGroup.closure_equiv_closure | Mathlib.GroupTheory.ArchimedeanDensely | {G : Type u_1} →
{G' : Type u_2} →
[inst : AddCommGroup G] →
[inst_1 : LinearOrder G] →
[IsOrderedAddMonoid G] →
[inst_3 : AddCommGroup G'] →
[inst_4 : LinearOrder G'] →
[IsOrderedAddMonoid G'] →
(x : G) → (y : G') → (x = 0 ↔ y = 0) → ↥(AddSubgroup... | **Alias** of `LinearOrderedAddCommGroup.zmultiplesOrderAddMonoidIso`.
---
In two linearly ordered additive groups, the closure of an element of one group
is isomorphic (and order-isomorphic) to the closure of an element in the other group. | true |
CategoryTheory.LocalizerMorphism.RightResolution.unop_X₁ | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂ᵒᵖ}
(L : Φ.op.RightResolution X₂), L.unop.X₁ = ... | null | true |
Lean.RArray.get_ofFn | Lean.Data.RArray | ∀ {α : Type u_1} {n : ℕ} (f : Fin n → α) (h : 0 < n) (i : Fin n), (Lean.RArray.ofFn f h).get ↑i = f i | The correctness theorem for `ofFn` | true |
CategoryTheory.ComposableArrows.Mk₁.obj.eq_2 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} (X₀ X₁ : C) (isLt : 1 < 2), CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ ⟨1, isLt⟩ = X₁ | null | true |
_private.Batteries.Data.List.Perm.0.List.Perm.idxBij_leftInverse_idxBij_symm._proof_1_6 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs ys : List α},
xs.Perm ys → ∀ (w : Fin ys.length), List.idxOfNth ys[w] xs (List.countBefore ys[w] ys ↑w) < xs.length | null | false |
Sublattice.instInfSet._proof_2 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (S : Set (Sublattice α)), InfClosed (⋂₀ Set.range fun L => ⨅ (_ : L ∈ S), ↑L) | null | false |
sSupHomClass.rec | Mathlib.Order.Hom.CompleteLattice | {F : Type u_8} →
{α : Type u_9} →
{β : Type u_10} →
[inst : SupSet α] →
[inst_1 : SupSet β] →
[inst_2 : FunLike F α β] →
{motive : sSupHomClass F α β → Sort u} →
((map_sSup : ∀ (f : F) (s : Set α), f (sSup s) = sSup (⇑f '' s)) → motive ⋯) →
(t : sS... | null | false |
PiLp.instPseudoEMetricSpace | Mathlib.Analysis.Normed.Lp.PiLp | (p : ENNReal) →
{ι : Type u_2} →
(β : ι → Type u_4) →
[hp : Fact (1 ≤ p)] → [Fintype ι] → [(i : ι) → PseudoEMetricSpace (β i)] → PseudoEMetricSpace (PiLp p β) | pseudoemetric space instance on the product of finitely many pseudoemetric spaces, using the
`L^p` pseudoedistance, and having as uniformity the product uniformity. | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.doubling_lt_golden_ratio._simp_1_27 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Function.minimalPeriod_eq_sInf_n_pos_IsPeriodicPt | Mathlib.Dynamics.PeriodicPts.Lemmas | ∀ {α : Type u_1} {f : α → α} {x : α}, Function.minimalPeriod f x = sInf {n | n > 0 ∧ Function.IsPeriodicPt f n x} | null | true |
Homeomorph.contDiff_symm | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
[CompleteSpace E] (f : E ≃ₜ F) {f₀' : E → E ≃L[𝕜] F},
(∀ (a : E), HasFDerivAt (⇑f) (↑(f₀' a)) ... | If `f` is an `n` times continuously differentiable homeomorphism,
and if the derivative of `f` at each point is a continuous linear equivalence,
then `f.symm` is `n` times continuously differentiable.
This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function. | true |
AlgebraicGeometry.Scheme.affineBasisCover.eq_1 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ (X : AlgebraicGeometry.Scheme),
X.affineBasisCover =
CategoryTheory.Precoverage.ZeroHypercover.bind X.affineCover fun x =>
AlgebraicGeometry.Scheme.affineBasisCoverOfAffine ((fun x => Classical.choose ⋯) x) | null | true |
FreeMagma.rec.eq._@.Mathlib.Algebra.Free.2492573129._hygCtx._hyg.4 | Mathlib.Algebra.Free | @FreeMagma.rec = @FreeMagma.rec✝ | null | false |
MagmaCat.mulEquiv_coe_eq | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y : Type u_1} [inst : Mul X] [inst_1 : Mul Y] (e : X ≃* Y), MagmaCat.Hom.hom (MagmaCat.ofHom ↑e) = ↑e | null | true |
Bifunctor.casesOn | Mathlib.Control.Bifunctor | {F : Type u₀ → Type u₁ → Type u₂} →
{motive : Bifunctor F → Sort u} →
(t : Bifunctor F) →
((bimap : {α α' : Type u₀} → {β β' : Type u₁} → (α → α') → (β → β') → F α β → F α' β') →
motive { bimap := bimap }) →
motive t | null | false |
_private.Lean.Meta.Sym.Canon.0.Lean.Meta.Sym.Canon.Context.mk | Lean.Meta.Sym.Canon | Bool → Lean.Meta.Sym.Canon.Context✝ | null | true |
Lean.Lsp.instToJsonParameterInformationLabel.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.ParameterInformationLabel → Sort u_1) →
(x : Lean.Lsp.ParameterInformationLabel) →
((name : String) → motive (Lean.Lsp.ParameterInformationLabel.name name)) →
((startUtf16Offset endUtf16Offset : ℕ) →
motive (Lean.Lsp.ParameterInformationLabel.range startUtf16Offset endUtf16Offse... | null | false |
SimpleGraph.ConnectedComponent.isoEquivSupp._proof_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u_2} {V' : Type u_1} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G ≃g G') (C : G.ConnectedComponent)
(v : ↑C.supp),
G'.connectedComponentMk (φ ↑v) = SimpleGraph.ConnectedComponent.map (RelIso.toRelEmbedding φ).toRelHom C | null | false |
Homeomorph.div_def | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} [inst : TopologicalSpace X] (a b : X ≃ₜ X), a / b = DivInvMonoid.div' a b | null | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabAppImplicitCore._sparseCasesOn_9 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.PrettyPrinter.Delaborator.AppImplicitArg → Sort u} →
(t : Lean.PrettyPrinter.Delaborator.AppImplicitArg) →
motive Lean.PrettyPrinter.Delaborator.AppImplicitArg.skip → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Polynomial.irreducible_of_degree_eq_one | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Field R] {p : Polynomial R}, p.degree = 1 → Irreducible p | null | true |
_private.Mathlib.Tactic.Linter.Whitespace.0.Mathlib.Linter.FormatError.ctorIdx | Mathlib.Tactic.Linter.Whitespace | Mathlib.Linter.FormatError✝ → ℕ | null | false |
Vector.back_append_of_neZero | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {xs : Vector α n} {ys : Vector α m} [inst : NeZero m], (xs ++ ys).back = ys.back | null | true |
Lean.Doc.Parser.InlineCtxt.boldDepth._default | Lean.DocString.Parser | Option ℕ | null | false |
Lean.Kernel.resetDiag | Lean.Environment | Lean.Environment → Lean.Environment | null | true |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.takeWhile.eq_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {ρ : Type} (s : String.Slice) (pat : ρ) [inst : String.Slice.Pattern.ForwardPattern pat],
s.takeWhile pat = s.sliceTo (s.skipPrefixWhile pat) | null | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image_aux1._simp_1_2 | Mathlib.MeasureTheory.Function.Jacobian | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
_private.Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain.0.HasStrictFDerivAt.implicitFunctionDataOfProdDomain.match_3 | Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E₁ : Type u_4} [inst_1 : NormedAddCommGroup E₁]
[inst_2 : NormedSpace 𝕜 E₁] {E₂ : Type u_1} [inst_3 : NormedAddCommGroup E₂] [inst_4 : NormedSpace 𝕜 E₂]
{F : Type u_2} [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {f'u : E₁ × E₂ →L[𝕜] F} (v : E... | null | false |
instTrichotomousLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : LinearOrder α], Std.Trichotomous fun x1 x2 => x1 ≤ x2 | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.opcyclesMap_opcyclesIso_hom._proof_8 | Mathlib.Algebra.Homology.SpectralObject.Page | ¬2 ≤ 3 → False | null | false |
SubMulAction.instNegSubtypeMem._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : SubMulAction R M)
(x : ↥p), -↑x ∈ p | null | false |
Ordnode.findGeAux._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → α → α | null | false |
Matrix.posDef_iff_posSemidef_and_mulVec_injective | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} {R' : Type u_4} [inst : CommRing R'] [inst_1 : PartialOrder R'] [inst_2 : StarRing R']
[inst_3 : Fintype n] [StarOrderedRing R'] [IsProperStar R'] {A : Matrix n n R'},
A.PosDef ↔ A.PosSemidef ∧ Function.Injective A.mulVec | null | true |
Array.foldlM.loop._sunfold | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} →
{m : Type v → Type w} → [Monad m] → (β → α → m β) → (as : Array α) → (stop : ℕ) → stop ≤ as.size → ℕ → ℕ → β → m β | null | false |
lt_inv_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (a < b⁻¹ ↔ b < a⁻¹) | null | true |
Lean.Compiler.LCNF.Code.isFVarLiveIn | Lean.Compiler.LCNF.LiveVars | Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure → Lean.FVarId → Lean.Compiler.LCNF.CompilerM Bool | Determine whether `fvarId` is live in `c`. Assumes that `c` and all of its transitively reachable
join-points are internalized.
| true |
Nat.le.brecOn | Init.Prelude | ∀ {n : ℕ} {motive : (a : ℕ) → n.le a → Prop} {a : ℕ} (t : n.le a),
(∀ (a : ℕ) (t : n.le a), Nat.le.below t → motive a t) → motive a t | null | true |
MeasureTheory.Filtration.cylinderEventsCompl._proof_1 | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_2} {m : MeasurableSpace Ω} {α : Type u_1} (x x_1 : (Finset α)ᵒᵈ),
x ≤ x_1 →
MeasureTheory.cylinderEvents (↑(OrderDual.ofDual x))ᶜ ≤ MeasureTheory.cylinderEvents (↑(OrderDual.ofDual x_1))ᶜ | null | false |
_private.Init.Data.AC.0.Lean.Data.AC.insert.match_1.splitter | Init.Data.AC | (motive : List ℕ → Sort u_1) →
(x : List ℕ) → (Unit → motive []) → ((a : ℕ) → (as : List ℕ) → motive (a :: as)) → motive x | null | true |
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {motive : Mathlib.Tactic.BicategoryLike.NormalExpr → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.NormalExpr) →
((t : Mathlib.Tactic.BicategoryLike.NormalExpr) → Mathlib.Tactic.BicategoryLike.NormalExpr.below t → motive t) →
motive t | null | false |
_private.Init.Data.List.Nat.TakeDrop.0.List.take_append._proof_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} (tail : List α) (n : ℕ), ¬n - tail.length = n + 1 - (tail.length + 1) → False | null | false |
le_iff_le_of_cmp_eq_cmp | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α} {β : Type u_3} [inst_1 : LinearOrder β] {x' y' : β},
cmp x y = cmp x' y' → (x ≤ y ↔ x' ≤ y') | null | true |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Equiv.ext.match_1_7 | Mathlib.SetTheory.ZFC.PSet | ∀ («Type» : Type u_1) (Func : «Type» → PSet.{u_1}) (Type_1 : Type u_1) (Func_1 : Type_1 → PSet.{u_1})
(motive :
{ «Type» := «Type», Func := Func } ⊆ { «Type» := Type_1, Func := Func_1 } ∧
{ «Type» := Type_1, Func := Func_1 } ⊆ { «Type» := «Type», Func := Func } →
Prop)
(x :
{ «Type» := «Type»,... | null | false |
QPF.Cofix.bisim' | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type u} [q : QPF F] {α : Type u_1} (Q : α → Prop) (u v : α → QPF.Cofix F),
(∀ (x : α),
Q x →
∃ a f f',
(u x).dest = QPF.abs ⟨a, f⟩ ∧
(v x).dest = QPF.abs (PFunctor.Obj.mk a f') ∧
∀ (i : (QPF.P F).B a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x') →
∀ (x ... | null | true |
String.Slice.Pattern.Model.Char.isRevMatch_iff._proof_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {s : String.Slice} (h : s.endPos ≠ s.startPos), s.endPos.prev h ≠ s.endPos | null | false |
CStarAlgebra.isMulCommutative_nonUnital_adjoin_pair._auto_1 | Mathlib.Analysis.CStarAlgebra.Fuglede | Lean.Syntax | null | false |
Lean.Elab.Tactic.Omega.Context.cfg | Lean.Elab.Tactic.Omega.OmegaM | Lean.Elab.Tactic.Omega.Context → Lean.Meta.Omega.OmegaConfig | User configurable options for `omega`. | true |
Monoid.CoprodI.NeWord.toList | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
{M : ι → Type u_2} → [inst : (i : ι) → Monoid (M i)] → {i j : ι} → Monoid.CoprodI.NeWord M i j → List ((i : ι) × M i) | The list represented by a given `NeWord` | true |
List.prefix_or_prefix_of_prefix | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₃ l₂ : List α}, l₁ <+: l₃ → l₂ <+: l₃ → l₁ <+: l₂ ∨ l₂ <+: l₁ | null | true |
MonoidWithZeroHom.mk._flat_ctor | Mathlib.Algebra.GroupWithZero.Hom | {α : Type u_7} →
{β : Type u_8} →
[inst : MulZeroOneClass α] →
[inst_1 : MulZeroOneClass β] →
(toFun : α → β) → toFun 0 = 0 → toFun 1 = 1 → (∀ (x y : α), toFun (x * y) = toFun x * toFun y) → α →*₀ β | null | false |
SimpleGraph.Walk.isInduced_toSubgraph | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {w : G.Walk u v}, w.toSubgraph.IsInduced ↔ w.IsChordless | null | true |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.S.brecOn | Mathlib.Tactic.DeriveEncodable | {motive : Mathlib.Deriving.Encodable.S✝ → Sort u} →
(t : Mathlib.Deriving.Encodable.S✝) →
((t : Mathlib.Deriving.Encodable.S✝) → Mathlib.Deriving.Encodable.S.below✝ t → motive t) → motive t | null | false |
Configuration.HasLines.lineCount_eq_pointCount | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} [inst : Membership P L] [Configuration.HasLines P L] [inst_2 : Fintype P]
[inst_3 : Fintype L],
Fintype.card P = Fintype.card L →
∀ {p : P} {l : L}, p ∉ l → Configuration.lineCount L p = Configuration.pointCount P l | null | true |
NNReal.agm_zero_left | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {y : NNReal}, NNReal.agm 0 y = 0 | null | true |
Mathlib.Tactic.AtomM.Recurse.instReprConfig | Mathlib.Util.AtomM.Recurse | Repr Mathlib.Tactic.AtomM.Recurse.Config | null | true |
Equiv.Perm.cycleOf_one | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} [inst : DecidableRel (Equiv.Perm.SameCycle 1)] (x : α), Equiv.Perm.cycleOf 1 x = 1 | null | true |
Nat.modEq_and_modEq_iff_modEq_mul | Mathlib.Data.Nat.ModEq | ∀ {a b m n : ℕ}, m.Coprime n → (a ≡ b [MOD m] ∧ a ≡ b [MOD n] ↔ a ≡ b [MOD m * n]) | null | true |
ProperCone.innerDual.congr_simp | Mathlib.Analysis.Convex.Cone.InnerDual | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : CompleteSpace E]
(s s_1 : Set E), s = s_1 → ProperCone.innerDual s = ProperCone.innerDual s_1 | null | true |
Std.Ric.Sliceable | Init.Data.Slice.Notation | Type u → outParam (Type v) → outParam (Type w) → Type (max (max u v) w) | This typeclass indicates how to obtain slices of elements of `α` over ranges in the index type
`β`, the ranges being left-unbounded right-closed.
The type of the resulting slices is `γ`.
| true |
CategoryTheory.Limits.HasZeroMorphisms.ext | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I J : CategoryTheory.Limits.HasZeroMorphisms C), I = J | If you're tempted to use this lemma "in the wild", you should probably
carefully consider whether you've made a mistake in allowing two
instances of `HasZeroMorphisms` to exist at all.
See, particularly, the note on `zeroMorphismsOfZeroObject` below.
| true |
Lean.HasConstCache.cache._default | Lean.Util.HasConstCache | {declNames : Array Lean.Name} → Std.HashMap.Raw Lean.Expr Bool | null | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_45 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lidx n : ℕ) (lhs : Std.Tactic.BVDecide.BVExpr w) (rhs : Std.Tactic.BVDecide.BVExpr n),
¬Std.Tactic.BVDecide.BVExpr.var lidx = lhs.shiftLeft rhs | null | false |
List.replace.eq_def | Init.Data.List.Impl | ∀ {α : Type u} [inst : BEq α] (x : List α) (x_1 x_2 : α),
x.replace x_1 x_2 =
match x, x_1, x_2 with
| [], x, x_3 => []
| a :: as, b, c =>
match b == a with
| true => c :: as
| false => a :: as.replace b c | null | true |
IsCompl.of_le | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {x y : α}, x ⊓ y ≤ ⊥ → ⊤ ≤ x ⊔ y → IsCompl x y | null | true |
ProbabilityTheory.Kernel.Invariant.comp | Mathlib.Probability.Kernel.Invariance | ∀ {α : Type u_1} {mα : MeasurableSpace α} {κ η : ProbabilityTheory.Kernel α α} {μ : MeasureTheory.Measure α},
κ.Invariant μ → η.Invariant μ → (κ.comp η).Invariant μ | null | true |
_private.Mathlib.RingTheory.PowerSeries.Trunc.0.PowerSeries.coeff_truncAux | Mathlib.RingTheory.PowerSeries.Trunc | ∀ {R : Type u_1} [inst : Semiring R] (m n : ℕ) (φ : PowerSeries R),
(PowerSeries.truncAux✝ n φ).coeff m = if m < n then (PowerSeries.coeff m) φ else 0 | null | true |
CategoryTheory.MorphismProperty.colimitsOfShape_le_coproducts | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (J : Type w),
W.colimitsOfShape (CategoryTheory.Discrete J) ≤ CategoryTheory.MorphismProperty.coproducts.{w, v, u} W | null | true |
CategoryTheory.SimplicialObject.Augmented.const._proof_3 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
{ left := (CategoryTheory.SimplicialObject.const C).map (CategoryTheory.CategoryStruct.id X),
right := CategoryTheory.CategoryStruct.id X, w := ⋯ } =
CategoryTheory.CategoryStruct.id
{ left := (CategoryTheory.SimplicialObject.cons... | null | false |
Vector.set_eraseIdx | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {w : i < n} {j : ℕ} {a : α} (hj : j < n - 1),
(xs.eraseIdx i w).set j a hj = if h' : i ≤ j then (xs.set (j + 1) a ⋯).eraseIdx i w else (xs.set j a ⋯).eraseIdx i w | null | true |
isAtomic_iff | Mathlib.Order.Atoms | ∀ (α : Type u_2) [inst : PartialOrder α] [inst_1 : OrderBot α], IsAtomic α ↔ ∀ (b : α), b = ⊥ ∨ ∃ a, IsAtom a ∧ a ≤ b | null | true |
Array.size_eq_one_iff | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, xs.size = 1 ↔ ∃ a, xs = #[a] | null | true |
_private.Lean.Elab.Quotation.Precheck.0.Lean.Elab.Term.Quotation.precheckBinopLazy._regBuiltin.Lean.Elab.Term.Quotation.precheckBinopLazy_1 | Lean.Elab.Quotation.Precheck | IO Unit | null | false |
Real.geom_mean_lt_arith_mean_weighted_iff_of_pos' | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) (w z : ι → ℝ),
(∀ i ∈ s, 0 < w i) →
∑ i ∈ s, w i = 1 →
(∀ i ∈ s, 0 ≤ z i) → (∏ i ∈ s, z i ^ w i < ∑ i ∈ s, w i * z i ↔ ∃ j ∈ s, z j ≠ ∑ i ∈ s, w i * z i) | **AM-GM inequality - strict inequality condition**.
The condition is that not all elements of `z` are equal to their center of mass
`∑ i ∈ s, w i * z i`; see `geom_mean_lt_arith_mean_weighted_iff_of_pos` for a version that compares
the elements to each other instead. | true |
AddOpposite.instAddCommGroup.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddCommGroup α],
AddOpposite.instAddCommGroup = { toAddGroup := AddOpposite.instAddGroup, add_comm := ⋯ } | null | true |
comap_mabs_nhds_one | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : LinearOrder G] [IsOrderedMonoid G]
[OrderTopology G], Filter.comap mabs (nhds 1) = nhds 1 | null | true |
RCLike.hasSum_ofReal | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u_1} (𝕜 : Type u_2) [inst : RCLike 𝕜] {L : SummationFilter α} {f : α → ℝ} {x : ℝ},
HasSum (fun x => ↑(f x)) (↑x) L ↔ HasSum f x L | null | true |
Equiv.Perm.inv_subtypePerm | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {p : α → Prop} (f : Equiv.Perm α) (hf : ∀ (x : α), p (f x) ↔ p x),
(f.subtypePerm hf)⁻¹ = f⁻¹.subtypePerm ⋯ | See `Equiv.Perm.subtypePerm_inv`. | true |
Std.HashSet.Raw.get?_emptyWithCapacity | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α} {c : ℕ}, (Std.HashSet.Raw.emptyWithCapacity c).get? a = none | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.DropWhile.0.Std.Iter.step_intermediateDropWhile.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.DropWhile | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {it : Std.Iter β} (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.Iter β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' ... | null | true |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.dvd_trans.match_1_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (motive : (x x_1 x_2 : ℤ) → x ∣ x_1 → x_1 ∣ x_2 → Prop) (x x_1 x_2 : ℤ) (x_3 : x ∣ x_1) (x_4 : x_1 ∣ x_2),
(∀ (a d e : ℤ), motive a (a * d) (a * d * e) ⋯ ⋯) → motive x x_1 x_2 x_3 x_4 | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._proof_28 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (lhs rhs : Std.Sat.AIG.Fanin),
lhs.gate < upper ∧ rhs.gate < upper →
∀ (rstate : Std.Sat.AIG.toCNF.State✝ aig),
lhs.gate < (Std.Sat.AIG.toCNF.Cache.marks✝ (Std.Sat.AIG.toCNF.State.cache✝ rstate)).size | null | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.finite_periods | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s), (IsProperLinearSet.periods✝ hs).Finite | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.