name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Parser.Tactic.Conv.rewrite | Init.Conv | Lean.ParserDescr | `rw [thm]` rewrites the target using `thm`. See the `rw` tactic for more information. | true |
Std.TreeMap.Raw.toList_rco | Std.Data.TreeMap.Raw.Slice | ∀ {α : Type u} {β : Type v} (cmp : autoParam (α → α → Ordering) Std.TreeMap.Raw.toList_rco._auto_1) [Std.TransCmp cmp]
{t : Std.TreeMap.Raw α β cmp},
t.WF →
∀ {lowerBound upperBound : α},
Std.Slice.toList (Std.Rco.Sliceable.mkSlice t (lowerBound...upperBound)) =
List.filter (fun e => decide ((cmp ... | null | true |
Finset.inf'_congr | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] {s : Finset β} (H : s.Nonempty) {t : Finset β} {f g : β → α}
(h₁ : s = t), (∀ x ∈ s, f x = g x) → s.inf' H f = t.inf' ⋯ g | null | true |
_private.Batteries.Data.Fin.Coding.0.Fin.encodePi._proof_7 | Batteries.Data.Fin.Coding | ∀ (n : ℕ) (f : Fin (n + 1) → ℕ) (x : (i : Fin (n + 1)) → Fin (f i)) (k : ℕ), f 0 * k + ↑(x 0) < f 0 * k + f 0 | null | false |
mem_of_csSup_mem_of_forall_exists_gt | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] {a b : α} {s : Set α},
sSup (s ∩ Set.Icc a b) ∈ s → a ∈ s → a ≤ b → (∀ x ∈ s ∩ Set.Ico a b, (s ∩ Set.Ioc x b).Nonempty) → b ∈ s | A version of the continuous induction principle `IsClosed.mem_of_ge_of_forall_exists_gt` where
closedness is weakened to membership of the supremum: if `a ∈ s`, the supremum of `s ∩ [a, b]`
belongs to `s`, and `s ∩ [a, b)` has no maximal point, then `b ∈ s`. | true |
CategoryTheory.yoneda'_comp | Mathlib.CategoryTheory.Sites.Types | CategoryTheory.yoneda'.comp (CategoryTheory.sheafToPresheaf CategoryTheory.typesGrothendieckTopology (Type u)) =
CategoryTheory.yoneda | null | true |
ContinuousMap.HomotopyWith.ext_iff | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
{P : C(X, Y) → Prop} {F G : f₀.HomotopyWith f₁ P}, F = G ↔ ∀ (x : ↑unitInterval × X), F x = G x | null | true |
Vector.mapFinIdxM | Init.Data.Vector.Basic | {n : ℕ} →
{α : Type u} →
{β : Type v} → {m : Type v → Type w} → [Monad m] → Vector α n → ((i : ℕ) → α → i < n → m β) → m (Vector β n) | Variant of `mapIdxM` which receives the index `i` along with the bound `i < n. | true |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.limitOfSurjectionsSurjective.preimage.match_1 | Mathlib.CategoryTheory.Limits.Types.Images | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
MonoidHom.coe_of_map_mul_inv | Mathlib.Algebra.Group.Hom.Basic | ∀ {G : Type u_5} [inst : Group G] {H : Type u_8} [inst_1 : Group H] (f : G → H)
(map_div : ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹), ⇑(MonoidHom.ofMapMulInv f map_div) = f | null | true |
CategoryTheory.AddMonObj.zero_eq_zero | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.AddMonObj M], CategoryTheory.AddMonObj.zero = 0 | null | true |
CategoryTheory.Limits.createsColimitsOfShapeOfRightOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(J : Type w) →
[inst_2 : CategoryTheory.Category.{w', w} J] →
(F : CategoryTheory.Functor Cᵒᵖ D) →
[CategoryTheory.CreatesLimitsOfShape Jᵒ... | If `F.rightOp : C ⥤ Dᵒᵖ` creates limits of shape `Jᵒᵖ`, then `F : Cᵒᵖ ⥤ D` creates colimits
of shape `J`. | true |
FirstOrder.Language.ElementarilyEquivalent.toModel | Mathlib.ModelTheory.Bundled | {L : FirstOrder.Language} →
(T : L.Theory) →
{M : T.ModelType} → {N : Type u_1} → [LN : L.Structure N] → L.ElementarilyEquivalent (↑M) N → T.ModelType | A structure that is elementarily equivalent to a model, bundled as a model. | true |
SimpleGraph.finsubgraphOfAdj.eq_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (e : G.Adj u v), SimpleGraph.finsubgraphOfAdj e = ⟨G.subgraphOfAdj e, ⋯⟩ | null | true |
Filter.pi_mono | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)},
(∀ (i : ι), f₁ i ≤ f₂ i) → Filter.pi f₁ ≤ Filter.pi f₂ | null | true |
_private.Init.Data.Range.Polymorphic.BitVec.0.BitVec.instLawfulUpwardEnumerable._simp_4 | Init.Data.Range.Polymorphic.BitVec | ∀ {m n : ℕ}, m ≤ n → ∀ {x : BitVec m}, (x.toNat < 2 ^ n) = True | null | false |
CategoryTheory.isIso_iff_nonzero | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasKernels C] {X Y : C} [CategoryTheory.Simple X] [CategoryTheory.Simple Y] (f : X ⟶ Y),
CategoryTheory.IsIso f ↔ f ≠ 0 | As a corollary of Schur's lemma for preadditive categories,
any morphism between simple objects is (exclusively) either an isomorphism or zero.
| true |
FinBddDistLat.ofHom | Mathlib.Order.Category.FinBddDistLat | {X Y : Type u} →
[inst : DistribLattice X] →
[inst_1 : BoundedOrder X] →
[inst_2 : Fintype X] →
[inst_3 : DistribLattice Y] →
[inst_4 : BoundedOrder Y] → [inst_5 : Fintype Y] → BoundedLatticeHom X Y → (↧X ⟶ ↧Y) | Typecheck a `BoundedLatticeHom` as a morphism in `FinBddDistLat`. | true |
Order.Preimage.instIsStrictOrder | Mathlib.Order.RelClasses | ∀ {α : Type u} {β : Type v} {r : α → α → Prop} [IsStrictOrder α r] {f : β → α}, IsStrictOrder β (f ⁻¹'o r) | null | true |
AddAction.instDecidablePredMemAddSubmonoidStabilizerAddSubmonoidOfDecidableEq | Mathlib.GroupTheory.GroupAction.Defs | {M : Type u_1} →
{α : Type u_3} →
[inst : AddMonoid M] →
[inst_1 : AddAction M α] →
[DecidableEq α] → (a : α) → DecidablePred fun x => x ∈ AddAction.stabilizerAddSubmonoid M a | null | true |
Polynomial.instNormalizationMonoid._proof_10 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : NormalizationMonoid R],
Polynomial.C ↑(normUnit (Polynomial.leadingCoeff 1))⁻¹ * Polynomial.C ↑(normUnit (Polynomial.leadingCoeff 1)) = 1 | null | false |
Profinite.NobelingProof.isClosed_C0 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}},
IsClosed C → ∀ (ho : o < Ordinal.type fun x1 x2 => x1 < x2), IsClosed (Profinite.NobelingProof.C0 C ho) | null | true |
Std.DHashMap.Internal.Raw₀.map | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} → ((a : α) → β a → γ a) → Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α γ | Internal implementation detail of the hash map | true |
map_inv_eq_ringInverse_map | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {M₀ : Type u_2} {G₀ : Type u_3} {F : Type u_6} [inst : MonoidWithZero M₀] [inst_1 : GroupWithZero G₀]
[inst_2 : FunLike F G₀ M₀] [MonoidWithZeroHomClass F G₀ M₀] (f : F) (a : G₀), f a⁻¹ = Ring.inverse (f a) | null | true |
Fin.succAbove_of_lt_succ | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), p < i.succ → p.succAbove i = i.succ | null | true |
QuadraticAlgebra.instCommSemiring._proof_4 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : CommSemiring R] (x x_1 : QuadraticAlgebra R a b), x * x_1 = x_1 * x | null | false |
Part.mem_ofOption._simp_1 | Mathlib.Data.Part | ∀ {α : Type u_1} {a : α} {o : Option α}, (a ∈ ↑o) = (a ∈ o) | null | false |
Lean.Macro.Context.ctorIdx | Init.Prelude | Lean.Macro.Context → ℕ | null | false |
SimpleGraph.finsetWalkLength._f | Mathlib.Combinatorics.SimpleGraph.Walk.Counting | {V : Type u} →
(G : SimpleGraph V) →
[DecidableEq V] →
[G.LocallyFinite] →
(v : V) →
(n : ℕ) → Nat.below (motive := fun n => (u : V) → Finset (G.Walk u v)) n → (u : V) → Finset (G.Walk u v) | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.span_singleton_mul_le_span_singleton_mul._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {I : Ideal R}, (x ∈ Ideal.span {y} * I) = ∃ z ∈ I, y * z = x | null | false |
CategoryTheory.Limits.WidePushoutShape.struct._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePushoutShape J}, Z = none → none = Z | null | false |
Lean.InductiveVal.mk.inj | Lean.Declaration | ∀ {toConstantVal : Lean.ConstantVal} {numParams numIndices : ℕ} {all ctors : List Lean.Name} {numNested : ℕ}
{isRec isUnsafe isReflexive : Bool} {toConstantVal_1 : Lean.ConstantVal} {numParams_1 numIndices_1 : ℕ}
{all_1 ctors_1 : List Lean.Name} {numNested_1 : ℕ} {isRec_1 isUnsafe_1 isReflexive_1 : Bool},
{ toCon... | null | true |
_private.Init.Data.String.Basic.0.String.copy_toSlice._simp_1_2 | Init.Data.String.Basic | ∀ {s : String}, s.utf8ByteSize = s.toByteArray.size | null | false |
CategoryTheory.ObjectProperty.small_unop_iff | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
CategoryTheory.ObjectProperty.Small.{w, v, u} P.unop ↔ CategoryTheory.ObjectProperty.Small.{w, v, u} P | null | true |
AlgCat.limitSemiring._aux_1 | Mathlib.Algebra.Category.AlgCat.Limits | {R : Type u_4} →
[inst : CommRing R] →
{J : Type u_3} →
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J (AlgCat R)) →
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections] →
(CategoryTheory.Limits.Types.Small.l... | null | false |
ArchimedeanClass.instFieldFiniteResidueField._aux_8 | Mathlib.Algebra.Order.Ring.StandardPart | (K : Type u_1) →
[inst : LinearOrder K] →
[inst_1 : Field K] →
[inst_2 : IsOrderedRing K] → ℕ → ArchimedeanClass.FiniteResidueField K → ArchimedeanClass.FiniteResidueField K | null | false |
Finset.ruzsa_triangle_inequality_addNeg_add_add | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
(A + -C).card * B.card ≤ (A + B).card * (C + B).card | **Ruzsa's triangle inequality**. Addneg-add-add version. | true |
Mathlib.Tactic.Algebra.algebraWith | Mathlib.Tactic.Algebra.Basic | Lean.ParserDescr | `algebra` solves equalities in the language of algebras: ring operations and scalar
multiplications.
Given a goal which is an equality in a commutative `R`-algebra `A`, `algebra` parses the LHS and
RHS of the goal as polynomial expressions of `A`-atoms with coefficients in some semiring `R`, and
closes the goal if the... | true |
NonUnitalCommCStarAlgebra.toNonUnitalNormedCommRing | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} → [self : NonUnitalCommCStarAlgebra A] → NonUnitalNormedCommRing A | null | true |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.foldlMAux.traverse | Lean.Data.PersistentHashMap | {m : Type w → Type w'} →
[Monad m] →
{σ : Type w} →
{α : Type u_1} →
{β : Type u_2} → (σ → α → β → m σ) → (keys : Array α) → (vals : Array β) → keys.size = vals.size → ℕ → σ → m σ | null | true |
Nat.add_mod_eq_add_mod_left | Init.Data.Nat.Lemmas | ∀ {a d b : ℕ} (c : ℕ), a % d = b % d → (c + a) % d = (c + b) % d | null | true |
WithConv.casesOn | Mathlib.Algebra.WithConv | {A : Sort u_1} →
{motive : WithConv A → Sort u} → (t : WithConv A) → ((ofConv : A) → motive (WithConv.toConv ofConv)) → motive t | null | false |
PresheafOfModules.Sheafify.smul_zero | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | null | true |
eval_det | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {n : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_3} [inst_2 : CommRing R]
(M : Matrix n n (Polynomial R)) (r : R),
Polynomial.eval r M.det = (Polynomial.eval ((Matrix.scalar n) r) (matPolyEquiv M)).det | null | true |
CategoryTheory.epi_comp_iff_of_isIso | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
[CategoryTheory.IsIso g], CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g) ↔ CategoryTheory.Epi f | When `g` is an isomorphism, `f ≫ g` is epic iff `f` is. | true |
IsOpen.tendstoLocallyUniformlyOn_iff_forall_tendsto | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
IsOpen s →
(TendstoLocallyUniformlyOn F f p s ↔
∀ x ∈ s, Filter.Tendsto (fun y => (f y.2, F y.1 y.2)) (p ×ˢ nhds x) (uniformity β)) | null | true |
RelIso.prodLexCongr._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {r₁ : α₁ → α₁ → Prop} {r₂ : α₂ → α₂ → Prop}
{s₁ : β₁ → β₁ → Prop} {s₂ : β₂ → β₂ → Prop} (e₁ : r₁ ≃r s₁) (e₂ : r₂ ≃r s₂) {a b : α₁ × α₂},
Prod.Lex s₁ s₂ ((e₁.prodCongr e₂.toEquiv) a) ((e₁.prodCongr e₂.toEquiv) b) ↔ Prod.Lex r₁ r₂ a b | null | false |
Lean.NamePart.num.sizeOf_spec | Lean.Data.NameTrie | ∀ (n : ℕ), sizeOf (Lean.NamePart.num n) = 1 + sizeOf n | null | true |
_private.Mathlib.Analysis.CStarAlgebra.Fuglede.0.SemiconjBy.star_right_of_unital | Mathlib.Analysis.CStarAlgebra.Fuglede | ∀ {A : Type u_1} [inst : CStarAlgebra A] {a b x : A} [IsStarNormal a] [IsStarNormal b],
SemiconjBy x a b → SemiconjBy x (star a) (star b) | null | true |
CategoryTheory.Limits.Types.isPullback_of_isPushout | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {X₁ X₂ X₃ X₄ : Type u} {t : X₁ ⟶ X₂} {r : X₂ ⟶ X₄} {l : X₁ ⟶ X₃} {b : X₃ ⟶ X₄},
CategoryTheory.IsPushout t l r b →
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom t) → CategoryTheory.IsPullback t l r b | A pushout square in `Type` where the top map is injective is a pullback square.
This is also essentially the lemma `isPullback_of_isPushout_of_mono_left`
from the file `CategoryTheory.Adhesive.Basic` in the case of the adhesive category of types. | true |
Topology.CWComplex.cellFrontier_union_openCell_eq_closedCell | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D] (n : ℕ)
(i : Topology.RelCWComplex.cell C n),
Topology.RelCWComplex.cellFrontier n i ∪ Topology.RelCWComplex.openCell n i = Topology.RelCWComplex.closedCell n i | **Alias** of `Topology.RelCWComplex.cellFrontier_union_openCell_eq_closedCell`. | true |
isRelLowerSet_empty._simp_1 | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α], IsRelLowerSet ∅ P = True | null | false |
sectionOfRetractionKerToTensorAux.congr_simp | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] (l l_1 : TensorProduct P S Ω[P⁄R] →ₗ[P] ↥(RingHom.ker (algebraMap P S)))
(e_l : l = l_1) (hl : l ∘ₗ KaehlerDifferential.kerToTensor R P S = LinearMap.id) (σ σ_... | null | true |
nnnorm_cfcₙHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : outParam (A → Prop)} [inst : RCLike 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : StarRing A] [inst_3 : NormedSpace 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A]
[inst_6 : NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p] (a : A)
(f : ContinuousM... | null | true |
Set.instFintypeIcc | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrder α] → (a b : α) → Fintype ↑(Set.Icc a b) | null | true |
OptionT.instMonadLift | Init.Control.Option | {m : Type u → Type v} → [Monad m] → MonadLift m (OptionT m) | null | true |
String.toInt?_comp_toSlice | Std.Data.String.ToInt | String.Slice.toInt? ∘ String.toSlice = String.toInt? | null | true |
Lean.Elab.ConfigEval.EvalExpr.evalOptionExprCore | Lean.Elab.ConfigEval.Instances | {α : Type} → (Lean.Expr → Lean.MetaM α) → Lean.Expr → Lean.MetaM (Option α) | null | true |
Batteries.Tactic.PrintPrefixConfig.ctorIdx | Batteries.Tactic.PrintPrefix | Batteries.Tactic.PrintPrefixConfig → ℕ | null | false |
ZPow.mk.noConfusion | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} → {P : Sort u} → {zpow zpow' : ℤ → G → G} → { zpow := zpow } = { zpow := zpow' } → (zpow ≍ zpow' → P) → P | null | false |
CategoryTheory.Functor.preimageIso_mapIso | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} [inst_2 : F.Full] [inst_3 : F.Faithful] (f : X ≅ Y),
F.preimageIso (F.mapIso f) = f | null | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Limits_ExactFunctor___unexpand_CategoryTheory_ExactFunctor_1 | Mathlib.CategoryTheory.Limits.ExactFunctor | Lean.PrettyPrinter.Unexpander | null | false |
Nat.ofNat_lt_cast | Mathlib.Data.Nat.Cast.Order.Basic | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ} [inst_5 : m.AtLeastTwo], OfNat.ofNat m < ↑n ↔ OfNat.ofNat m < n | null | true |
IsDedekindDomain.selmerGroup.fromUnit | Mathlib.RingTheory.DedekindDomain.SelmerGroup | {R : Type u} →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
{K : Type v} →
[inst_2 : Field K] →
[inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → {n : ℕ} → Rˣ →* ↥IsDedekindDomain.selmerGroup | The natural homomorphism from `Rˣ` to `K⟮∅, n⟯`. | true |
instCommRingFreeCommRing._aux_1 | Mathlib.RingTheory.FreeCommRing | (α : Type u_1) → FreeCommRing α | null | false |
Lean.Compiler.LCNF.ToMonoM.State.rec | Lean.Compiler.LCNF.ToMono | {motive : Lean.Compiler.LCNF.ToMonoM.State → Sort u} →
((typeParams : Lean.FVarIdHashSet) → motive { typeParams := typeParams }) →
(t : Lean.Compiler.LCNF.ToMonoM.State) → motive t | null | false |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.evaln_complete._simp_1_29 | Mathlib.Computability.PartrecCode | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
_private.Init.Data.Nat.Fold.0.Nat.fold_congr._proof_1 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, n = m → ∀ i < m, ¬i < n → False | null | false |
Fintype.sum_subtype_add_sum_subtype | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} {ι : Type u_5} [inst : Fintype ι] [inst_1 : AddCommMonoid M] (p : ι → Prop) (f : ι → M)
[inst_2 : DecidablePred p], ∑ i, f ↑i + ∑ i, f ↑i = ∑ i, f i | null | true |
Finsupp.embDomain_comapDomain | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] {f : α ↪ β} {g : β →₀ M},
↑g.support ⊆ Set.range ⇑f → Finsupp.embDomain f (Finsupp.comapDomain (⇑f) g ⋯) = g | null | true |
Set.MapsTo.subset_preimage | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.MapsTo f s t → s ⊆ f ⁻¹' t | null | true |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.Strictness.toPositive.match_1 | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
{e : Q(«$α»)} →
{pα : Q(PartialOrder «$α»)} →
(motive : Mathlib.Meta.Positivity.Strictness zα e (some pα) → Sort u_1) →
(x : Mathlib.Meta.Positivity.Strictness zα e (some pα)) →
((pf : Q(0 < «$e»)) → motiv... | null | false |
Setoid.mkClasses_classes | Mathlib.Order.Setoid.Partition | ∀ {α : Type u_1} (r : Setoid α), Setoid.mkClasses r.classes ⋯ = r | The equivalence relation made from the equivalence classes of an equivalence relation `r`
equals `r`. | true |
Lean.Elab.Tactic.Omega.Problem.addInequality | Lean.Elab.Tactic.Omega.Core | Lean.Elab.Tactic.Omega.Problem →
ℤ → Lean.Omega.Coeffs → Option Lean.Elab.Tactic.Omega.Proof → Lean.Elab.Tactic.Omega.Problem | Helper function for adding an inequality of the form `const + Coeffs.dot coeffs atoms ≥ 0`
to a `Problem`.
(This is only used while initializing a `Problem`. During elimination we use `addConstraint`.)
| true |
Sym.mem_mk | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (s : Multiset α) (h : s.card = n), a ∈ Sym.mk s h ↔ a ∈ s | null | true |
Std.Sat.AIG.RefVec.cast'.eq_1 | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α} (s : aig1.RefVec len)
(h :
(∀ {i : ℕ} (h : i < len), s.refs[i].gate < aig1.decls.size) →
∀ {i : ℕ} (h : i < len), s.refs[i].gate < aig2.decls.size),
s.cast' h = { refs := s.refs, hrefs := ⋯ } | null | true |
SSet.prodStdSimplex.pairingCore.IsIndex.type₁_index | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N} {d : ℕ}
{hd : x.dim = d + 1} {i : Fin (d + 1)} (h : SSet.prodStdSimplex.pairingCore.IsIndex x hd i.succ), h.type₁.index = i | null | true |
_private.Init.Data.SInt.Lemmas.0.Int32.toISize_ne_minValue._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x = y) = (x.toInt = y.toInt) | null | false |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.mkBoxedVersion.match_1 | Lean.Compiler.LCNF.ExplicitBoxing | (motive :
Option
(Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure ×
Subarray (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure)) →
Sort u_1) →
(x :
Option
(Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure ×
Subarray (Lean.Compiler.LCNF.Pa... | null | false |
NumberField.IsCMField.mem_realUnits_iff | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] (u : (NumberField.RingOfIntegers K)ˣ),
u ∈ NumberField.IsCMField.realUnits K ↔
∃ v,
(algebraMap (NumberField.RingOfIntegers ↥(NumberField.maximalRealSubfield K)) (NumberField.RingOfIntegers K)) ↑v =
↑u | null | true |
MonoidHom.fiberEquivKerOfSurjective._proof_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_2} [inst : Group α] {H : Type u_1} [inst_1 : Group H] {f : α →* H} (hf : Function.Surjective ⇑f) (h : H),
f ⋯.choose = h | null | false |
Std.TreeMap.Raw.getElem!_union_of_not_mem_right | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst : Inhabited β], k ∉ t₂ → (t₁ ∪ t₂)[k]! = t₁[k]! | null | true |
Subarray.get! | Init.Data.Array.Subarray | {α : Type u_1} → [Inhabited α] → Subarray α → ℕ → α | Extracts an element from the subarray, or returns a default value when the index is out of bounds.
The index is relative to the start and end of the subarray, rather than the underlying array. The
default value is that provided by the `Inhabited α` instance.
| true |
Mathlib.Tactic.ITauto.IProp.ctorElim | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.IProp → Sort u} →
(ctorIdx : ℕ) →
(t : Mathlib.Tactic.ITauto.IProp) →
ctorIdx = t.ctorIdx → Mathlib.Tactic.ITauto.IProp.ctorElimType ctorIdx → motive t | null | false |
Ordering | Init.Data.Ord.Basic | Type | The result of a comparison according to a total order.
The relationship between the compared items may be:
* `Ordering.lt`: less than
* `Ordering.eq`: equal
* `Ordering.gt`: greater than
| true |
List.Cursor | Std.Do.Triple.SpecLemmas | {α : Type u} → List α → Type u | A pointer at a specific location in a list. List cursors are used in loop invariants for the
`mvcgen` tactic.
Moving the cursor to the left or right takes time linear in the current position of the cursor, so
this data structure is not appropriate for run-time code.
| true |
Stream'.WSeq.drop.aux_none | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (n : ℕ), Stream'.WSeq.drop.aux n none = Computation.pure none | null | true |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.Seq.BisimO.match_1.splitter | Mathlib.Data.WSeq.Basic | {α : Type u_1} →
(motive : Option (Stream'.Seq1 α) → Option (Stream'.Seq1 α) → Sort u_2) →
(x x_1 : Option (Stream'.Seq1 α)) →
(Unit → motive none none) →
((a : α) → (s : Stream'.Seq α) → (a' : α) → (s' : Stream'.Seq α) → motive (some (a, s)) (some (a', s'))) →
((x x_2 : Option (Stream'.Se... | null | true |
Std.Rci.rec | Init.Data.Range.Polymorphic.PRange | {α : Type u} → {motive : Std.Rci α → Sort u_1} → ((lower : α) → motive (lower...*)) → (t : Std.Rci α) → motive t | null | false |
MultilinearMap.freeFinsuppEquiv._proof_4 | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
supIrred_ofDual | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a : αᵒᵈ}, SupIrred (OrderDual.ofDual a) ↔ InfIrred a | null | true |
NonUnitalSeminormedRing.rec | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
{motive : NonUnitalSeminormedRing α → Sort u} →
([toNorm : Norm α] →
[toNonUnitalRing : NonUnitalRing α] →
[toPseudoMetricSpace : PseudoMetricSpace α] →
(dist_eq : ∀ (x y : α), dist x y = ‖-x + y‖) →
(norm_mul_le : ∀ (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖) →
... | null | false |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.isUnit_resultant_iff_isCoprime.match_1_4 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] {f g : Polynomial R} (motive : IsCoprime f g → Prop) (h : IsCoprime f g),
(∀ (a b : Polynomial R) (e : a * f + b * g = 1), motive ⋯) → motive h | null | false |
AddCommGrpCat.ofHom_hom | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddCommGrpCat} (f : X ⟶ Y), AddCommGrpCat.ofHom (AddCommGrpCat.Hom.hom f) = f | null | true |
CategoryTheory.Grothendieck.functorFrom_obj | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{E : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} E] (fib : (c : C) → CategoryTheory.Functor (↑(F.obj c)) E)
(hom : {c c' : C} → (f : c ⟶ c') → fib c ⟶ (F.map f).toFunctor.comp (fib c'))
(hom_id : ... | null | true |
CategoryTheory.Free.of | Mathlib.Algebra.Category.ModuleCat.Adjunctions | (R : Type u_1) → {C : Type u} → C → CategoryTheory.Free R C | Consider an object of `C` as an object of the `R`-linear completion.
It may be preferable to use `(Free.embedding R C).obj X` instead;
this functor can also be used to lift morphisms.
| true |
Mathlib.Tactic.Widget.StringDiagram.IdNode | Mathlib.Tactic.Widget.StringDiagram | Type | Nodes for identity 2-morphisms in a string diagram. | true |
Topology.IsConstructible.preimage_of_isOpenEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Topology.IsOpenEmbedding f → Topology.IsConstructible s → Topology.IsConstructible (f ⁻¹' s) | [Stacks Tag 005J](https://stacks.math.columbia.edu/tag/005J) | true |
Hashable.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Sort u} →
{t : Hashable α} → {α' : Sort u} → {t' : Hashable α'} → α = α' → t ≍ t' → Hashable.noConfusionType P t t' | null | false |
ProbabilityTheory.HasGaussianLaw.toLp_prodMk | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {F : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E]
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace ℝ F] [inst_6 : MeasurableSpace F] [BorelSpace F... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.