name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Localization.AtPrime.map_eq_maximalIdeal | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {I : Ideal R} [hI : I.IsPrime],
Ideal.map (algebraMap R (Localization.AtPrime I)) I = IsLocalRing.maximalIdeal (Localization I.primeCompl) | The image of `I` in the localization at `I.primeCompl` is a maximal ideal, and in particular
it is the unique maximal ideal given by the local ring structure `AtPrime.isLocalRing` | true |
_private.Mathlib.Analysis.Normed.Group.Uniform.0.MonoidHomClass.isometry_iff_norm._simp_1_2 | Mathlib.Analysis.Normed.Group.Uniform | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Group G] [inst_2 : DivisionMonoid H]
[MonoidHomClass F G H] (f : F) (a : G), (f a)⁻¹ = f a⁻¹ | null | false |
Module.ext | Mathlib.Algebra.Module.Defs | ∀ {R : Type u} {M : Type v} {inst : Semiring R} {inst_1 : AddCommMonoid M} {x y : Module R M},
SMul.smul = SMul.smul → x = y | null | true |
TopologicalSpace.Compacts.map_singleton | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β}
(hf : Continuous f) (x : α), TopologicalSpace.Compacts.map f hf {x} = {f x} | null | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doMatch._regBuiltin.Lean.Parser.Term.doMatch.parenthesizer_23 | Lean.Parser.Do | IO Unit | null | false |
Std.DTreeMap.Internal.Impl.filterMap!.eq_def | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : Ord α] (f : (a : α) → β a → Option (γ a))
(t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.filterMap! f t =
match t with
| Std.DTreeMap.Internal.Impl.leaf => Std.DTreeMap.Internal.Impl.leaf
| Std.DTreeMap.Internal.Impl.inner size k... | null | true |
CategoryTheory.Functor.RepresentableBy.homEquiv' | Mathlib.CategoryTheory.ConcreteCategory.Representable | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor Cᵒᵖ D} →
{CD : D → Type u_3} →
{FD : D → D → Type u_4} →
[inst_2 : (X Y : D) → FunLike (FD X Y) (CD X) (... | The natural bijection `(X ⟶ Y) ≃ F.obj (op X)`. | true |
AddConstMap.toEnd_apply | Mathlib.Algebra.AddConstMap.Basic | ∀ {G : Type u_1} [inst : Add G] {a : G}, ⇑AddConstMap.toEnd = DFunLike.coe | null | true |
Matrix.instLieRingToLieAlgebra._aux_14 | Mathlib.Algebra.Lie.SerreConstruction | (R : Type u_1) →
{B : Type u_2} →
[inst : CommRing R] →
(CM : Matrix B B ℤ) →
[inst_1 : DecidableEq B] → Matrix.ToLieAlgebra R CM → Matrix.ToLieAlgebra R CM → Matrix.ToLieAlgebra R CM | null | false |
ENat.add_le_add_iff_left | Mathlib.Data.ENat.Basic | ∀ {m n k : ℕ∞}, k ≠ ⊤ → (k + n ≤ k + m ↔ n ≤ m) | null | true |
_private.Mathlib.FieldTheory.SeparablyGenerated.0.MvPolynomial.aeval_toPolynomialAdjoinImageCompl_eq_zero._simp_1_3 | Mathlib.FieldTheory.SeparablyGenerated | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
(φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B) (p : A), φ₁ (φ₂ p) = (φ₁.comp φ₂) p | null | false |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image_aux1._simp_1_13 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {q : NNReal}, (0 ≤ ↑q) = True | null | false |
MinTropical.le_zero._simp_2 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LE R] [inst_1 : OrderTop R] (x : MinTropical R), (x ≤ 0) = True | null | false |
_private.Init.Data.UInt.Lemmas.0.USize.lt_of_le_of_lt._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
AlgebraicGeometry.Scheme.RationalMap.comp._proof_1 | Mathlib.AlgebraicGeometry.Birational.Composition | ∀ {X Y Z : AlgebraicGeometry.Scheme} [inst : PreirreducibleSpace ↥X] [inst_1 : Nonempty ↥Y] (f : X.RationalMap Y)
[inst_2 : f.IsDominant] (x x_1 : Y.PartialMap Z),
x ≈ x_1 →
(AlgebraicGeometry.Scheme.PartialMap.toRationalMap ∘ f.representative.comp) x =
(AlgebraicGeometry.Scheme.PartialMap.toRationalMap ∘... | null | false |
WeierstrassCurve.Jacobian.Point.toAffineAddEquiv_apply | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] (W : WeierstrassCurve.Jacobian F) [inst_1 : DecidableEq F] (P : W.Point),
(WeierstrassCurve.Jacobian.Point.toAffineAddEquiv W) P = P.toAffineLift | null | true |
DiscreteTopology.of_subset | Mathlib.Topology.Constructions | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s t : Set X}, DiscreteTopology ↑s → t ⊆ s → DiscreteTopology ↑t | Let `s, t ⊆ X` be two subsets of a topological space `X`. If `t ⊆ s` and the topology induced
by `X` on `s` is discrete, then also the topology induces on `t` is discrete.
(Compare `IsDiscrete.mono` which is the same thing stated without using subtypes.) | true |
differentiableAt_piLp | Mathlib.Analysis.Calculus.FDeriv.WithLp | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup H] [inst_2 : (i : ι) → NormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_4 : NormedSpace 𝕜 H] [Finite ι] (p : ENNReal) [Fact (1 ≤ p)] {f : H → PiLp p E} {y : H... | null | true |
SemilinearEquivClass.semilinearEquiv._proof_1 | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_4} {S : Type u_5} {M : Type u_2} {M₂ : Type u_1} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂] {σ : R →+* S}
{σ' : S →+* R} [inst_6 : RingHomInvPair σ σ'] [inst_7 : RingHomInvPair σ' σ] [inst... | null | false |
_private.Mathlib.Basic.NNReal.Defs.0.NNReal.bddAbove_coe.match_1_7 | Mathlib.Basic.NNReal.Defs | ∀ {s : Set NNReal} (motive : BddAbove s → Prop) (x : BddAbove s),
(∀ (b : NNReal) (hb : b ∈ upperBounds s), motive ⋯) → motive x | null | false |
ProbabilityTheory.HasGaussianLaw.isGaussian_map | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Def | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} [inst : TopologicalSpace E] [inst_1 : AddCommMonoid E]
[inst_2 : Module ℝ E] [mE : MeasurableSpace E] {X : Ω → E} {P : MeasureTheory.Measure Ω},
ProbabilityTheory.HasGaussianLaw X P → ProbabilityTheory.IsGaussian (MeasureTheory.Measure.map X P) | null | true |
IsRegularLocalRing.instOfIsLocalRingOfIsDomainOfIsPrincipalIdealRing | Mathlib.RingTheory.RegularLocalRing.Defs | ∀ (R : Type u_1) [inst : CommRing R] [IsLocalRing R] [IsDomain R] [IsPrincipalIdealRing R], IsRegularLocalRing R | null | true |
LinOrd.Iso.mk_inv | Mathlib.Order.Category.LinOrd | ∀ {α β : LinOrd} (e : ↑α ≃o ↑β), (LinOrd.Iso.mk e).inv = LinOrd.ofHom ↑e.symm | null | true |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.Ctx.mk.injEq | Lean.Compiler.LCNF.ExplicitBoxing | ∀ (currDecl : Lean.Name) (currDeclResultType : Lean.Expr) (currDecl_1 : Lean.Name) (currDeclResultType_1 : Lean.Expr),
({ currDecl := currDecl, currDeclResultType := currDeclResultType } =
{ currDecl := currDecl_1, currDeclResultType := currDeclResultType_1 }) =
(currDecl = currDecl_1 ∧ currDeclResultType =... | null | true |
ContinuousOpenMapClass | Mathlib.Topology.Hom.Open | (F : Type u_6) →
(α : outParam (Type u_7)) →
(β : outParam (Type u_8)) → [TopologicalSpace α] → [TopologicalSpace β] → [FunLike F α β] → Prop | `ContinuousOpenMapClass F α β` states that `F` is a type of continuous open maps.
You should extend this class when you extend `ContinuousOpenMap`. | true |
MeasureTheory.eLpNormEssSup_lt_top_of_ae_bound | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_6} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup F]
{f : α → F} {C : ℝ}, (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C) → MeasureTheory.eLpNormEssSup f μ < ⊤ | null | true |
Polynomial.continuousWithinAt_aeval | Mathlib.Topology.Algebra.Polynomial | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : TopologicalSpace A] [IsTopologicalSemiring A] (p : Polynomial R) {s : Set A} {a : A},
ContinuousWithinAt (fun x => (Polynomial.aeval x) p) s a | null | true |
CategoryTheory.Functor.mapComon._proof_2 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] {X Y Z : CategoryTheory.Comon C} (f : X ... | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.CoordinateRing.XYIdeal_mul_XYIdeal._simp_1_8 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {α : Type u} [inst : Semiring α] {x y : α}, (x ∈ Ideal.span {y}) = ∃ a, a * y = x | null | false |
_private.Mathlib.Control.ULift.0.PLift.instLawfulApplicative_mathlib.match_1 | Mathlib.Control.ULift | ∀ (x x_1 : Type u_1) (motive : PLift (x → x_1) → Prop) (x_2 : PLift (x → x_1)),
(∀ (down : x → x_1), motive { down := down }) → motive x_2 | null | false |
_private.Mathlib.Data.Finset.Insert.0.Finset.toList_cons._simp_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | null | false |
Std.DTreeMap.Raw.empty_eq_emptyc | Std.Data.DTreeMap.Raw.Basic | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}, Std.DTreeMap.Raw.empty = ∅ | null | true |
Lean.Elab.ErrorNameInfo.mk.injEq | Lean.Elab.InfoTree.Types | ∀ (stx : Lean.Syntax) (errorName : Lean.Name) (stx_1 : Lean.Syntax) (errorName_1 : Lean.Name),
({ stx := stx, errorName := errorName } = { stx := stx_1, errorName := errorName_1 }) =
(stx = stx_1 ∧ errorName = errorName_1) | null | true |
Lean.PersistentHashSet.rec | Lean.Data.PersistentHashSet | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.PersistentHashSet α → Sort u_1} →
((set : Lean.PersistentHashMap α Unit) → motive { set := set }) → (t : Lean.PersistentHashSet α) → motive t | null | false |
CategoryTheory.LocalizerMorphism.LeftResolution.mk_surjective | 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 : Φ.LeftResolution X₂), ∃ X₁ w, ∃ (hw : W₂... | null | true |
CategoryTheory.Limits.Cocone.toCostructuredArrowCompProj_hom_app | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) (X : J),
c.toCostructuredArrowCompProj.hom.app X = CategoryTheory.CategoryStruct.id X | null | true |
CategoryTheory.CommSq.LiftStruct.opEquiv | Mathlib.CategoryTheory.CommSq | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A B X Y : C} →
{f : A ⟶ X} →
{i : A ⟶ B} → {p : X ⟶ Y} → {g : B ⟶ Y} → (sq : CategoryTheory.CommSq f i p g) → sq.LiftStruct ≃ ⋯.LiftStruct | Equivalences of `LiftStruct` for a square and the corresponding square
in the opposite category. | true |
_private.Mathlib.Algebra.Order.CauSeq.Basic.0.CauSeq.pos_add_limZero.match_1_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {f g : CauSeq α abs} (F : α)
(motive : (∃ i, ∀ j ≥ i, F ≤ ↑f j ∧ |↑g j| < F / 2) → Prop) (x : ∃ i, ∀ j ≥ i, F ≤ ↑f j ∧ |↑g j| < F / 2),
(∀ (i : ℕ) (h : ∀ j ≥ i, F ≤ ↑f j ∧ |↑g j| < F / 2), motive ⋯) → motive x | null | false |
Lean.Meta.Grind.Arith.CommRing.EqCnstr.below | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive_1 : Lean.Meta.Grind.Arith.CommRing.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof → Sort u} →
Lean.Meta.Grind.Arith.CommRing.EqCnstr → Sort (max 1 u) | null | false |
ImportGraph.Shake.instHTransClosureNeedsOfHierarchy | ImportGraph.Shake.Algebra | {H : Type u_1} →
[ImportGraph.Shake.Hierarchy H] → ImportGraph.Shake.HTransClosure H ImportGraph.Shake.Needs ImportGraph.Shake.Needs | null | true |
expChar_prime_iff | Mathlib.Algebra.CharP.Defs | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] {p : ℕ}, Nat.Prime p → (ExpChar R p ↔ CharP R p) | null | true |
Aesop.Index.instEmptyCollection | Aesop.Index | {α : Type} → EmptyCollection (Aesop.Index α) | null | true |
UniformFun.toFun_sum | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {ι : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {f : ι → α → β} (I : Finset ι),
UniformFun.toFun (∑ i ∈ I, f i) = ∑ i ∈ I, UniformFun.toFun (f i) | null | true |
CategoryTheory.Cat.freeMapIdIso._proof_2 | Mathlib.CategoryTheory.Category.Quiv | ∀ (V : Type u_1) [inst : Quiver V] {X Y : CategoryTheory.Paths V} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Cat.freeMap (𝟭q V)).map f)
(CategoryTheory.Iso.refl ((CategoryTheory.Cat.freeMap (𝟭q V)).obj Y)).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl ((CategoryTh... | null | false |
DirectLimit.instDivisionRing._proof_7 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
SSet.prodStdSimplex.isoNerve._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | ∀ (p q d : ℕ),
Function.LeftInverse
(fun s => ULift.orderIso.{u_1, 0}.toOrderEmbedding.toOrderHom.comp { toFun := s.obj, monotone' := ⋯ }) fun f =>
⋯.functor | null | false |
Cardinal.ord_le_type | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u} (r : α → α → Prop) [h : IsWellOrder α r], (Cardinal.mk α).ord ≤ Ordinal.type r | null | true |
Nat.pow._sunfold | Init.Prelude | ℕ → ℕ → ℕ | null | false |
_private.Mathlib.RingTheory.Unramified.Basic.0.Algebra.FormallyUnramified.lift_unique_of_ringHom._simp_1_1 | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {x y : R} [inst_1 : I.IsTwoSided],
((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) = (x - y ∈ I) | null | false |
finSuccEquiv_eq_some | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {i : Fin (n + 1)} {j : Fin n}, (finSuccEquiv n) i = some j ↔ i = j.succ | null | true |
Lean.Doc.Block.concat | Lean.DocString.Types | {i : Type u} → {b : Type v} → Array (Lean.Doc.Block i b) → Lean.Doc.Block i b | Multiple blocks, merged.
| true |
Std.Http.Protocol.H1.Reader._sizeOf_1 | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Reader dir → ℕ | null | false |
Std.Ric.forIn'_eq_ite_roc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Ric α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : LT α] [inst_3 : Std.PRange.Least? α]
[inst_4 : Std.PRange.UpwardEnumerable α] [inst_5 : Std.PRange.LawfulUpwardEnumerableLE α]
[inst_6 : Std.PRange.LawfulUpwardEnumerableLT α] [inst_7 : Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst... | null | true |
ProbabilityTheory.riskIncrease_comp_le | Mathlib.Probability.Decision.Risk.RiskIncrease | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓧' : Type u_3} {𝓨 : Type u_4} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓧' : MeasurableSpace 𝓧'} [inst : MeasurableSpace 𝓨] (ℓ : Θ → 𝓨 → ENNReal) (P : ProbabilityTheory.Kernel Θ 𝓧)
(π : MeasureTheory.Measure Θ) (η : ProbabilityTheory.Kernel 𝓧 𝓧') [ProbabilityTh... | **Data processing inequality** for the risk increase. | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts_supportsStmt._simp_1_5 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a' = a → p a) = p a' | null | false |
TopModuleCat.instPreservesLimitsTopCatForget₂ContinuousLinearMapIdCarrierContinuousMapCarrier | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u} [inst : Ring R] [inst_1 : TopologicalSpace R],
CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ (TopModuleCat R) TopCat) | null | true |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.Valid'.rotateL_lemma₃._proof_1_1 | Mathlib.Data.Ordmap.Ordset | ∀ {a b c : ℕ}, 3 * a ≤ b + c → b < 2 * c → a + b < 3 * c | null | false |
CategoryTheory.Precoverage.morphismProperty | Mathlib.CategoryTheory.Sites.MorphismProperty | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.Precoverage C → CategoryTheory.MorphismProperty C | The weakest morphism property satisfied by all morphisms in covering families. | true |
_private.Batteries.Util.ProofWanted.0.elabInstanceWanted.match_1 | Batteries.Util.ProofWanted | (motive : Option (Lean.TSyntax `Lean.Parser.Command.declId) → Sort u_1) →
(name? : Option (Lean.TSyntax `Lean.Parser.Command.declId)) →
((n : Lean.TSyntax `Lean.Parser.Command.declId) → motive (some n)) → (Unit → motive none) → motive name? | null | false |
List.Nodup.sublist | Init.Data.List.Pairwise | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₂.Nodup → l₁.Nodup | null | true |
_private.Mathlib.RingTheory.HahnSeries.Summable.0.HahnSeries.SummableFamily.instSMul._simp_1 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, (x ∈ Function.support f) = (f x ≠ 0) | null | false |
CategoryTheory.Localization.SmallShiftedHom.precompEquiv._proof_1 | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {M : Type u_1} [inst : AddMonoid M] {a : M}, a + 0 = a | null | false |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso._proof_8 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Mon (CategoryTheory.Functor C D)) ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Monoida... | null | false |
CategoryTheory.eqToHom_comp_heq | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y : C} (f : Y ⟶ X) (h : W = Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h) f ≍ f | null | true |
toIocDiv_mul_sub_self | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R), ↑(toIocDiv hp a b) * p - b = -toIocMod hp a b | null | true |
LinearIsometryEquiv.ofTop._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} [inst : Ring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
Set.Finite.isClopen_biInter | Mathlib.Topology.Clopen | ∀ {X : Type u} [inst : TopologicalSpace X] {Y : Type u_2} {s : Set Y},
s.Finite → ∀ {f : Y → Set X}, (∀ i ∈ s, IsClopen (f i)) → IsClopen (⋂ i ∈ s, f i) | null | true |
String.revSkip?_eq_revSkip?_toSlice | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.BackwardPattern pat] {s : String} {pos : s.Pos},
pos.revSkip? pat = Option.map String.Pos.ofToSlice (pos.toSlice.revSkip? pat) | null | true |
List.map_id_fun | Init.Data.List.Lemmas | ∀ {α : Type u_1}, List.map id = id | null | true |
AlgebraicGeometry.Proj.fromOfGlobalSections_preimage_basicOpen | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_1} {A : Type u} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {X : AlgebraicGeometry.Scheme} (f : A →+* ↑(X.presheaf.obj (Opposite.op ⊤)))
(hf : Ideal.map f (HomogeneousIdeal.irrelevant 𝒜).toIdeal = ⊤) {r : A} {n : ℕ},
0 < n →
r... | null | true |
SimpleGraph.sum.match_1.congr_eq_1 | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_1} {W : Type u_2} (motive : V ⊕ W → V ⊕ W → Sort u_3) (x x_1 : V ⊕ W)
(h_1 : (u v : V) → motive (Sum.inl u) (Sum.inl v)) (h_2 : (u v : W) → motive (Sum.inr u) (Sum.inr v))
(h_3 : (x x_2 : V ⊕ W) → motive x x_2) (u v : V),
x = Sum.inl u →
x_1 = Sum.inl v →
(match x, x_1 with
| Sum.i... | null | true |
Dioph.diophFn_comp | Mathlib.NumberTheory.Dioph | ∀ {α : Type} {n : ℕ} {f : Vector3 ℕ n → ℕ},
Dioph.DiophFn f →
∀ (g : Vector3 ((α → ℕ) → ℕ) n), VectorAllP Dioph.DiophFn g → Dioph.DiophFn fun v => f fun i => g i v | null | true |
Lean.Expr.isAppOrForallOfConst | Mathlib.Lean.Expr.Basic | Lean.Name → Lean.Expr → Bool | Returns `true` if `type` is an application of a constant `declName`, or a
forall with return type of the same form (i.e. of the form `∀ (x₀ : X₀) (x₁ : X₁) ⋯, declName ..`).
Runs `cleanupAnnotations` on `type` and `forallE` bodies, and ignores metadata in applications.
| true |
Algebra.IsAlgebraic.of_ringHom_of_comp_eq | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {S : Type u_1} {A : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R A] {B : Type u_2} [inst_4 : Ring B] [inst_5 : Algebra S B] {FRS : Type u_3} {FAB : Type u_4}
[inst_6 : FunLike FRS R S] [inst_7 : RingHomClass FRS R S] [inst_8 : FunLike FAB A B] [inst_9 : Ring... | null | true |
CategoryTheory.FreeBicategory.Hom₂.whisker_left.elim | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{motive :
{a b : CategoryTheory.FreeBicategory B} →
(a_1 a_2 : a ⟶ b) → CategoryTheory.FreeBicategory.Hom₂ a_1 a_2 → Sort u_1} →
{a b : CategoryTheory.FreeBicategory B} →
{a_1 a_2 : a ⟶ b} →
(t : CategoryTheory.FreeBicategory.Hom₂ a_1 a_... | null | false |
Lean.Data.AC.Expr.var.injEq | Init.Data.AC | ∀ (x x_1 : ℕ), (Lean.Data.AC.Expr.var x = Lean.Data.AC.Expr.var x_1) = (x = x_1) | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go_denote_eq._proof_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight | ∀ {w : ℕ} (distance curr idx : ℕ), idx < w → ¬w - 1 < w → False | null | false |
Lean.Compiler.LCNF.Code.setTag.elim | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
t.ctorIdx = 10 →
((fvarId : Lean.FVarId) →
(cidx : ℕ) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
... | null | false |
CategoryTheory.MonoidalCategory.selfLeftAction._proof_3 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (c d : C),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft c (CategoryTheory.CategoryStruct.id d) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj c d) | null | false |
LieSubalgebra.toLieSubmodule._proof_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(K : LieSubalgebra R L) {x : ↥K} {x_1 : L}, x_1 ∈ K.carrier → ⁅↑x, x_1⁆ ∈ K | null | false |
Mathlib.Meta.FunProp.Context.constToUnfold._default | Mathlib.Tactic.FunProp.Types | Std.TreeSet Lean.Name Lean.Name.quickCmp | null | false |
OnePoint.isBoundedAt_infty_iff | Mathlib.NumberTheory.ModularForms.BoundedAtCusp | ∀ {f : UpperHalfPlane → ℂ} {k : ℤ}, OnePoint.infty.IsBoundedAt f k ↔ UpperHalfPlane.IsBoundedAtImInfty f | null | true |
Submodule.span_eq_span | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s t : Set M},
s ⊆ ↑(Submodule.span R t) → t ⊆ ↑(Submodule.span R s) → Submodule.span R s = Submodule.span R t | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.inner_eq_neg_mul_norm_of_angle_eq_pi._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
inner ℝ x y = Real.cos (InnerProductGeometry.angle x y) * (‖x‖ * ‖y‖) | null | false |
_private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.slash_mul | Mathlib.NumberTheory.ModularForms.SlashActions | ∀ (k : ℤ) (A B : GL (Fin 2) ℝ) (f : UpperHalfPlane → ℂ),
ModularForm.privateSlash✝ k (A * B) f = ModularForm.privateSlash✝ k B (ModularForm.privateSlash✝ k A f) | null | true |
NNReal.le_add_nndist | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ (a b : NNReal), a ≤ b + nndist a b | null | true |
CategoryTheory.Limits.CatCospanTransform.isIso_base | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆}
[inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheor... | null | true |
not_denseRange_zpow | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : LinearOrder G] [IsOrderedMonoid G]
[OrderTopology G] [Nontrivial G] [DenselyOrdered G] {a : G}, ¬DenseRange fun x => a ^ x | In a nontrivial densely linearly ordered commutative group,
the integer powers of an element can't be dense. | true |
_private.Mathlib.Tactic.FunProp.Mor.0.Mathlib.Meta.FunProp.Mor.withApp.go.match_3 | Mathlib.Tactic.FunProp.Mor | (motive : Lean.Expr → Array Mathlib.Meta.FunProp.Mor.Arg → Sort u_1) →
(x : Lean.Expr) →
(x_1 : Array Mathlib.Meta.FunProp.Mor.Arg) →
((data : Lean.MData) →
(b : Lean.Expr) → (as : Array Mathlib.Meta.FunProp.Mor.Arg) → motive (Lean.Expr.mdata data b) as) →
((c f x : Lean.Expr) → (as : Arra... | null | false |
Pi.Lex.le_sInf_apply | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedLT ι] {s : Set (Lex ((i : ι) → (fun i => α i) i))} {i : ι}
{e : Lex ((i : ι) → (fun i => α i) i)}, (∀ f ∈ s, (∀ j < i, f j = sInf s j) → e i ≤ f i) → e i ≤ sInf s i | null | true |
CategoryTheory.Limits.limitBiconeOfUnique | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[Unique J] → (f : J → C) → CategoryTheory.Limits.LimitBicone f | The limit bicone for the biproduct over an index type with exactly one term. | true |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.rank'_lt_rankMax.go.match_1 | Batteries.Data.UnionFind.Basic | ∀ (motive : (x : List Batteries.UFNode) → (x_1 : Batteries.UFNode) → x_1 ∈ x → Prop) (x : List Batteries.UFNode)
(x_1 : Batteries.UFNode) (x_2 : x_1 ∈ x),
(∀ (a : Batteries.UFNode) (l : List Batteries.UFNode), motive (a :: l) a ⋯) →
(∀ (a : Batteries.UFNode) (l : List Batteries.UFNode) (a_1 : Batteries.UFNode) ... | null | false |
ShareCommonM.run | Init.ShareCommon | {σ : ShareCommon.StateFactory} → {α : Type u_1} → ShareCommonM σ α → α | null | true |
MonCat.FilteredColimits.colimitMulAux_eq_of_rel_left | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J] {x x' y : (j : J) × ↑(F.obj j)},
CategoryTheory.Limits.Types.FilteredColimit.Rel (F.comp (CategoryTheory.forget MonCat)) x x' →
MonCat.FilteredColimits.colimitMulAux F x y = MonCat... | Multiplication in the colimit is well-defined in the left argument. | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.RxoIterator.instFinitenessRelation._proof_2 | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] {it it' : Std.IterM Id ((a : α) × β a)},
it'.IsPlausibleSuccessorOf it →
Std.DTreeMap.Internal.Zipper.size✝ it'.internalState.iter < Std.DTreeMap.Internal.Zipper.size✝ it.internalState.iter | null | false |
OrdinalApprox.lfpApprox_of_isSuccLimit | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {x : α} {a : Ordinal.{u}},
Order.IsSuccLimit a → OrdinalApprox.lfpApprox f x a = ⨆ b, OrdinalApprox.lfpApprox f x ↑b | null | true |
TopologicalSpace.encodableCountableBasis | Mathlib.Topology.Bases | (α : Type u) →
[t : TopologicalSpace α] → [inst : SecondCountableTopology α] → Encodable ↑(TopologicalSpace.countableBasis α) | null | true |
ContinuousLinearMap.compLeftContinuousBounded._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ (α : Type u_1) {β : Type u_3} {γ : Type u_2} {𝕜 : Type u_4} [inst : TopologicalSpace α]
[inst_1 : SeminormedAddCommGroup β] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 β]
[inst_4 : SeminormedAddCommGroup γ] [inst_5 : NormedSpace 𝕜 γ] (g : β →L[𝕜] γ) (c : 𝕜)
(f : BoundedContinuousFunction ... | null | false |
ConjAct.unitsMulDistribMulAction._proof_4 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {M : Type u_1} [inst : Monoid M] (r : ConjAct Mˣ) (x y : M), r • (x * y) = r • x * r • y | null | false |
_private.Plausible.Random.0.Plausible.Random.instBoundedRandomNat._proof_3 | Plausible.Random | ∀ (lo hi : ℕ), lo ≤ hi → ∀ (z : Fin (hi - lo).succ), ¬lo + ↑z ≤ hi → False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.