name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Equiv.Set.univ.match_1 | Mathlib.Logic.Equiv.Set | ∀ (α : Type u_1) (motive : ↑Set.univ → Prop) (x : ↑Set.univ),
(∀ (val : α) (property : val ∈ Set.univ), motive ⟨val, property⟩) → motive x | false |
CategoryTheory.Oplax.StrongTrans.Modification.vcomp_app | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ ι : F ⟶ G} (Γ : CategoryTheory.Oplax.StrongTrans.Modification η θ)
(Δ : CategoryTheory.Oplax.StrongTrans.Modification θ ι) (a : B),
(Γ.vcomp Δ).app a = CategoryThe... | true |
TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivFunctor_obj_pt | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasProducts C] {X : TopCat}
(F : TopCat.Presheaf C X) {ι : Type v'} (U : ι → TopologicalSpace.Opens ↑X)
(c : CategoryTheory.Limits.Cone ((CategoryTheory.Pairwise.diagram U).op.comp F)),
((TopCat.Presheaf.SheafConditionPairwis... | true |
CategoryTheory.SpectralSequence.pageXIsoOfEq._proof_1 | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C] {κ : Type u_3}
{c : ℤ → ComplexShape κ} {r₀ : ℤ} (E : CategoryTheory.SpectralSequence C c r₀) (pq : κ) (r r' : ℤ) (h : r = r')
(hr : r₀ ≤ r), (E.page r ⋯).X pq = (E.page r' ⋯).X pq | false |
subtypeOrEquiv_symm_inr | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} (p q : α → Prop) [inst : DecidablePred p] (h : Disjoint p q) (x : { x // q x }),
(subtypeOrEquiv p q h).symm (Sum.inr x) = ⟨↑x, ⋯⟩ | true |
instFaithfulSMulMulOppositeOfIsLeftCancelMul | Mathlib.Algebra.Group.Action.Faithful | ∀ (R : Type u_4) [inst : Mul R] [IsLeftCancelMul R], FaithfulSMul Rᵐᵒᵖ R | true |
LeftCommutative | Mathlib.Logic.OpClass | {α : Sort u} → {β : Sort v} → (α → β → β) → Prop | true |
_private.Mathlib.LinearAlgebra.FreeModule.PID.0.Module.Basis.SmithNormalForm.repr_apply_embedding_eq_repr_smul._simp_1_2 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | false |
Subrel.relEmbedding._proof_1 | Mathlib.Order.RelIso.Set | ∀ {α : Type u_1} (r : α → α → Prop) (p : α → Prop) {a b : Subtype p},
r ((Function.Embedding.subtype p) a) ((Function.Embedding.subtype p) b) ↔
r ((Function.Embedding.subtype p) a) ((Function.Embedding.subtype p) b) | false |
MeasureTheory.quasiMeasurePreserving_neg_add_swap | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd₂ G] (μ ν : MeasureTheory.Measure G)
[MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] [MeasurableNeg G] [μ.IsAddLeftInvariant],
MeasureTheory.Measure.QuasiMeasurePreserving (fun p => -p.2 + p.1) (μ.prod ν) μ | true |
Profinite.NobelingProof.union_C0C1_eq | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}}
(ho : o < Ordinal.type fun x1 x2 => x1 < x2), Profinite.NobelingProof.C0 C ho ∪ Profinite.NobelingProof.C1 C ho = C | true |
FreeGroup.toWord_eq_nil_iff | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] {x : FreeGroup α}, x.toWord = [] ↔ x = 1 | true |
Lean.Meta.SynthInstance.Waiter.root.sizeOf_spec | Lean.Meta.SynthInstance | sizeOf Lean.Meta.SynthInstance.Waiter.root = 1 | true |
Polynomial.natDegree_mul | Mathlib.Algebra.Polynomial.Degree.Domain | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R},
p ≠ 0 → q ≠ 0 → (p * q).natDegree = p.natDegree + q.natDegree | true |
MulAction.IsPretransitive | Mathlib.Algebra.Group.Action.Pretransitive | (M : Type u_5) → (α : Type u_6) → [SMul M α] → Prop | true |
Lean.Server.Watchdog.FileWorker.exitCode | Lean.Server.Watchdog | Lean.Server.Watchdog.FileWorker → Std.Mutex (Option UInt32) | true |
instInhabitedFilterBasisNat | Mathlib.Order.Filter.Bases.Basic | Inhabited (FilterBasis ℕ) | true |
OrderedFinpartition.mk.inj | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n length : ℕ} {partSize : Fin length → ℕ} {partSize_pos : ∀ (m : Fin length), 0 < partSize m}
{emb : (m : Fin length) → Fin (partSize m) → Fin n} {emb_strictMono : ∀ (m : Fin length), StrictMono (emb m)}
{parts_strictMono : StrictMono fun m => emb m ⟨partSize m - 1, ⋯⟩}
{disjoint : Set.univ.PairwiseDisjoint fu... | true |
AlgebraicGeometry.Scheme.kerAdjunction | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | (Y : AlgebraicGeometry.Scheme) → (AlgebraicGeometry.Scheme.IdealSheafData.subschemeFunctor Y).rightOp ⊣ Y.kerFunctor | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.code.takeContentsFn | Lean.DocString.Parser | ℕ → Lean.Parser.ParserContext → Lean.Parser.ParserState → Lean.Parser.ParserState | true |
UInt8.ofBitVec_and | Init.Data.UInt.Bitwise | ∀ (a b : BitVec 8), { toBitVec := a &&& b } = { toBitVec := a } &&& { toBitVec := b } | true |
ProbabilityTheory.complexMGF_mul_I | Mathlib.Probability.Moments.ComplexMGF | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
AEMeasurable X μ →
∀ (t : ℝ),
ProbabilityTheory.complexMGF X μ (↑t * Complex.I) = MeasureTheory.charFun (MeasureTheory.Measure.map X μ) t | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Basic.0.SimpleGraph.Walk.snd_darts_getElem._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} {i : ℕ}, i < p.darts.length → i < p.darts.length | false |
sup_eq_sup_iff_right | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, a ⊔ c = b ⊔ c ↔ a ≤ b ⊔ c ∧ b ≤ a ⊔ c | true |
IsDedekindDomain.HeightOneSpectrum.valuation._proof_2 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R),
∀ r ∈ nonZeroDivisors R, r ∈ (↑v.intValuation.supp)ᶜ | false |
RootPairing.Base.coroot_mem_span_int | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (b : P.Base) (i : ι),
P.coroot i ∈ Submodule.span ℤ (⇑P.coroot '' ↑b.support) | true |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Presentation.Expr.2260322628._hygCtx._hyg.1.rec | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} →
((name userName html : Lean.Json) → motive { name := name, userName := userName, html := html }) →
(t : ProofWidgets.RpcEncodablePacket✝) → motive t | false |
_private.Mathlib.Tactic.IntervalCases.0.Mathlib.Tactic._aux_Mathlib_Tactic_IntervalCases___elabRules_Mathlib_Tactic_intervalCases_1._sparseCasesOn_17 | Mathlib.Tactic.IntervalCases | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
HahnEmbedding.ArchimedeanStrata.recOn | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
... | false |
_private.Mathlib.Data.List.Basic.0.List.length_eq_three.match_1_1 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (motive : (l : List α) → l.length = 3 → Prop) (l : List α) (x : l.length = 3),
(∀ (a b c : α) (x : [a, b, c].length = 3), motive [a, b, c] x) → motive l x | false |
Module.Relations.Solution.ofπ'.eq_1 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (π : (relations.G →₀ A) →ₗ[A] M) (hπ : π ∘ₗ relations.map = 0),
Module.Relations.Solution.ofπ' π hπ = Module.Relations.Solution.ofπ π ⋯ | true |
WeierstrassCurve.Affine.Equation.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve.Affine R) (x y : R),
W.Equation x y = (Polynomial.evalEval x y W.polynomial = 0) | true |
Lean.Meta.AltVarNames.mk.inj | Lean.Meta.Tactic.Induction | ∀ {explicit : Bool} {varNames : List Lean.Name} {explicit_1 : Bool} {varNames_1 : List Lean.Name},
{ explicit := explicit, varNames := varNames } = { explicit := explicit_1, varNames := varNames_1 } →
explicit = explicit_1 ∧ varNames = varNames_1 | true |
_private.Init.Data.List.Nat.Basic.0.List.getElem_intersperse._proof_1_1 | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {l : List α} {sep : α} {i : ℕ}, i % 2 = 0 → ¬i = 2 * (i / 2) → False | false |
Algebra.algebraMap_intNorm_fractionRing | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ {A : Type u_1} {B : Type u_6} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[inst_3 : IsIntegrallyClosed A] [inst_4 : IsDomain A] [inst_5 : IsDomain B] [inst_6 : IsIntegrallyClosed B]
[inst_7 : Algebra.IsIntegral A B] [inst_8 : Module.IsTorsionFree A B] (x : B),
(algebraMap A (FractionRing A)... | true |
CategoryTheory.FreeMonoidalCategory.inclusionObj | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} → CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → CategoryTheory.FreeMonoidalCategory C | true |
ZMod.toAddCircle_inj | Mathlib.Topology.Instances.AddCircle.Real | ∀ {N : ℕ} [inst : NeZero N] {j k : ZMod N}, ZMod.toAddCircle j = ZMod.toAddCircle k ↔ j = k | true |
Subalgebra.bot_eq_top_iff_finrank_eq_one | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {F : Type u_1} {E : Type u_2} [inst : CommRing F] [StrongRankCondition F] [inst_2 : Ring E] [inst_3 : Algebra F E]
[Nontrivial E] [Module.Free F E], ⊥ = ⊤ ↔ Module.finrank F E = 1 | true |
Lean.ShareCommon.PShareCommonM.run | Lean.Util.ShareCommon | {α : Type u_1} → Lean.ShareCommon.PShareCommonM α → α | true |
CategoryTheory.Functor.rightDerivedUnique.congr_simp | Mathlib.CategoryTheory.Functor.Derived.PointwiseRightDerived | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_2} D] [inst_2 : CategoryTheory.Category.{v_5, u_3} H]
(RF RF' : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α α_1 : F ⟶ L.comp R... | true |
CategoryTheory.Limits.ReflectsLimitsOfShape.mk | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {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},
autoParam (∀ {K : CategoryTheory.Functor J C}, CategoryTheory.Limits.ReflectsLimit K F)
CategoryTh... | true |
Lean.Lsp.instToJsonRpcKeepAliveParams.toJson | Lean.Data.Lsp.Extra | Lean.Lsp.RpcKeepAliveParams → Lean.Json | true |
ImplicitFunctionData.map_implicitFunction_nhdsWithin_preimage | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 :... | true |
String.Slice.instInhabitedRevPosIterator | Init.Data.String.Iterate | {a : String.Slice} → Inhabited a.RevPosIterator | true |
Module.End.invtSubmodule.map_subtype_mem_of_mem_invtSubmodule | Mathlib.Algebra.Module.Submodule.Invariant | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f : Module.End R M) {p : Submodule R M} (hp : p ∈ f.invtSubmodule) {q : Submodule R ↥p},
q ∈ Module.End.invtSubmodule (LinearMap.restrict f hp) → Submodule.map p.subtype q ∈ f.invtSubmodule | true |
_private.Mathlib.LinearAlgebra.Basis.Exact.0.Submodule.top_le_span_of_exact_of_retraction._simp_1_1 | Mathlib.LinearAlgebra.Basis.Exact | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b = (a ⊔ b = ⊤) | false |
Submonoid.pow_mem | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_5} [inst : Monoid M] (S : Submonoid M) {x : M}, x ∈ S → ∀ (n : ℕ), x ^ n ∈ S | true |
Array.eq_empty_of_size_eq_zero | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, xs.size = 0 → xs = #[] | true |
fderiv_pow_ring | Mathlib.Analysis.Calculus.FDeriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedCommRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {x : 𝔸} (n : ℕ),
fderiv 𝕜 (fun x => x ^ n) x = (n • x ^ (n - 1)) • ContinuousLinearMap.id 𝕜 𝔸 | true |
String.Pos.next_eq_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} {p q : s.Pos} {h : p ≠ s.endPos}, p.next h = q ↔ p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q' | true |
CategoryTheory.Bicategory.LeftLift.homMk.congr_simp | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
{s t : CategoryTheory.Bicategory.LeftLift f g} (η η_1 : s.lift ⟶ t.lift) (e_η : η = η_1)
(w : CategoryTheory.CategoryStruct.comp s.unit (CategoryTheory.Bicategory.whiskerRight η f) = t.unit),
CategoryTheory.Bicategory.LeftLift... | true |
not_bddAbove_univ | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] [NoTopOrder α], ¬BddAbove Set.univ | true |
IsCommJordan.lmul_comm_rmul_rmul | Mathlib.Algebra.Jordan.Basic | ∀ {A : Type u_1} {inst : CommMagma A} [self : IsCommJordan A] (a b : A), a * b * (a * a) = a * (b * (a * a)) | true |
_private.Aesop.Util.EqualUpToIds.0.Aesop.EqualUpToIds.Unsafe.exprsEqualUpToIdsCore₃.compareMVarValues._sparseCasesOn_4 | Aesop.Util.EqualUpToIds | {motive : Aesop.EqualUpToIds.MVarValue → Sort u} →
(t : Aesop.EqualUpToIds.MVarValue) →
((e : Lean.Expr) → motive (Aesop.EqualUpToIds.MVarValue.expr e)) →
((mvarId : Lean.MVarId) → motive (Aesop.EqualUpToIds.MVarValue.mvarId mvarId)) →
(Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | false |
ComputeAsymptotics.MultiseriesExpansion.Multiseries.map.eq_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : ComputeAsymptotics.Basis} {basis_hd' : ℝ → ℝ} {basis_tl' : ComputeAsymptotics.Basis}
(f : ℝ → ℝ) (g : ComputeAsymptotics.MultiseriesExpansion basis_tl → ComputeAsymptotics.MultiseriesExpansion basis_tl')
(ms : ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl),
... | true |
Matroid.disjointSigma_isBasis_iff._simp_1 | Mathlib.Combinatorics.Matroid.Sum | ∀ {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} {h : Pairwise (Function.onFun Disjoint fun i => (M i).E)}
{I X : Set α},
(Matroid.disjointSigma M h).IsBasis I X =
((∀ (i : ι), (M i).IsBasis (I ∩ (M i).E) (X ∩ (M i).E)) ∧ I ⊆ X ∧ X ⊆ ⋃ i, (M i).E) | false |
CategoryTheory.Mat_.embeddingLiftIso._proof_6 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
... | false |
Array.reverse_eq_empty_iff._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, (xs.reverse = #[]) = (xs = #[]) | false |
CategoryTheory.Under | Mathlib.CategoryTheory.Comma.Over.Basic | {T : Type u₁} → [CategoryTheory.Category.{v₁, u₁} T] → T → Type (max u₁ v₁) | true |
instIsUpperProp | Mathlib.Topology.Order.LowerUpperTopology | Topology.IsUpper Prop | true |
ISize.toInt16 | Init.Data.SInt.Basic | ISize → Int16 | true |
NonUnitalRingHom.instNonUnitalRingHomClass | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : NonUnitalNonAssocSemiring α] [inst_1 : NonUnitalNonAssocSemiring β],
NonUnitalRingHomClass (α →ₙ+* β) α β | true |
LieSubalgebra.span_union | Mathlib.Algebra.Lie.Subalgebra | ∀ (R : Type u) {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (s t : Set L),
LieSubalgebra.lieSpan R L (s ∪ t) = LieSubalgebra.lieSpan R L s ⊔ LieSubalgebra.lieSpan R L t | true |
BoolAlg.Hom | Mathlib.Order.Category.BoolAlg | BoolAlg → BoolAlg → Type u | true |
Sublattice.ext | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L M : Sublattice α}, (∀ (a : α), a ∈ L ↔ a ∈ M) → L = M | true |
AlgebraicGeometry.Scheme.Pullback.cocycle_fst_snd | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j k : 𝒰.I₀),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k)
(CategoryTheory.... | true |
_private.Mathlib.Topology.UniformSpace.Ascoli.0.EquicontinuousOn.isClosed_range_pi_of_uniformOnFun'._simp_1_3 | Mathlib.Topology.UniformSpace.Ascoli | ∀ {α : Type u_1} {β : Type u_2} (f : α → β), Filter.principal (Set.range f) = Filter.map f ⊤ | false |
Mathlib.Tactic.LibraryRewrite.getHypotheses | Mathlib.Tactic.Widget.LibraryRewrite | Option Lean.FVarId → Lean.MetaM (Lean.Meta.RefinedDiscrTree (Lean.FVarId × Bool)) | true |
Std.Http.URI.Builder.setHost! | Std.Internal.Http.Data.URI.Basic | Std.Http.URI.Builder → String → Std.Http.URI.Builder | true |
Lean.Meta.RefinedDiscrTree.MatchResult | Mathlib.Lean.Meta.RefinedDiscrTree.Lookup | Type → Type | true |
CategoryTheory.Limits.isPushout_map_codiagonal | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasPushouts C]
{S T : C} (f : T ⟶ X) (g : T ⟶ Y) (i : S ⟶ T),
CategoryTheory.IsPushout
(CategoryTheory.Limits.pushout.map i i (CategoryTheory.CategoryStruct.comp i f)
(CategoryTheory.CategoryStruct.com... | true |
IsUnit.inv_mul_eq_inv_mul_iff | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : DivisionCommMonoid α] {a b c d : α}, IsUnit b → IsUnit d → (b⁻¹ * a = d⁻¹ * c ↔ a * d = c * b) | true |
Ordinal.IsAcc.forall_lt | Mathlib.SetTheory.Ordinal.Topology | ∀ {o : Ordinal.{u_1}} {S : Set Ordinal.{u_1}}, o.IsAcc S → ∀ p < o, (S ∩ Set.Ioo p o).Nonempty | true |
CategoryTheory.Subobject.subobjectOrderIso._proof_13 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X : C} (Y : CategoryTheory.Subobject X)
(Z : ↑(Set.Iic Y)),
CategoryTheory.Subobject.mk
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.mk ((↑Z).ofLE Y ⋯)).arrow Y.arrow) ∈
Set.Iic Y | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.ProperAction.0.UpperHalfPlane.cdsq_le.match_1_1 | Mathlib.Analysis.Complex.UpperHalfPlane.ProperAction | ∀ {K : Set UpperHalfPlane} (motive : (∃ x ∈ K, IsMinOn UpperHalfPlane.im K x) → Prop)
(x : ∃ x ∈ K, IsMinOn UpperHalfPlane.im K x),
(∀ (z : UpperHalfPlane) (left : z ∈ K) (h : IsMinOn UpperHalfPlane.im K z), motive ⋯) → motive x | false |
limsup_add_const | Mathlib.Topology.Algebra.Order.LiminfLimsup | ∀ {ι : Type u_1} {R : Type u_4} [inst : ConditionallyCompleteLinearOrder R] [inst_1 : TopologicalSpace R]
[OrderTopology R] (F : Filter ι) [F.NeBot] [inst_4 : Add R] [ContinuousAdd R] [AddRightMono R] (f : ι → R) (c : R),
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) F f →
Filter.IsCoboundedUnder (fun x1 x2 => x... | true |
Lean.Lsp.CreateFile.Options.mk | Lean.Data.Lsp.Basic | Bool → Bool → Lean.Lsp.CreateFile.Options | true |
OrderIso.image_Ioo | Mathlib.Order.Interval.Set.OrderIso | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (a b : α),
⇑e '' Set.Ioo a b = Set.Ioo (e a) (e b) | true |
FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra | Mathlib.Algebra.Lie.Free | (R : Type u) →
(X : Type v) → [inst : CommRing R] → UniversalEnvelopingAlgebra R (FreeLieAlgebra R X) ≃ₐ[R] FreeAlgebra R X | true |
Matrix.Pivot.mul_listTransvecRow_last_col | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {𝕜 : Type u_3} [inst : Field 𝕜] {r : ℕ} (M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜) (i : Fin r ⊕ Unit),
(M * (Matrix.Pivot.listTransvecRow M).prod) i (Sum.inr ()) = M i (Sum.inr ()) | true |
_private.Mathlib.Analysis.Polynomial.Basic.0.Polynomial.div_tendsto_atTop_zero_iff_degree_lt._simp_1_1 | Mathlib.Analysis.Polynomial.Basic | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) | false |
Rack.PreEnvelGroupRel'.inhabited | Mathlib.Algebra.Quandle | (R : Type u) → [inst : Rack R] → Inhabited (Rack.PreEnvelGroupRel' R Rack.PreEnvelGroup.unit Rack.PreEnvelGroup.unit) | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.someExistsOneDivLT_lt.match_1_1 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α}
(motive :
MeasureTheory.SignedMeasure.someExistsOneDivLT✝ s i ⊆ i ∧
MeasurableSet (MeasureTheory.SignedMeasure.someExistsOneDivLT✝ s i) ∧
1 / (↑(MeasureTheory.SignedMeasure.findExistsOneDivLT✝ s i) + 1) <... | false |
ContinuousMap.instVAddCommClass | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_3} {R₁ : Type u_4} {M : Type u_5} [inst_1 : TopologicalSpace M]
[inst_2 : VAdd R M] [inst_3 : ContinuousConstVAdd R M] [inst_4 : VAdd R₁ M] [inst_5 : ContinuousConstVAdd R₁ M]
[VAddCommClass R R₁ M], VAddCommClass R R₁ C(α, M) | true |
_private.Mathlib.Geometry.Manifold.Algebra.Monoid.0.contMDiff_pow._simp_1_3 | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | false |
Mul.toSMulMulOpposite.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ (α : Type u_9) [inst : Mul α], Mul.toSMulMulOpposite α = { smul := fun a b => b * MulOpposite.unop a } | true |
normFromConst | Mathlib.Analysis.Normed.Unbundled.SeminormFromConst | {K : Type u_1} → [inst : Field K] → {k : K} → {g : RingSeminorm K} → g 1 ≤ 1 → g k ≠ 0 → IsPowMul ⇑g → RingNorm K | true |
Lean.NameSet.insert | Lean.Data.NameMap.Basic | Lean.NameSet → Lean.Name → Lean.NameSet | true |
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.MvPolynomial.schwartz_zippel_sup_sum._simp_1_7 | Mathlib.Algebra.MvPolynomial.SchwartzZippel | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | false |
AlgebraicGeometry.IsAffineHom.recOn | Mathlib.AlgebraicGeometry.Morphisms.Affine | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsAffineHom f → Sort u} →
(t : AlgebraicGeometry.IsAffineHom f) →
((isAffine_preimage :
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U →
AlgebraicGeometry.IsAffineOpen ((To... | false |
Lean.Grind.AC.Seq.concat._sunfold | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | false |
LinearEquiv.coe_pow | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (e : M ≃ₗ[R] M)
(n : ℕ), ⇑(e ^ n) = (⇑e)^[n] | true |
AlgEquiv.toAlgHom._proof_2 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_3} {A₁ : Type u_2} {A₂ : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂), e 0 = 0 | false |
Module.Presentation.tautological.R.ctorIdx | Mathlib.Algebra.Module.Presentation.Tautological | {A : Type u} → {M : Type v} → Module.Presentation.tautological.R A M → ℕ | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.statement._proof_1_7 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {n : ℕ} (R : Type u_1) [inst : CommRing R] (c : ChevalleyThm.PolynomialC.InductionObj✝ R n) (i j : Fin n),
ChevalleyThm.PolynomialC.InductionObj.degBound✝
{
val :=
Function.update (ChevalleyThm.PolynomialC.InductionObj.val✝ c) j
(ChevalleyThm.PolynomialC.InductionObj.val✝... | false |
HomotopicalAlgebra.FibrantObject.instWeakEquivalenceWWeakEquivalences | Mathlib.AlgebraicTopology.ModelCategory.DerivabilityStructureFibrant | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X : C}
(R : (HomotopicalAlgebra.FibrantObject.localizerMorphism C).RightResolution X), HomotopicalAlgebra.WeakEquivalence R.w | true |
Pi.apply_mulSingle | Mathlib.Algebra.Notation.Pi.Basic | ∀ {ι : Type u_1} {M : ι → Type u_6} {N : ι → Type u_7} [inst : (i : ι) → One (M i)] [inst_1 : (i : ι) → One (N i)]
[inst_2 : DecidableEq ι] (f' : (i : ι) → M i → N i),
(∀ (i : ι), f' i 1 = 1) → ∀ (i : ι) (x : M i) (j : ι), f' j (Pi.mulSingle i x j) = Pi.mulSingle i (f' i x) j | true |
CategoryTheory.Limits.PreservesTerminal.iso | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Terminal | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor C D) →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
[inst_3 : CategoryTheory.Limits.HasTerminal D] →
[Cate... | true |
Asymptotics.IsBigOWith.prod_left_fst | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E' : Type u_6} {F' : Type u_7} {G' : Type u_8} [inst : SeminormedAddCommGroup E']
[inst_1 : SeminormedAddCommGroup F'] [inst_2 : SeminormedAddCommGroup G'] {c : ℝ} {f' : α → E'} {g' : α → F'}
{k' : α → G'} {l : Filter α}, Asymptotics.IsBigOWith c l (fun x => (f' x, g' x)) k' → Asymptotics.IsBigOWi... | true |
ISize.toInt_minValue_le | Init.Data.SInt.Lemmas | ISize.minValue.toInt ≤ -2 ^ 31 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.