name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Internal.List.minKey?_insertEntryIfNew_le_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
{k kmi : α} {v : β k} {l : List ((a : α) × β a)} (hl : Std.Internal.List.DistinctKeys l),
(Std.Internal.List.minKey? (Std.Internal.List.insertEntryIfNew k v l)).get ⋯ = kmi → (compare kmi k).isLE ... | true |
CategoryTheory.Functor.mapHomologicalComplexUpToQuasiIsoLocalizerMorphism._proof_1 | Mathlib.Algebra.Homology.Localization | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Preadditive C] [CategoryTheory.CategoryWithHomology C] (x : HomologicalComplex C c) (i : ι),
(x.sc i).HasHomology | false |
_private.Lean.Elab.Tactic.Grind.Have.0.Lean.Elab.Tactic.Grind.evalHaveSilent.match_7 | Lean.Elab.Tactic.Grind.Have | (motive : Option (Lean.TSyntax `ident) → Sort u_1) →
(id? : Option (Lean.TSyntax `ident)) →
((id : Lean.TSyntax `ident) → motive (some id)) → ((x : Option (Lean.TSyntax `ident)) → motive x) → motive id? | false |
_private.Init.Data.Vector.Lemmas.0.Vector.getElem_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} {size : xs.size = n} {i : ℕ}, i < n → ¬i < xs.size → False | false |
IsFractionRing.lift.congr_simp | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_4} [inst : CommRing A] {K : Type u_5} [inst_1 : Field K] {L : Type u_7} [inst_2 : Field L]
[inst_3 : Algebra A K] [inst_4 : IsFractionRing A K] {g g_1 : A →+* L} (e_g : g = g_1) (hg : Function.Injective ⇑g),
IsFractionRing.lift hg = IsFractionRing.lift ⋯ | true |
CochainComplex.Plus.instIsClosedUnderColimitsOfShapeIntPlusOfFinCategoryOfHasColimitsOfShape | Mathlib.Algebra.Homology.CochainComplexPlus | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(J : Type u_2) [inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J]
[CategoryTheory.Limits.HasColimitsOfShape J C], (CochainComplex.plus C).IsClosedUnderColimitsOfShape J | true |
MeasureTheory.tilted_apply_eq_ofReal_integral' | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} (f : α → ℝ),
MeasurableSet s → (μ.tilted f) s = ENNReal.ofReal (∫ (a : α) in s, Real.exp (f a) / ∫ (x : α), Real.exp (f x) ∂μ ∂μ) | true |
CategoryTheory.instLocallySmallFunctor | Mathlib.CategoryTheory.EssentiallySmall | ∀ {A : Type u'} [inst : CategoryTheory.Category.{v', u'} A] [CategoryTheory.LocallySmall.{w, v', u'} A] (C : Type w)
[inst_2 : CategoryTheory.SmallCategory C],
CategoryTheory.LocallySmall.{w, max v' w, max (max (max u' w) v') w} (CategoryTheory.Functor C A) | true |
MulChar.ringHomComp_inv | Mathlib.NumberTheory.MulChar.Basic | ∀ {R' : Type u_2} [inst : CommRing R'] {R'' : Type u_3} [inst_1 : CommRing R''] {R : Type u_4}
[inst_2 : CommMonoidWithZero R] (χ : MulChar R R') (f : R' →+* R''), (χ.ringHomComp f)⁻¹ = χ⁻¹.ringHomComp f | true |
Std.Time.Year | Std.Time.Format.Basic | Type | true |
Nat.recOn | Init.Prelude | {motive : ℕ → Sort u} → (t : ℕ) → motive Nat.zero → ((n : ℕ) → motive n → motive n.succ) → motive t | false |
_private.Batteries.Data.List.Lemmas.0.List.filterMap.match_1.splitter | Batteries.Data.List.Lemmas | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((b : β) → motive (some b)) → motive x | true |
Computability.instDecidableEqΓ'.decEq._proof_19 | Mathlib.Computability.Encoding | ¬Computability.Γ'.ket = Computability.Γ'.comma | false |
Algebra.IsFiniteSplit.instEtale | Mathlib.RingTheory.TotallySplit | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.IsFiniteSplit R S], Algebra.Etale R S | true |
_private.Aesop.Index.0.Aesop.Index.trace.traceArray | Aesop.Index | {α : Type} → [ToString (Aesop.Rule α)] → Aesop.TraceOption → Array (Aesop.Rule α) → Lean.CoreM Unit | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_19 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι},
a ≤ b → ∀ (w : ι) (h_9 : ¬w ≤ b) (hq : w ≤ c), ↑⟨w, ⋯⟩ ∈ Finset.Ioc a c | false |
Lean.Elab.Term.ToDepElimPattern.TopSort.State.ctorIdx | Lean.Elab.Match | Lean.Elab.Term.ToDepElimPattern.TopSort.State → ℕ | false |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.letCase.match_1 | Mathlib.Tactic.FunProp.Core | (motive : Bool → Bool → Sort u_1) →
(x x_1 : Bool) → (Unit → motive true true) → (Unit → motive true false) → ((x : Bool) → motive false x) → motive x x_1 | false |
oscillation | Mathlib.Analysis.Oscillation | {E : Type u} → {F : Type v} → [PseudoEMetricSpace F] → [TopologicalSpace E] → (E → F) → E → ENNReal | true |
_private.Std.Internal.Http.Internal.IndexMultiMap.0.Std.Internal.IndexMultiMap.insert.match_1.eq_1 | Std.Internal.Http.Internal.IndexMultiMap | ∀ (motive : Option (Array ℕ) → Sort u_1) (idxs : Array ℕ) (h_1 : (idxs : Array ℕ) → motive (some idxs))
(h_2 : Unit → motive none),
(match some idxs with
| some idxs => h_1 idxs
| none => h_2 ()) =
h_1 idxs | true |
SSet.δ_comp_δ_self'_apply | Mathlib.AlgebraicTopology.SimplicialSet.Basic | ∀ {S : SSet} {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 3)},
j = i.castSucc →
∀ (x : S.obj (Opposite.op { len := n + 2 })),
CategoryTheory.SimplicialObject.δ S i (CategoryTheory.SimplicialObject.δ S j x) =
CategoryTheory.SimplicialObject.δ S i (CategoryTheory.SimplicialObject.δ S i.succ x) | true |
ContinuousLinearMap.norm_extendTo𝕜 | Mathlib.Analysis.Normed.Module.RCLike.Extend | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F]
[inst_3 : NormedSpace ℝ F] [inst_4 : IsScalarTower ℝ 𝕜 F] (fr : StrongDual ℝ F), ‖fr.extendRCLike‖ = ‖fr‖ | true |
Lean.Compiler.LCNF.compiler.maxRecSpecialize | Lean.Compiler.LCNF.ConfigOptions | Lean.Option ℕ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.ordered_keys_toList._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Equiv.mapMatrix._proof_2 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_4} {β : Type u_3} (f : α ≃ β) (x : Matrix m n β), (x.map ⇑f.symm).map ⇑f = x | false |
LieSubmodule.lieSpan_mono | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {s t : Set M},
s ⊆ t → LieSubmodule.lieSpan R L s ≤ LieSubmodule.lieSpan R L t | true |
Lean.Meta.Grind.AC.EqCnstrProof.simp_middle.elim | Lean.Meta.Tactic.Grind.AC.Types | {motive_2 : Lean.Meta.Grind.AC.EqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.AC.EqCnstrProof) →
t.ctorIdx = 8 →
((lhs : Bool) →
(s₁ s₂ : Lean.Grind.AC.Seq) →
(c₁ c₂ : Lean.Meta.Grind.AC.EqCnstr) →
motive_2 (Lean.Meta.Grind.AC.EqCnstrProof.simp_middle lhs s₁ s₂ c₁ c₂)) →
... | false |
Sum.infinite_of_left | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {β : Type u_2} [Infinite α], Infinite (α ⊕ β) | true |
Std.DTreeMap.Internal.Impl.maxEntry?_eq_minEntry? | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [o : Ord α] [«to» : Std.TransOrd α] {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.maxEntry? = Std.Internal.List.minEntry? t.toListModel | true |
Equiv.uniqueProd | Mathlib.Logic.Equiv.Prod | (α : Type u_9) → (β : Type u_10) → [Unique β] → β × α ≃ α | true |
AlgHom.compLeftContinuous | Mathlib.Topology.ContinuousMap.Algebra | (R : Type u_2) →
[inst : CommSemiring R] →
{A : Type u_3} →
[inst_1 : TopologicalSpace A] →
[inst_2 : Semiring A] →
[inst_3 : Algebra R A] →
[inst_4 : IsTopologicalSemiring A] →
{A₂ : Type u_4} →
[inst_5 : TopologicalSpace A₂] →
[... | true |
Lean.Meta.ArgsPacker.Mutual.uncurryWithType | Lean.Meta.ArgsPacker | Lean.Expr → Array Lean.Expr → Lean.MetaM Lean.Expr | true |
Function.Injective.semigroup.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Mul M₁] [inst_1 : Semigroup M₂] (f : M₁ → M₂) (hf : Function.Injective f)
(mul : ∀ (x y : M₁), f (x * y) = f x * f y), Function.Injective.semigroup f hf mul = { toMul := inst, mul_assoc := ⋯ } | true |
Inhabited.mk | Init.Prelude | {α : Sort u} → α → Inhabited α | true |
Pi.instLTColexForall | Mathlib.Order.PiLex | {ι : Type u_1} → {β : ι → Type u_2} → [LT ι] → [(a : ι) → LT (β a)] → LT (Colex ((i : ι) → β i)) | true |
AddSubgroup.normalClosure_subset_iff | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {s : Set G} {N : AddSubgroup G} [N.Normal],
s ⊆ ↑N ↔ AddSubgroup.normalClosure s ≤ N | true |
Fin.coe_sub_one | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} (a : Fin (n + 1)), ↑(a - 1) = if a = 0 then n else ↑a - 1 | true |
Finset.Nonempty.mono | Mathlib.Data.Finset.Empty | ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → s.Nonempty → t.Nonempty | true |
Lean.Elab.Tactic.Location.targets.injEq | Lean.Elab.Tactic.Location | ∀ (hypotheses : Array Lean.Syntax) (type : Bool) (hypotheses_1 : Array Lean.Syntax) (type_1 : Bool),
(Lean.Elab.Tactic.Location.targets hypotheses type = Lean.Elab.Tactic.Location.targets hypotheses_1 type_1) =
(hypotheses = hypotheses_1 ∧ type = type_1) | true |
CategoryTheory.PreGaloisCategory.instMonoCoprod | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C],
CategoryTheory.Limits.MonoCoprod C | true |
_private.Init.Data.List.Nat.TakeDrop.0.List.take_replicate.match_1_1 | Init.Data.List.Nat.TakeDrop | ∀ (motive : ℕ → ℕ → Prop) (x x_1 : ℕ),
(∀ (n : ℕ), motive n 0) → (∀ (m : ℕ), motive 0 m) → (∀ (n m : ℕ), motive n.succ m.succ) → motive x x_1 | false |
ULift.addCommGroupWithOne._proof_1 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_1} [inst : AddCommGroupWithOne R], ↑0 = 0 | false |
UInt8.ofBitVec_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a : BitVec 8), ∀ b < 8, { toBitVec := a <<< b } = { toBitVec := a } <<< UInt8.ofNat b | true |
_private.Mathlib.RingTheory.Valuation.Integers.0.Valuation.leIdeal_map_algebraMap_eq_leSubmodule_min._simp_1_1 | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R M} {x : M₂},
(x ∈ S... | false |
_private.Aesop.Frontend.RuleExpr.0.Aesop.Frontend.RuleConfig.toRuleFilter.match_10 | Aesop.Frontend.RuleExpr | (motive : Lean.Name × Aesop.ScopeName → Sort u_1) →
(__discr : Lean.Name × Aesop.ScopeName) →
((name : Lean.Name) → (scope : Aesop.ScopeName) → motive (name, scope)) → motive __discr | false |
ByteArray.utf8DecodeChar?.assemble₂Unchecked | Init.Data.String.Decode | UInt8 → UInt8 → UInt32 | true |
AlternatingMap.pi._proof_1 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_5} [inst : Semiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_2}
{ι' : Type u_3} {N : ι' → Type u_4} [inst_3 : (i : ι') → AddCommMonoid (N i)] [inst_4 : (i : ι') → Module R (N i)]
(f : (i : ι') → M [⋀^ι]→ₗ[R] N i) (x : ι → M) (x_1 x_2 : ι),
x x_1 = x x_2 → x_1 ≠ ... | false |
hammingDist.eq_1 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_2} {β : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → DecidableEq (β i)] (x y : (i : ι) → β i),
hammingDist x y = {i | x i ≠ y i}.card | true |
FGAlgCatSkeleton.mk._flat_ctor | Mathlib.Algebra.Category.CommAlgCat.FiniteType | {R : Type u} → [inst : CommRing R] → (n : ℕ) → Ideal (MvPolynomial (Fin n) R) → FGAlgCatSkeleton R | false |
WithConv.ofConv_smul | Mathlib.Algebra.WithConv | ∀ {R : Type u_1} {A : Type u_2} [inst : Monoid R] [inst_1 : MulAction R A] (c : R) (x : WithConv A),
(c • x).ofConv = c • x.ofConv | true |
CategoryTheory.Limits.ColimitPresentation.bind._proof_7 | Mathlib.CategoryTheory.Presentable.ColimitPresentation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} {I : J → Type u_3}
[inst_1 : CategoryTheory.SmallCategory J] [inst_2 : (j : J) → CategoryTheory.SmallCategory (I j)] {X : C}
(P : CategoryTheory.Limits.ColimitPresentation J X)
(Q : (j : J) → CategoryTheory.Limits.ColimitPresentation (I... | false |
Lean.Lsp.DeclarationParams.rec | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.DeclarationParams → Sort u} →
((toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams) →
motive { toTextDocumentPositionParams := toTextDocumentPositionParams }) →
(t : Lean.Lsp.DeclarationParams) → motive t | false |
_private.Init.Data.Int.LemmasAux.0.Int.toNat_sub'._proof_1_3 | Init.Data.Int.LemmasAux | ∀ (b a b_1 : ℕ), ↑a - ↑b = -(↑b_1 + 1) → ¬a - b = 0 → False | false |
LinearMap.toSeminormFamily | Mathlib.Analysis.LocallyConvex.WeakDual | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : NormedField 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : AddCommGroup F] → [inst_4 : Module 𝕜 F] → (E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) → SeminormFamily 𝕜 E F | true |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.isClosed_inter_cellFrontier_succ_of_le_isClosed_inter_closedCell.match_1_1 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {n : ℕ} (motive : { x // x < n + 1 } → Prop) (h : { x // x < n + 1 }),
(∀ (m : ℕ) (mlt : m < n + 1), motive ⟨m, mlt⟩) → motive h | false |
ProbabilityTheory.Kernel.compProd_apply_univ | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α β} {η : ProbabilityTheory.Kernel (α × β) γ}
[ProbabilityTheory.IsSFiniteKernel κ] [ProbabilityTheory.IsMarkovKernel η] {a : α},
((κ.compProd η) a) Set.univ = (κ... | true |
_private.Init.Data.List.Int.Sum.0.List.min_mul_length_le_sum_int._proof_1_2 | Init.Data.List.Int.Sum | ∀ (head : ℤ) (tail : List ℤ), ¬0 < ↑tail.length + 1 → False | false |
_private.Init.Data.Nat.Lemmas.0.Nat.mul_right_cancel_iff.match_1_1 | Init.Data.Nat.Lemmas | ∀ {n : ℕ} (motive : (k : ℕ) → n = k → Prop) (k : ℕ) (x : n = k), (∀ (a : Unit), motive n ⋯) → motive k x | false |
_private.Mathlib.LinearAlgebra.Multilinear.Basic.0.MultilinearMap.map_sum_finset_aux._simp_1_7 | Mathlib.LinearAlgebra.Multilinear.Basic | (¬True) = False | false |
PFunctor.MIntl.inhabited | Mathlib.Data.PFunctor.Univariate.M | (F : PFunctor.{uA, uB}) → [Inhabited F.A] → Inhabited F.MIntl | true |
String.Pos.ne_next._simp_1 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p : s.Pos} {h : p ≠ s.endPos}, (p = p.next h) = False | false |
IsCyclotomicExtension.Rat.isIntegralClosure_adjoin_singleton_of_prime | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[hcycl : IsCyclotomicExtension {p} ℚ K], IsPrimitiveRoot ζ p → IsIntegralClosure ↥ℤ[ζ] ℤ K | true |
SpectralMap.instInhabited | Mathlib.Topology.Spectral.Hom | (α : Type u_2) → [inst : TopologicalSpace α] → Inhabited (SpectralMap α α) | true |
Std.Internal.List.getEntry!_cons_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [ReflBEq α] {l : List ((a : α) × β a)} {k : α} {v : β k}
[inst_2 : Inhabited ((a : α) × β a)], Std.Internal.List.getEntry! k (⟨k, v⟩ :: l) = ⟨k, v⟩ | true |
_private.Mathlib.Tactic.Ring.Compare.0.Mathlib.Tactic.Ring.evalLE._sparseCasesOn_10 | Mathlib.Tactic.Ring.Compare | {u : Lean.Level} →
{α : Q(Type u)} →
{BaseType : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
{motive_3 : (e : Q(«$α»)) → Mathlib.Tactic.Ring.Common.ExSum BaseType sα e → Sort u} →
{e : Q(«$α»)} →
(t : Mathlib.Tactic.Ring.Common.ExSum BaseType sα e) →
({a b : Q... | false |
Std.ExtTreeSet.mk._flat_ctor | Std.Data.ExtTreeSet.Basic | {α : Type u} →
{cmp : autoParam (α → α → Ordering) Std.ExtTreeSet._auto_1} → Std.ExtTreeMap α Unit cmp → Std.ExtTreeSet α cmp | false |
CategoryTheory.Functor.instMonoidalProdDiag._proof_4 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(X' : C) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.Functor.diag C).obj X')
((CategoryTheory.Functor.diag C).ma... | false |
PseudoMetricSpace.ofSeminormedSpaceCore | Mathlib.Analysis.Normed.Module.Basic | {𝕜 : Type u_6} →
{E : Type u_7} →
[inst : NormedField 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Norm E] → [inst_3 : Module 𝕜 E] → SeminormedSpace.Core 𝕜 E → PseudoMetricSpace E | true |
Lean.LevelSet | Lean.Level | Type | true |
Array.getElem?_setIfInBounds_ne | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, i ≠ j → ∀ {a : α}, (xs.setIfInBounds i a)[j]? = xs[j]? | true |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.cast_nnrat.match_1_1 | Mathlib.Tactic.Ring.Basic | ∀ {n d : ℕ} {R : Type u_1} [inst : DivisionSemiring R] {a : R} (motive : Mathlib.Meta.NormNum.IsNNRat a n d → Prop)
(x : Mathlib.Meta.NormNum.IsNNRat a n d), (∀ (inv : Invertible ↑d) (e : a = ↑n * ⅟↑d), motive ⋯) → motive x | false |
gt_trans' | Mathlib.Order.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b c : α}, a < b → b < c → a < c | true |
cauchySeq_iff_tendsto | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [Nonempty β] [inst : SemilatticeSup β] {u : β → α},
CauchySeq u ↔ Filter.Tendsto (Prod.map u u) Filter.atTop (uniformity α) | true |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_12 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n n_1 : ℕ), ¬Std.Tactic.BVDecide.BVUnOp.rotateLeft n = Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n_1 | false |
ENNReal.div_eq_top | Mathlib.Data.ENNReal.Inv | ∀ {a b : ENNReal}, a / b = ⊤ ↔ a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤ | true |
List.IsChain.singleton._simp_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} {R : α → α → Prop} (a : α), List.IsChain R [a] = True | false |
_private.Mathlib.Tactic.NormNum.GCD.0.Tactic.NormNum.isInt_gcd.match_1_1 | Mathlib.Tactic.NormNum.GCD | ∀
(motive :
(x x_1 x_2 x_3 : ℤ) →
(x_4 : ℕ) → Mathlib.Meta.NormNum.IsInt x x_2 → Mathlib.Meta.NormNum.IsInt x_1 x_3 → x_2.gcd x_3 = x_4 → Prop)
(x x_1 x_2 x_3 : ℤ) (x_4 : ℕ) (x_5 : Mathlib.Meta.NormNum.IsInt x x_2) (x_6 : Mathlib.Meta.NormNum.IsInt x_1 x_3)
(x_7 : x_2.gcd x_3 = x_4),
(∀ (n n_1 : ℤ), m... | false |
lp.infty_coeFn_mul | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {I : Type u_5} {B : I → Type u_6} [inst : (i : I) → NonUnitalNormedRing (B i)] (f g : ↥(lp B ⊤)), ↑(f * g) = ↑f * ↑g | true |
Finset.prod_eq_mul_prod_diff_singleton_of_mem | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] [inst_1 : DecidableEq ι] {s : Finset ι} {i : ι},
i ∈ s → ∀ (f : ι → M), ∏ x ∈ s, f x = f i * ∏ x ∈ s \ {i}, f x | true |
LinearAlgebra.FreeProduct.ι'._proof_1 | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
Encodable.ofLeftInjection | Mathlib.Logic.Encodable.Basic | {α : Type u_1} →
{β : Type u_2} → [Encodable α] → (f : β → α) → (finv : α → Option β) → (∀ (b : β), finv (f b) = some b) → Encodable β | true |
Set.sups_subset_left | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeSup α] {s t₁ t₂ : Set α}, t₁ ⊆ t₂ → s ⊻ t₁ ⊆ s ⊻ t₂ | true |
Tuple.eq_sort_iff | Mathlib.Data.Fin.Tuple.Sort | ∀ {n : ℕ} {α : Type u_1} [inst : LinearOrder α] {f : Fin n → α} {σ : Equiv.Perm (Fin n)},
σ = Tuple.sort f ↔ Monotone (f ∘ ⇑σ) ∧ ∀ (i j : Fin n), i < j → f (σ i) = f (σ j) → σ i < σ j | true |
Std.Do.ExceptConds.true | Std.Do.PostCond | {ps : Std.Do.PostShape} → Std.Do.ExceptConds ps | true |
Lean.Meta.Simp.SimprocOLeanEntry.mk.inj | Lean.Meta.Tactic.Simp.Types | ∀ {declName : Lean.Name} {post : Bool} {keys : Array Lean.Meta.SimpTheoremKey} {declName_1 : Lean.Name} {post_1 : Bool}
{keys_1 : Array Lean.Meta.SimpTheoremKey},
{ declName := declName, post := post, keys := keys } = { declName := declName_1, post := post_1, keys := keys_1 } →
declName = declName_1 ∧ post = po... | true |
CategoryTheory.ShortComplex.Homotopy.comm₁._autoParam | Mathlib.Algebra.Homology.ShortComplex.Preadditive | Lean.Syntax | false |
Bundle.Trivialization.symmL._proof_1 | Mathlib.Topology.VectorBundle.Basic | ∀ {B : Type u_3} {F : Type u_1} {E : B → Type u_2} [inst : (x : B) → AddCommMonoid (E x)]
[inst_1 : NormedAddCommGroup F] [inst_2 : TopologicalSpace B] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_4 : (x : B) → TopologicalSpace (E x)] [FiberBundle F E] (e : Bundle.Trivialization F Bundle.TotalSpace.pro... | false |
CategoryTheory.Abelian.Ext.biprodAddEquiv_apply_fst | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X₁ X₂ Y : C} {n : ℕ} (e : CategoryTheory.Abelian.Ext (X₁ ⊞ X₂) Y n),
(CategoryTheory.Abelian.Ext.biprodAddEquiv e).1 =
(CategoryTheory.Abelian.Ext.mk₀ CategoryTheory.Limits.biprod.inl... | true |
AkraBazziRecurrence.eventually_r_lt_n | Mathlib.Computability.AkraBazzi.SumTransform | ∀ {α : Type u_1} [inst : Fintype α] {T : ℕ → ℝ} {g : ℝ → ℝ} {a b : α → ℝ} {r : α → ℕ → ℕ} [inst_1 : Nonempty α]
(R : AkraBazziRecurrence T g a b r), ∀ᶠ (n : ℕ) in Filter.atTop, ∀ (i : α), r i n < n | true |
SeparationQuotient.instMonoidWithZero | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {M₀ : Type u_1} →
[inst : TopologicalSpace M₀] →
[inst_1 : MonoidWithZero M₀] → [ContinuousMul M₀] → MonoidWithZero (SeparationQuotient M₀) | true |
Lean.Doc.Syntax.metadataContents.parenthesizer | Lean.DocString.Syntax | Lean.PrettyPrinter.Parenthesizer | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.eq_1 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : String.Slice),
String.Slice.Pattern.ForwardSliceSearcher.buildTable pat =
if h : pat.utf8ByteSize = 0 then Vector.cast ⋯ #v[]
else
let arr := Array.emptyWithCapacity pat.utf8ByteSize;
let arr' := arr.push 0;
String.Slice.Pattern.ForwardSliceSearcher.buildTable.go✝ pat arr' ⋯ ⋯ ⋯ | true |
Types.monoOverEquivalenceSet._proof_5 | Mathlib.CategoryTheory.Subobject.Types | ∀ (α : Type u_1) (X : Set α),
CategoryTheory.MonoOver.homMk (fun w => ⟨↑w, ⋯⟩) ⋯ =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoOver.mk Subtype.val) | false |
SzemerediRegularity.edgeDensity_chunk_uniform | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U V : Finset α} [Nonempty α],
P.parts.card * 16 ^ P.parts.card ≤ Fintype.card α →
100 ≤ 4 ^ P.parts.card * ε ^ 5 →
∀ (hU : U ∈ P.p... | true |
Lean.Meta.Sym.Simp.Config.mk.injEq | Lean.Meta.Sym.Simp.SimpM | ∀ (maxSteps maxDischargeDepth maxSteps_1 maxDischargeDepth_1 : ℕ),
({ maxSteps := maxSteps, maxDischargeDepth := maxDischargeDepth } =
{ maxSteps := maxSteps_1, maxDischargeDepth := maxDischargeDepth_1 }) =
(maxSteps = maxSteps_1 ∧ maxDischargeDepth = maxDischargeDepth_1) | true |
SimplexCategory.Truncated.δ₂_two_comp_σ₂_one_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {Z : CategoryTheory.ObjectProperty.FullSubcategory fun a => a.len ≤ 2}
(h : { obj := { len := 1 }, property := SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp
(SimplexCategory.Truncated.δ₂ 2 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1
Simp... | true |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.isPrimitiveRoot_exp_rat_of_even_num._proof_1_3 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ (q : ℚ) (n : ℤ), q.num = 2 • n → 2 * n.natAbs = q.num.natAbs | false |
Lean.Lsp.SignatureHelpOptions.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.SignatureHelpOptions → Lean.Lsp.SignatureHelpOptions → Sort u | false |
Mul.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Mul α} → {α' : Type u} → {t' : Mul α'} → α = α' → t ≍ t' → Mul.noConfusionType P t t' | false |
IsMinFilter.tendsto_principal_Ici | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {l : Filter α} {a : α},
IsMinFilter f l a → Filter.Tendsto f l (Filter.principal (Set.Ici (f a))) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.