name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Parser.patternIgnore.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | true |
Std.Sat.CNF.emptyWithCapacity.eq_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} (n : ℕ), Std.Sat.CNF.emptyWithCapacity n = { clauses := Array.emptyWithCapacity n } | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0._regBuiltin.Char.reduceToLower.declare_18._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.334306140._hygCtx._hyg.13 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | false |
AdicCompletion.instSMulQuotientIdealHSMulTopSubmodule | Mathlib.RingTheory.AdicCompletion.Algebra | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) → {M : Type u_3} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → SMul (R ⧸ I • ⊤) (M ⧸ I • ⊤) | true |
Equiv.sigmaSumDistrib_symm_apply | Mathlib.Logic.Equiv.Sum | ∀ {ι : Type u_11} (α : ι → Type u_9) (β : ι → Type u_10) (a : (i : ι) × α i ⊕ (i : ι) × β i),
(Equiv.sigmaSumDistrib α β).symm a = Sum.elim (Sigma.map id fun x => Sum.inl) (Sigma.map id fun x => Sum.inr) a | true |
Function.Surjective.mulActionLeft._proof_2 | Mathlib.Algebra.Group.Action.Hom | ∀ {R : Type u_3} {S : Type u_2} {M : Type u_1} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : Monoid S]
[inst_3 : SMul S M] (f : R →* S), (∀ (c : R) (x : M), f c • x = c • x) → ∀ (b : M), 1 • b = b | false |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.IsStoppingTime.measurableSet_le'._simp_1_1 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
SimpleGraph.Iso.boxProdSumDistrib | Mathlib.Combinatorics.SimpleGraph.Prod | {V : Type u_4} →
{W₁ : Type u_8} →
{W₂ : Type u_9} →
(G : SimpleGraph V) → (H₁ : SimpleGraph W₁) → (H₂ : SimpleGraph W₂) → G □ (H₁ ⊕g H₂) ≃g G □ H₁ ⊕g G □ H₂ | true |
ModuleCat.ExtendScalars.obj' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} → {S : Type u₂} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → ModuleCat R → ModuleCat S | true |
_private.Mathlib.FieldTheory.RatFunc.AsPolynomial.0.Polynomial.valuation_le_one_of_valuation_X_le_one._simp_1_3 | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] {a : M}, a ≤ 1 → ∀ (n : ℕ), (a ^ n ≤ 1) = True | false |
Plausible.Testable.orTestable.match_1 | Plausible.Testable | {p : Prop} →
(motive : Plausible.TestResult p → Sort u_1) →
(xp : Plausible.TestResult p) →
((h : Unit) → motive (Plausible.TestResult.success (PSum.inl h))) →
((h : p) → motive (Plausible.TestResult.success (PSum.inr h))) →
((x : Plausible.TestResult p) → motive x) → motive xp | false |
Lean.Grind.AC.eq_norm_a_cert.eq_1 | Init.Grind.AC | ∀ (lhs rhs : Lean.Grind.AC.Expr) (lhs' rhs' : Lean.Grind.AC.Seq),
Lean.Grind.AC.eq_norm_a_cert lhs rhs lhs' rhs' = (lhs.toSeq.beq' lhs').and' (rhs.toSeq.beq' rhs') | true |
CategoryTheory.NatIso.removeOp._proof_4 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] {F G : CategoryTheory.Functor C D} (α : F.op ≅ G.op),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.removeOp α.inv) (CategoryTheory.NatTrans.removeOp α.hom) =
CategoryTheor... | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.accLevelAtCtor.match_1 | Lean.Elab.MutualInductive | (motive : Except Lean.MessageData Unit → Sort u_1) →
(__do_lift : Except Lean.MessageData Unit) →
((a : Unit) → motive (Except.ok a)) → ((msg : Lean.MessageData) → motive (Except.error msg)) → motive __do_lift | false |
Batteries.Tactic.TransRelation.ctorElimType | Batteries.Tactic.Trans | {motive : Batteries.Tactic.TransRelation → Sort u} → ℕ → Sort (max 1 u) | false |
_private.Mathlib.Algebra.Order.Group.DenselyOrdered.0.exists_nsmul_lt_of_pos.match_1_1 | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive x | false |
deltaGenerated_le | Mathlib.Topology.Compactness.DeltaGeneratedSpace | ∀ {X : Type u_1} [tX : TopologicalSpace X], TopologicalSpace.deltaGenerated X ≤ tX | true |
CategoryTheory.Limits.ImageFactorisation.ofIsoI | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
(F : CategoryTheory.Limits.ImageFactorisation f) →
{I' : C} → (F.F.I ≅ I') → CategoryTheory.Limits.ImageFactorisation f | true |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.HtmlDisplay.3304690324._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.HtmlDisplay | {P : Sort u} →
{t t' : ProofWidgets.RpcEncodablePacket✝} →
t = t' →
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.HtmlDisplay.3304690324._hygCtx._hyg.1.noConfusionType
P t t' | false |
Turing.PointedMap.mk._flat_ctor | Mathlib.Computability.TuringMachine.Tape | {Γ : Type u} →
{Γ' : Type v} →
[inst : Inhabited Γ] → [inst_1 : Inhabited Γ'] → (f : Γ → Γ') → f default = default → Turing.PointedMap Γ Γ' | false |
MonomialOrder.lex | Mathlib.Data.Finsupp.MonomialOrder | {σ : Type u_1} → [inst : LinearOrder σ] → [WellFoundedGT σ] → MonomialOrder σ | true |
_private.Mathlib.Analysis.SpecialFunctions.Bernstein.0._aux_Mathlib_Analysis_SpecialFunctions_Bernstein___unexpand_bernstein_z_1 | Mathlib.Analysis.SpecialFunctions.Bernstein | Lean.PrettyPrinter.Unexpander | false |
CategoryTheory.CostructuredArrow.ext_iff | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {S : CategoryTheory.Functor C D} {A B : CategoryTheory.CostructuredArrow S T} (f g : A ⟶ B),
f = g ↔ f.left = g.left | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.matiyasevic.match_1_9 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (y u : ℕ) (motive : { k // k ≡ a [MOD u] ∧ k ≡ 1 [MOD 4 * y] } → Prop)
(x : { k // k ≡ a [MOD u] ∧ k ≡ 1 [MOD 4 * y] }),
(∀ (b : ℕ) (ba : b ≡ a [MOD u]) (bm1 : b ≡ 1 [MOD 4 * y]), motive ⟨b, ⋯⟩) → motive x | false |
EuclideanDomain.gcdB_zero_left | Mathlib.Algebra.EuclideanDomain.Defs | ∀ {R : Type u} [inst : EuclideanDomain R] [inst_1 : DecidableEq R] {s : R}, EuclideanDomain.gcdB 0 s = 1 | true |
Profinite.fintypeDiagram._proof_3 | Mathlib.Topology.Category.Profinite.AsLimit | ∀ (X : Profinite) {X_1 Y : DiscreteQuotient ↑X.toTop} (f : X_1 ⟶ Y), X_1 ≤ Y | false |
IsGδ.setOf_irrational | Mathlib.Topology.Instances.Irrational | IsGδ {x | Irrational x} | true |
Ordinal.IsNormal.nfp_le_apply | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ {f : Ordinal.{u} → Ordinal.{u}}, Order.IsNormal f → ∀ {a b : Ordinal.{u}}, Ordinal.nfp f a ≤ f b ↔ Ordinal.nfp f a ≤ b | true |
LinearIsometry.rTensor | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
(G : Type u_4) →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : InnerProductSpace 𝕜 F] →
... | true |
UpperHalfPlane.ne_intCast | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (z : UpperHalfPlane) (n : ℤ), ↑z ≠ ↑n | true |
CompactlySupportedContinuousMap.pullback_monoidHom_def | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : TopologicalSpace α] [inst_1 : R1Space α] [inst_2 : Group α]
[inst_3 : TopologicalSpace β] [inst_4 : R1Space β] [inst_5 : Group β] [inst_6 : ContinuousMul β]
[inst_7 : NormedAddCommGroup γ] {φ : α →* β} (hφ : Topology.IsClosedEmbedding ⇑φ)
(f : CompactlySuppor... | true |
CategoryTheory.Pseudofunctor.mapComp_assoc_left_hom_app | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat)
{a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) (X : ↑(F.obj a)),
CategoryTheory.CategoryStruct.comp ((F.mapComp (CategoryTheory.CategoryStruct.comp f g) h).hom.toNatTrans.app X)
((F.map h).toFuncto... | true |
Monoid.CoprodI.NeWord.toList._unsafe_rec | 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) | false |
CategoryTheory.ShiftMkCore.recOn | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_1} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
{motive : CategoryTheory.ShiftMkCore C A → Sort u_2} →
(t : CategoryTheory.ShiftMkCore C A) →
((F : A → CategoryTheory.Functor C C) →
(zero : F 0 ≅ CategoryTheor... | false |
DiscreteQuotient.ofLE_map | Mathlib.Topology.DiscreteQuotient | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{A : DiscreteQuotient X} {B B' : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B) (h : B ≤ B')
(a : Quotient A.toSetoid), DiscreteQuotient.ofLE h (DiscreteQuotient.map f cond a) = DiscreteQuotient.map ... | true |
OrderBot.lift | Mathlib.Order.BoundedOrder.Basic | {α : Type u} →
{β : Type v} →
[inst : LE α] →
[inst_1 : Bot α] →
[inst_2 : LE β] → [inst_3 : OrderBot β] → (f : α → β) → (∀ (b a : α), f b ≤ f a → b ≤ a) → f ⊥ = ⊥ → OrderBot α | true |
CategoryTheory.CartesianMonoidalCategory.comp_lift_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{V W X Y : C} (f : V ⟶ W) (g : W ⟶ X) (h : W ⟶ Y) {Z : C}
(h_1 : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (... | true |
String.Slice.RevPosIterator.instIteratorSubtypePosNeEndPosOfPure._proof_7 | Init.Data.String.Iterate | ∀ {m : Type → Type u_1} {s : String.Slice} (currPos : s.Pos) (h : ¬currPos = s.startPos),
match Std.IterStep.yield { internalState := { currPos := currPos.prev h } } ⟨currPos.prev h, ⋯⟩ with
| Std.IterStep.yield it' out =>
∃ (h : { internalState := { currPos := currPos } }.internalState.currPos ≠ s.startPos),
... | false |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Int.padicValuation_lt_one_iff._simp_1_3 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (x : ℤ), ((Int.padicValuation p) x ≤ 1) = True | false |
WithTop.sumHomeomorph._proof_1 | Mathlib.Topology.Order.WithTop | ∀ (ι : Type u_1) [inst : LinearOrder ι] [OrderTop ι], Nonempty ι | false |
CategoryTheory.Limits.HasColimitOfHasCoproductsOfHasCoequalizers.buildColimit._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} [inst_1 : CategoryTheory.SmallCategory J]
{F : CategoryTheory.Functor J C} {c₁ : CategoryTheory.Limits.Cofan fun f => F.obj f.fst.1}
{c₂ : CategoryTheory.Limits.Cofan F.obj} (s t : c₁.pt ⟶ c₂.pt),
(∀ (f : (p : J × J) × (p.1 ⟶ p.2)),
... | false |
Set.center_units_eq | Mathlib.Algebra.GroupWithZero.Center | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀], Set.center G₀ˣ = Units.val ⁻¹' Set.center G₀ | true |
_private.Mathlib.Probability.Kernel.Disintegration.CDFToKernel.0.ProbabilityTheory.setLIntegral_stieltjesOfMeasurableRat._simp_1_7 | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] (s : Set α),
(μ s = ⊤) = False | false |
UInt64.ofFin_div | Init.Data.UInt.Lemmas | ∀ (a b : Fin UInt64.size), UInt64.ofFin (a / b) = UInt64.ofFin a / UInt64.ofFin b | true |
String.Slice.Pos._sizeOf_1 | Init.Data.String.Defs | {s : String.Slice} → s.Pos → ℕ | false |
Lean.Elab.Tactic.Do.ProofMode.parseMGoal? | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Expr → Option Lean.Elab.Tactic.Do.ProofMode.MGoal | true |
CategoryTheory.ObjectProperty.instEssentiallySmallMax | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.ObjectProperty C}
[CategoryTheory.ObjectProperty.EssentiallySmall.{w, v, u} P]
[CategoryTheory.ObjectProperty.EssentiallySmall.{w, v, u} Q],
CategoryTheory.ObjectProperty.EssentiallySmall.{w, v, u} (P ⊔ Q) | true |
_private.Mathlib.Data.List.Intervals.0.List.Ico.filter_lt_of_le_bot._simp_1_1 | Mathlib.Data.List.Intervals | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
CategoryTheory.Comonad.comonadicOfHasPreservesCoreflexiveEqualizersOfReflectsIsomorphisms | Mathlib.CategoryTheory.Monad.Comonadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
(F ⊣ G) →
[CategoryTheory.Limits.HasCoreflexiveEqualizers C] →
... | true |
CategoryTheory.MorphismProperty.instHasOfPrecompPropertyUnopOfHasOfPostcompPropertyOpposite | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W₁ W₂ : CategoryTheory.MorphismProperty Cᵒᵖ)
[W₁.HasOfPostcompProperty W₂], W₁.unop.HasOfPrecompProperty W₂.unop | true |
UpperHalfPlane.IsZeroAtImInfty.petersson_exp_decay_right | Mathlib.NumberTheory.ModularForms.Petersson | ∀ {F : Type u_1} {F' : Type u_2} [inst : FunLike F UpperHalfPlane ℂ] [inst_1 : FunLike F' UpperHalfPlane ℂ] (k : ℤ)
(Γ : Subgroup (GL (Fin 2) ℝ)) [Fact (IsCusp OnePoint.infty Γ)] [Γ.HasDetPlusMinusOne] [DiscreteTopology ↥Γ]
[ModularFormClass F Γ k] [ModularFormClass F' Γ k] (f : F) {f' : F'},
UpperHalfPlane.IsZer... | true |
FP.Float.sign' | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → FP.Float → Semiquot Bool | true |
IntermediateField.restrictScalars._proof_5 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ (K : Type u_2) {L : Type u_1} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] [inst_5 : Algebra L' L] [inst_6 : IsScalarTower K L' L]
(E : IntermediateField L' L) (r : K), (algebraMap K L) r ∈ (Subalgebra.restrictScalars K E.toSubalgebra).carr... | false |
Std.TreeSet.Equiv.max!_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t₁.Equiv t₂ → t₁.max! = t₂.max! | true |
CategoryTheory.MorphismProperty.rlp_isStableUnderBaseChange | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C),
T.rlp.IsStableUnderBaseChange | true |
WeierstrassCurve.Projective.equation_of_Z_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P : Fin 3 → F},
P 2 ≠ 0 → (W.Equation P ↔ W.toAffine.Equation (P 0 / P 2) (P 1 / P 2)) | true |
Std.TreeSet.Equiv.toList_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp],
t₁.Equiv t₂ → t₁.toList = t₂.toList | true |
String.IsSuffix | Mathlib.Data.String.Defs | String → String → Prop | true |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.sPolynomial_decomposition._simp_1_3 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {α : Type u_9} {β : Type u_10} {inst : Semigroup α} [self : SemigroupAction α β] (x y : α) (b : β),
x • y • b = (x * y) • b | false |
Representation.Coinvariants.instModule._proof_8 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (x : ρ.Coinvariants), 0 • x = 0 | false |
Std.HashMap.Raw.getD_eq_fallback | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a : α} {fallback : β}, a ∉ m → m.getD a fallback = fallback | true |
_private.Lean.Elab.Deriving.Inhabited.0.Lean.Elab.Deriving.mkInhabitedInstanceUsing | Lean.Elab.Deriving.Inhabited | Lean.Name → Lean.Name → Bool → Lean.Elab.Command.CommandElabM Bool | true |
Lean.NamePart.cmp | Lean.Data.NameTrie | Lean.NamePart → Lean.NamePart → Ordering | true |
CategoryTheory.Comonad.comonadicOfHasPreservesReflectsFSplitEqualizers | Mathlib.CategoryTheory.Monad.Comonadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
(F ⊣ G) →
[CategoryTheory.Comonad.HasEqualizerOfIsCosplitPair F] →
... | true |
Lean.registerInitAttrUnsafe | Lean.Compiler.InitAttr | Lean.Name → Bool → Lean.Name → IO (Lean.ParametricAttribute Lean.Name) | true |
Lean.Server.locationLinksDefault | Lean.Server.GoTo | Lean.Server.GoToM (Array Lean.Lsp.LeanLocationLink) | true |
USize.toBitVec_ofBitVec | Init.Data.UInt.Lemmas | ∀ (n : BitVec System.Platform.numBits), { toBitVec := n }.toBitVec = n | true |
Fin.pred_mk_succ' | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (i : ℕ) (h₁ : i + 1 < n + 1 + 1) (h₂ : ⟨i + 1, h₁⟩ ≠ 0), ⟨i + 1, h₁⟩.pred h₂ = ⟨i, ⋯⟩ | true |
Batteries.instTransCmpCompareLex | Batteries.Classes.Deprecated | ∀ {α : Sort u_1} {cmp₁ cmp₂ : α → α → Ordering} [inst₁ : Batteries.TransCmp cmp₁] [inst₂ : Batteries.TransCmp cmp₂],
Batteries.TransCmp (compareLex cmp₁ cmp₂) | true |
_private.Mathlib.Geometry.Manifold.IntegralCurve.ExistUnique.0.IsMIntegralCurve.periodic_xor_injective.match_1_1 | Mathlib.Geometry.Manifold.IntegralCurve.ExistUnique | ∀ {M : Type u_1} {γ : ℝ → M} (motive : (∃ T > 0, Function.Periodic γ T) → Prop) (x : ∃ T > 0, Function.Periodic γ T),
(∀ (T : ℝ) (hT : T > 0) (hf : Function.Periodic γ T), motive ⋯) → motive x | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.mkProofInstInfoMapFor | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.MetaM (Lean.AssocList Lean.Name Lean.Meta.Sym.ProofInstInfo) | true |
VSub | Mathlib.Algebra.Notation.Defs | outParam (Type u_1) → Type u_2 → Type (max u_1 u_2) | true |
Std.TreeMap.getKeyD_unitOfList_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α} {k k' fallback : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeMap.unitOfList l cmp).getKeyD k' fallback = k | true |
AddConstMap.mkFract._proof_2 | Mathlib.Algebra.AddConstMap.Basic | ∀ {R : Type u_1} {G : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : FloorRing R] [inst_4 : AddGroup G] (a : G) (x : ↑(Set.Ico 0 1) → G),
(fun f x => f ↑x) ((fun f => { toFun := fun x => f ⟨Int.fract x, ⋯⟩ + ⌊x⌋ • a, map_add_const' := ⋯ }) x) = x | false |
BoundedContinuousFunction.indicator._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : Set α), IsClopen s → ∀ a ∈ frontier s, 1 a = 0 | false |
Ordnode.fold._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → {β : Sort u_2} → β → (β → α → β → β) → Ordnode α → β | false |
List.dvd_prod | Mathlib.Algebra.BigOperators.Group.List.Lemmas | ∀ {M : Type u_4} [inst : CommMonoid M] {a : M} {l : List M}, a ∈ l → a ∣ l.prod | true |
AddCon.coe_mk' | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : AddZeroClass M] {c : AddCon M}, ⇑c.mk' = AddCon.toQuotient | true |
FP.FloatCfg.precPos | Mathlib.Data.FP.Basic | ∀ [self : FP.FloatCfg], 0 < FP.FloatCfg.prec | true |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.ZariskisMainProperty.of_algHom_polynomial._simp_1_1 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rcf : RingHomClass F R S] (f : F), Ideal.comap f ⊥ = RingHom.ker f | false |
_private.Mathlib.RingTheory.Ideal.Norm.AbsNorm.0.Ideal.mem_prime_of_mul_mem_pow._simp_1_3 | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {R : Type u} [inst : Semiring R] (r s : R) [(Ideal.span {r}).IsTwoSided],
Ideal.span {r * s} = Ideal.span {r} * Ideal.span {s} | false |
CochainComplex.ConnectData.comp_d₀ | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (self : CochainComplex.ConnectData K L),
CategoryTheory.CategoryStruct.comp (K.d 1 0) self.d₀ = 0 | true |
TopCat.Sheaf.instIsLeftAdjointPullback | Mathlib.Topology.Sheaves.Functors | ∀ {X Y : TopCat} (f : X ⟶ Y) (A : Type u_1) [inst : CategoryTheory.Category.{w, u_1} A] {FA : A → A → Type u_2}
{CA : A → Type w} [inst_1 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)]
[inst_2 : CategoryTheory.ConcreteCategory A FA] [inst_3 : CategoryTheory.Limits.HasColimits A]
[inst_4 : CategoryTheory.Limits.Has... | true |
MeasureTheory.VectorMeasure.instModule | Mathlib.MeasureTheory.VectorMeasure.Basic | {α : Type u_1} →
{m : MeasurableSpace α} →
{M : Type u_3} →
[inst : AddCommMonoid M] →
[inst_1 : TopologicalSpace M] →
{R : Type u_4} →
[inst_2 : Semiring R] →
[inst_3 : Module R M] →
[ContinuousConstSMul R M] → [inst_5 : ContinuousAdd M] → Module ... | true |
Std.ExtDTreeMap.get_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k a : α} {v : β k} {h₁ : a ∈ t.insertIfNew k v},
(t.insertIfNew k v).get a h₁ = if h₂ : cmp k a = Ordering.eq ∧ k ∉ t then cast ⋯ v else t.get a ⋯ | true |
Lean.Grind.Linarith.Expr.norm | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Expr → Lean.Grind.Linarith.Poly | true |
DoubleCentralizer.instStar._proof_2 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_2} {A : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : StarRing 𝕜]
[inst_6 : StarRing A] [inst_7 : StarModule 𝕜 A] [inst_8 : NormedStarGroup A] (a : DoubleCentralize... | false |
Std.ExtHashMap.insertManyIfNewUnit.congr_simp | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {ρ : Type w}
[inst_2 : ForIn Id ρ α] (m m_1 : Std.ExtHashMap α Unit),
m = m_1 → ∀ (l l_1 : ρ), l = l_1 → m.insertManyIfNewUnit l = m_1.insertManyIfNewUnit l_1 | true |
AlgebraicGeometry.Scheme.Cover.pullbackHom | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[inst : P.IsStableUnderBaseChange] →
[inst_1 : AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X W : AlgebraicGeometry.Scheme} →
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) →
... | true |
Valuation.HasExtension.instAlgebra_valuationSubring._proof_6 | Mathlib.RingTheory.Valuation.Extension | ∀ {K : Type u_1} {L : Type u_3} {Γ₀ : Type u_2} {Γ₁ : Type u_4} [inst : Field K] [inst_1 : Field L]
[inst_2 : Algebra K L] [inst_3 : LinearOrderedCommGroupWithZero Γ₀] [inst_4 : LinearOrderedCommGroupWithZero Γ₁]
(vK : Valuation K Γ₀) (vL : Valuation L Γ₁) [inst_5 : vK.HasExtension vL] (r : ↥vK.valuationSubring)
... | false |
Metric.sphere_subset_ball | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {r R : ℝ}, r < R → Metric.sphere x r ⊆ Metric.ball x R | true |
Polynomial.separable_X_pow_sub_C' | Mathlib.FieldTheory.Separable | ∀ {F : Type u} [inst : Field F] (p n : ℕ) (a : F) [CharP F p],
¬p ∣ n → a ≠ 0 → (Polynomial.X ^ n - Polynomial.C a).Separable | true |
CategoryTheory.IsPullback.app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.Limits.HasPullbacks D] {F₁ F₂ F₃ F₄ : CategoryTheory.Functor C D} {f₁ : F₁ ⟶ F₂} {f₂ : F₁ ⟶ F₃}
{f₃ : F₂ ⟶ F₄} {f₄ : F₃ ⟶ F₄},
CategoryTheory.IsPullback f₁ f₂ f₃ f₄ →
∀ (X : ... | true |
CategoryTheory.Limits.Cocones.cone_iso_of_hom_iso | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{K : CategoryTheory.Functor J C} {c d : CategoryTheory.Limits.Cocone K} (f : d ⟶ c) [i : CategoryTheory.IsIso f.hom],
CategoryTheory.IsIso f | true |
Booleanisation.liftLatticeHom._proof_1 | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (x x_1 : α),
Booleanisation.lift (x ⊔ x_1) = Booleanisation.lift (x ⊔ x_1) | false |
OrthogonalFamily.of_pairwise | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {V : ι → Submodule 𝕜 E},
Pairwise (Function.onFun (fun x1 x2 => x1 ⟂ x2) V) → OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ | true |
Array.attach_congr._proof_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {xs ys : Array α}, xs = ys → ∀ (x : { x // x ∈ ys }), ↑x ∈ xs | false |
_private.Mathlib.Topology.Compactness.Compact.0.IsCompact.sigma_exists_finite_sigma_eq._simp_1_3 | Mathlib.Topology.Compactness.Compact | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
lieModule_lcs_map_le | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [LieModule R L M] {L₂ : Type u_1}
{M₂ : Type u_2} [inst_7 : LieRing L₂] [inst_8 : LieAlgebra R L₂] [inst_9 : AddCommGroup M₂] [inst... | true |
_private.Init.Data.SInt.Bitwise.0.Int32.and_not_self._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.