name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Time.Minute.Ordinal.toOffset | Std.Time.Time.Unit.Minute | Std.Time.Minute.Ordinal → Std.Time.Minute.Offset | true |
Topology.scottHausdorff_le_isLawson | Mathlib.Topology.Order.LawsonTopology | ∀ {α : Type u_1} [inst : Preorder α] (L : TopologicalSpace α) [Topology.IsLawson α],
Topology.scottHausdorff α Set.univ ≤ L | true |
Lean.Compiler.LCNF.CtorFieldInfo.ctorElimType | Lean.Compiler.LCNF.ToImpureType | {motive : Lean.Compiler.LCNF.CtorFieldInfo → Sort u} → ℕ → Sort (max 1 u) | false |
Lean.getPPSorrySource | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → Bool | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.casesOn | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.NormalizePattern.Context✝ → Sort u} →
(t : Lean.Meta.Grind.NormalizePattern.Context✝) →
((symPrios : Lean.Meta.Grind.SymbolPriorities) →
(minPrio : ℕ) → motive { symPrios := symPrios, minPrio := minPrio }) →
motive t | false |
Condensed.lanSheafProfinite._proof_1 | Mathlib.Condensed.Discrete.Colimit | ∀ (X : Type (u_1 + 1)),
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology Profinite)
(Condensed.lanPresheaf (Condensed.locallyConstantPresheaf X)) | false |
Finset.Ioo_insert_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] {a b : α} [inst_2 : DecidableEq α],
a < b → insert a (Finset.Ioo a b) = Finset.Ico a b | true |
_private.Init.Data.Array.Basic.0.Array.isPrefixOfAux._proof_4 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as bs : Array α), as.size ≤ bs.size → ∀ i < as.size, i < bs.size | false |
WithSeminorms.congr | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} {ι' : Type u_10} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] {p : SeminormFamily 𝕜 E ι} {q : SeminormFamily 𝕜 E ι'} [t : TopologicalSpace E],
WithSeminorms p → Seminorm.IsBounded p q LinearMap.id → Seminorm.IsBounded q p LinearMap.id → W... | true |
MonoidAlgebra.singleOneAlgHom._proof_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_3} {A : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Monoid M] (r : R),
(↑↑MonoidAlgebra.singleOneRingHom).toFun ((algebraMap R A) r) = (algebraMap R (MonoidAlgebra A M)) r | false |
Std.TreeMap.unitOfList_singleton | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {k : α}, Std.TreeMap.unitOfList [k] cmp = ∅.insertIfNew k () | true |
_private.Mathlib.RingTheory.LocalRing.NonLocalRing.0.IsLocalRing.not_isLocalRing_of_nontrivial_pi.match_1_1 | Mathlib.RingTheory.LocalRing.NonLocalRing | ∀ {ι : Type u_1} (motive : (∃ x y, x ≠ y) → Prop) (x : ∃ x y, x ≠ y),
(∀ (i₁ i₂ : ι) (hi : i₁ ≠ i₂), motive ⋯) → motive x | false |
Cardinal.toENatAux_eq_zero | Mathlib.SetTheory.Cardinal.ENat | ∀ {x : Cardinal.{u_1}}, x.toENatAux = 0 ↔ x = 0 | true |
IsConvexMetricSpace.mk | Mathlib.Analysis.Convex.MetricSpace | ∀ {X : Type u_1} [inst : ConvexSpace ℝ X] [inst_1 : MetricSpace X],
(∀ (f : StdSimplex ℝ ℕ) (x y : ℕ → X),
dist (ConvexSpace.convexCombination (StdSimplex.map x f)) (ConvexSpace.convexCombination (StdSimplex.map y f)) ≤
f.sum fun i r => r * dist (x i) (y i)) →
IsConvexMetricSpace X | true |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.comm | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat)}
{ι : Type t} {S : C} {X : ι → C} {f : (i : ι) → X i ⟶ S} {D₁ D₂ : F.DescentDataAsCoalgebra f} (self : D₁.Hom D₂)
(i₁ i₂ : ι)... | true |
_private.Std.Internal.Http.Internal.Char.0.Std.Http.Internal.Char.qdtext.match_1.eq_1 | Std.Internal.Http.Internal.Char | ∀ (motive : Char → Sort u_1) (h_1 : Unit → motive '\t') (h_2 : Unit → motive ' ') (h_3 : Unit → motive '!')
(h_4 : (x : Char) → motive x),
(match '\t' with
| '\t' => h_1 ()
| ' ' => h_2 ()
| '!' => h_3 ()
| x => h_4 x) =
h_1 () | true |
Aesop.instHashableSlotIndex | Aesop.Forward.SlotIndex | Hashable Aesop.SlotIndex | true |
_private.Mathlib.MeasureTheory.Integral.CircleAverage.0.Real.ContinuousOn.eq_of_eqOn_Ioo._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleAverage | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (Set.Ioo b a ⊆ Set.Ioc b a) = True | false |
SymmetricPower.instAddCommGroup._proof_11 | Mathlib.LinearAlgebra.TensorPower.Symmetric | ∀ (ι R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(a : SymmetricPower R ι M), -a + a = 0 | false |
_private.Std.Data.Iterators.Lemmas.Combinators.TakeWhile.0.Std.Iter.val_step_takeWhile.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.TakeWhile | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 () | true |
Lean.Elab.Tactic.elabSimpLocals | Lean.Elab.Tactic.Simp | Lean.Meta.SimpTheorems → Lean.Elab.Tactic.SimpKind → Lean.MetaM Lean.Meta.SimpTheorems | true |
Batteries.BinomialHeap.Imp.Heap.casesOn | Batteries.Data.BinomialHeap.Basic | {α : Type u} →
{motive : Batteries.BinomialHeap.Imp.Heap α → Sort u_1} →
(t : Batteries.BinomialHeap.Imp.Heap α) →
motive Batteries.BinomialHeap.Imp.Heap.nil →
((rank : ℕ) →
(val : α) →
(node : Batteries.BinomialHeap.Imp.HeapNode α) →
(next : Batteries.Binom... | false |
USize.and_comm | Init.Data.UInt.Bitwise | ∀ (a b : USize), a &&& b = b &&& a | true |
Lean.Lsp.RefIdent.fromJsonRepr | Lean.Data.Lsp.Internal | Lean.Lsp.RefIdent.RefIdentJsonRepr → Lean.Lsp.RefIdent | true |
List.exists_map_eq_of_sorted_nonempty_iff_wbtw | Mathlib.Analysis.Convex.BetweenList | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] {l : List P} (hl : l ≠ []),
(∃ l', l'.SortedLE ∧ List.map (⇑(AffineMap.lineMap (l.head hl) (l.getLast hl))) l' = l) ↔ List.Wbtw R ... | true |
smulMonoidWithZeroHom | Mathlib.Algebra.GroupWithZero.Action.Basic | {M₀ : Type u_5} →
{N₀ : Type u_6} →
[inst : MonoidWithZero M₀] →
[inst_1 : MulZeroOneClass N₀] →
[inst_2 : MulActionWithZero M₀ N₀] → [IsScalarTower M₀ N₀ N₀] → [SMulCommClass M₀ N₀ N₀] → M₀ × N₀ →*₀ N₀ | true |
tendsto_pow_div_pow_atTop_atTop | Mathlib.Analysis.Asymptotics.SpecificAsymptotics | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {p q : ℕ},
q < p → Filter.Tendsto (fun x => x ^ p / x ^ q) Filter.atTop Filter.atTop | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_35 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j : ℕ), j + 1 ≤ i → i + 1 ≤ tail.length → j < tail.length | false |
CategoryTheory.Limits.MonoCoprod.mono_inl_iff | Mathlib.CategoryTheory.Limits.MonoCoprod | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A B : C} {c₁ c₂ : CategoryTheory.Limits.BinaryCofan A B}
(hc₁ : CategoryTheory.Limits.IsColimit c₁) (hc₂ : CategoryTheory.Limits.IsColimit c₂),
CategoryTheory.Mono c₁.inl ↔ CategoryTheory.Mono c₂.inl | true |
CategoryTheory.Pi.monoidalCategory._proof_17 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (W X Y Z : (i : I) → C i),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.as... | false |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.restoreM_refl._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | false |
Cardinal.aleph0_le_beth | Mathlib.SetTheory.Cardinal.Aleph | ∀ (o : Ordinal.{u_1}), Cardinal.aleph0 ≤ Cardinal.beth o | true |
le_schnirelmannDensity_iff | Mathlib.Combinatorics.Schnirelmann | ∀ {A : Set ℕ} [inst : DecidablePred fun x => x ∈ A] {x : ℝ},
x ≤ schnirelmannDensity A ↔ ∀ (n : ℕ), 0 < n → x ≤ ↑{a ∈ Finset.Ioc 0 n | a ∈ A}.card / ↑n | true |
Matrix.trace_smul | Mathlib.LinearAlgebra.Matrix.Trace | ∀ {n : Type u_3} {α : Type u_5} {R : Type u_6} [inst : Fintype n] [inst_1 : AddCommMonoid R] [inst_2 : DistribSMul α R]
(r : α) (A : Matrix n n R), (r • A).trace = r • A.trace | true |
Set.finite_iUnion_of_subsingleton | Mathlib.Data.Set.Finite.Lattice | ∀ {α : Type u} {ι : Sort u_1} [Subsingleton ι] {s : ι → Set α}, (⋃ i, s i).Finite ↔ ∀ (i : ι), (s i).Finite | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.aux_summable_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {k : ℕ}, 1 ≤ k → ∀ (x : ℂ), Summable fun n => (x - (↑n + 1)) ^ (-1 - ↑k) | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.Collector.State.rec | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.Collector.State✝ → Sort u} →
((patterns : Array Lean.Expr) → (done : Bool) → motive { patterns := patterns, done := done }) →
(t : Lean.Meta.Grind.Collector.State✝) → motive t | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g},
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl kf.pt).hom
(CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.Kernel... | false |
Lean.Meta.Grind.AC.Struct.denote._default | Lean.Meta.Tactic.Grind.AC.Types | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.AC.Expr | false |
Antivary.neg_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : AddCommGroup β]
[inst_2 : PartialOrder β] [IsOrderedAddMonoid β] {f : ι → α} {g : ι → β}, Antivary f g → Monovary f (-g) | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.canBeSynthesized | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.FVarIdSet → Lean.FVarIdSet → Lean.Expr → Lean.MetaM Bool | true |
Setoid.comap_eq | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {r : Setoid β}, Setoid.comap f r = Setoid.ker (Quotient.mk'' ∘ f) | true |
_private.Init.Data.Fin.Lemmas.0.Fin.succ_ne_zero.match_1_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (motive : (x : Fin n) → x.succ = 0 → Prop) (x : Fin n) (x_1 : x.succ = 0),
(∀ (k : ℕ) (isLt : k < n) (heq : ⟨k, isLt⟩.succ = 0), motive ⟨k, isLt⟩ heq) → motive x x_1 | false |
«tactic#adaptation_note_» | Mathlib.Tactic.AdaptationNote | Lean.ParserDescr | true |
Batteries.RunningStats.mean | Batteries.Data.RunningStats | Batteries.RunningStats → Float | true |
AlgebraicGeometry.LocallyRingedSpace.Γevaluation._proof_1 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ (X : AlgebraicGeometry.LocallyRingedSpace) (x : ↑X.toTopCat), x ∈ ⊤ | false |
CategoryTheory.PreGaloisCategory.instIsPretransitiveObjFiniteObjFintypeCatOfIsConnected | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.GaloisCategory C] (G : Type u_1) [inst_2 : Group G]
[inst_3 : (X : C) → MulAction G (F.obj X).obj] [CategoryTheory.PreGaloisCategory.FiberFunctor F]
[inst_5 : TopologicalSpace G] [inst_6 ... | true |
AlgebraicGeometry.StructureSheaf.const._proof_4 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R] (g : R),
∀ U ≤ PrimeSpectrum.basicOpen g,
∀ (V : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (i : V ⟶ Opposite.unop (Opposite.op U))
(x : ↥V), ↑(i x) ∈ PrimeSpectrum.basicOpen g | false |
BumpCovering.locallyFinite' | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {s : optParam (Set X) Set.univ} (self : BumpCovering ι X s),
LocallyFinite fun i => Function.support ⇑(self.toFun i) | true |
Std.Stream.takeTR.loop._unsafe_rec | Batteries.Data.Stream | {σ : Type u_1} → {α : Type u_2} → [Std.Stream σ α] → σ → List α → ℕ → List α × σ | false |
LieHom.coe_injective | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieAlgebra R L₁]
[inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂], Function.Injective DFunLike.coe | true |
CategoryTheory.Limits.ι_comp_colimitUnopIsoOpLimit_hom | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) [inst_2 : CategoryTheory.Limits.HasLimit F] (j : J),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F.unop j)
(CategoryTheory.Limits... | true |
CategoryTheory.CostructuredArrow.w_assoc | 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 : A ⟶ B) {Z : D}
(h : (CategoryTheory.Functor.fromPUnit T).obj B.right ⟶ Z),
CategoryTheory.CategoryStruc... | true |
Lean.Meta.Grind.Arith.Cutsat.Case.kind | Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM | Lean.Meta.Grind.Arith.Cutsat.Case → Lean.Meta.Grind.Arith.Cutsat.CaseKind | true |
_private.Mathlib.Data.Fin.VecNotation.0.Matrix.cons_swap._proof_1_3 | Mathlib.Data.Fin.VecNotation | ∀ {n : ℕ} (k : Fin n.succ) (hk₀ : k ≠ 0), k = ⟨↑k - 1, ⋯⟩.succ | false |
String.Pos.Raw.lt_of_lt_of_le | Init.Data.String.PosRaw | ∀ {a b c : String.Pos.Raw}, a < b → b ≤ c → a < c | true |
Submodule.instAddCommMonoidWithOne._proof_2 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : Semiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Module R A] (n : ℕ),
(n + 1).unaryCast = n.unaryCast + 1 | false |
Lean.instInhabitedClassState.default | Lean.Class | Lean.ClassState | true |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Lemmas.0.aestronglyMeasurable_withDensity_iff._simp_1_3 | Mathlib.MeasureTheory.Function.StronglyMeasurable.Lemmas | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | false |
Algebra.IsCentral.of_algEquiv | Mathlib.Algebra.Central.Basic | ∀ (K : Type u) [inst : CommSemiring K] (D D' : Type v) [inst_1 : Semiring D] [inst_2 : Algebra K D]
[h : Algebra.IsCentral K D] [inst_3 : Semiring D'] [inst_4 : Algebra K D'] (e : D ≃ₐ[K] D'), Algebra.IsCentral K D' | true |
CFC.abs_mul_abs | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Abs | ∀ {A : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : TopologicalSpace A] [inst_3 : Module ℝ A]
[inst_4 : SMulCommClass ℝ A A] [inst_5 : IsScalarTower ℝ A A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_7 : PartialOrder A]
[inst_8 : StarOrderedRing A] [inst_9 : Nonn... | true |
PresheafOfModules.isoMk | Mathlib.Algebra.Category.ModuleCat.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{M₁ M₂ : PresheafOfModules R} →
(app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X) →
autoParam
(∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (M₁.map ... | true |
Topology.CWComplex.isClosed_inter_cellFrontier_succ_of_le_isClosed_inter_closedCell | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C : Set X} [inst : Topology.CWComplex C] [T2Space X] {A : Set X} {n : ℕ},
(∀ m ≤ n, ∀ (j : Topology.RelCWComplex.cell C m), IsClosed (A ∩ Topology.RelCWComplex.closedCell m j)) →
∀ (j : Topology.RelCWComplex.cell C (n + 1)), IsClosed (A ∩ Topology.RelCWComplex.cellFronti... | true |
Order.coheight_pos._simp_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {x : α}, (0 < Order.coheight x) = ¬IsMax x | false |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._unsafe_rec | Init.Data.Nat.Power2.Basic | ℕ → (power : ℕ) → power > 0 → ℕ | false |
CondensedSet.ofSheafProfinite | Mathlib.Condensed.Explicit | (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))) →
[CategoryTheory.Limits.PreservesFiniteProducts F] → CategoryTheory.regularTopology.EqualizerCondition F → CondensedSet | true |
IsPrimitiveRoot.eq_pow_of_mem_rootsOfUnity | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [IsDomain R] {k : ℕ} [NeZero k] {ζ ξ : Rˣ},
IsPrimitiveRoot ζ k → ξ ∈ rootsOfUnity k R → ∃ i < k, ζ ^ i = ξ | true |
Std.TreeMap.Raw.isSome_getKey?_eq_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, (t.getKey? a).isSome = t.contains a | true |
CompHausLike.is_compact | Mathlib.Topology.Category.CompHausLike.Basic | ∀ {P : TopCat → Prop} (self : CompHausLike P), CompactSpace ↑self.toTop | true |
Lean.IR.Sorry.State.modified | Lean.Compiler.IR.Sorry | Lean.IR.Sorry.State → Bool | true |
withPtrAddrUnsafe | Init.Util | {α : Type u} → {β : Type v} → α → (k : USize → β) → (∀ (u₁ u₂ : USize), k u₁ = k u₂) → β | true |
_private.Init.Data.List.Impl.0.List.intercalateTR.go._unsafe_rec | Init.Data.List.Impl | {α : Type u_1} → Array α → List α → List (List α) → Array α → List α | false |
HomogeneousLocalization.hasPow._proof_2 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {A : Type u_2} {σ : Type u_1} [inst : CommRing A] [inst_1 : SetLike σ A] [AddSubgroupClass σ A], AddSubmonoidClass σ A | false |
CategoryTheory.GrothendieckTopology.toPlus_plusLift_assoc | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
[inst_3 : ∀ (X : C), Categ... | true |
AlgebraicGeometry.SheafedSpace.Γ | Mathlib.Geometry.RingedSpace.SheafedSpace | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Functor (AlgebraicGeometry.SheafedSpace C)ᵒᵖ C | true |
BitVec.zero_iff_eq_false | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x = 0#w ↔ ∀ (i : ℕ), x.getLsbD i = false | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.ofSliceFrom_ne_startPos._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p : s.Pos} {q r : (s.sliceFrom p).Pos}, (q < r) = (String.Pos.ofSliceFrom q < String.Pos.ofSliceFrom r) | false |
interior_Iic | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[NoMaxOrder α] {a : α}, interior (Set.Iic a) = Set.Iio a | true |
Lean.Expr.inferImplicit._unsafe_rec | Lean.Expr | Lean.Expr → ℕ → Bool → Lean.Expr | false |
MeasureTheory.Measure.map_def | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_4} {β : Type u_5} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (f : α → β)
(μ : MeasureTheory.Measure α),
MeasureTheory.Measure.map f μ =
if hf : AEMeasurable f μ then (MeasureTheory.Measure.mapₗ (AEMeasurable.mk f hf)) μ else 0 | true |
StandardBorelSpace.prod | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] {β : Type u_2} [inst_1 : MeasurableSpace β] [StandardBorelSpace α]
[StandardBorelSpace β], StandardBorelSpace (α × β) | true |
_private.Mathlib.Tactic.CancelDenoms.Core.0.Mathlib.Tactic.CancelDenoms.derive.match_5 | Mathlib.Tactic.CancelDenoms.Core | (motive :
(u : Lean.Level) ×
(α :
have u := u;
Q(Type u)) ×
Q(«$α») →
Sort u_1) →
(__discr :
(u : Lean.Level) ×
(α :
have u := u;
Q(Type u)) ×
Q(«$α»)) →
((u : Lean.Level) →
(tp :
have u := u;
... | false |
MeasureTheory.withDensity_one | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ.withDensity 1 = μ | true |
Module.Invertible.linearEquivOfLeftInverse | Mathlib.RingTheory.PicardGroup | {R : Type u} →
{M : Type v} →
{N : Type u_1} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] →
[inst_4 : Module R N] →
[Module.Invertible R M] →
[Module.Invertible R N] →... | true |
IntermediateField.adjoin.fieldCoe | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | (F : Type u_1) →
[inst : Field F] →
{E : Type u_2} → [inst_1 : Field E] → [inst_2 : Algebra F E] → (S : Set E) → CoeTC F ↥(IntermediateField.adjoin F S) | true |
Lean.Meta.Grind.Order.ToPropagate.eqFalse.injEq | Lean.Meta.Tactic.Grind.Order.Types | ∀ (c : Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId) (e : Lean.Expr) (u v : Lean.Meta.Grind.Order.NodeId)
(k k' : Lean.Meta.Grind.Order.Weight) (c_1 : Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId)
(e_1 : Lean.Expr) (u_1 v_1 : Lean.Meta.Grind.Order.NodeId) (k_1 k'_1 : Lean.Meta.Grind.Order.We... | true |
CategoryTheory.Retract.retract._autoParam | Mathlib.CategoryTheory.Retract | Lean.Syntax | false |
Aesop.SlotIndex.rec | Aesop.Forward.SlotIndex | {motive : Aesop.SlotIndex → Sort u} → ((toNat : ℕ) → motive { toNat := toNat }) → (t : Aesop.SlotIndex) → motive t | false |
iSup_disjointed | Mathlib.Order.Disjointed | ∀ {α : Type u_1} {ι : Type u_2} [inst : CompleteBooleanAlgebra α] [inst_1 : PartialOrder ι]
[inst_2 : LocallyFiniteOrderBot ι] (f : ι → α), ⨆ i, disjointed f i = ⨆ i, f i | true |
_private.Std.Time.DateTime.PlainDateTime.0.Std.Time.PlainDateTime.ofTimestampAssumingUTC._proof_12 | Std.Time.DateTime.PlainDateTime | 0 < 60 | false |
Std.TreeMap.Raw.«term_~m_» | Std.Data.TreeMap.Raw.Basic | Lean.TrailingParserDescr | true |
Lean.Lsp.instReprLineRange.repr | Lean.Data.Lsp.Extra | Lean.Lsp.LineRange → ℕ → Std.Format | true |
Lean.Meta.Contradiction.Config.emptyType._default | Lean.Meta.Tactic.Contradiction | Bool | false |
ConvexSpace.ofConvex._proof_2 | Mathlib.Analysis.Convex.MetricSpace | ∀ {R : Type u_2} {E : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : AddCommGroup E] [inst_4 : Module R E] {S : Set E} (H : Convex R S) (f : StdSimplex R (StdSimplex R ↑S)),
⟨ConvexSpace.convexCombination
(StdSimplex.map Subtype.val
(StdSimplex.map (... | false |
Matrix.IsHermitian.det_eq_prod_eigenvalues | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
(hA : A.IsHermitian), A.det = ∏ i, ↑(hA.eigenvalues i) | true |
TopModuleCat.instIsRightAdjointModuleCatForget₂ContinuousLinearMapIdCarrierLinearMap | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u) [inst : Ring R] [inst_1 : TopologicalSpace R],
(CategoryTheory.forget₂ (TopModuleCat R) (ModuleCat R)).IsRightAdjoint | true |
AddSubgroup.unop_inf | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : AddGroup G] (S₁ S₂ : AddSubgroup Gᵃᵒᵖ), (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitTraceNodesM._auto_1 | Mathlib.Tactic.DefEqAbuse | Lean.Syntax | false |
Std.ExtTreeMap.getElem_modify_self | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{f : β → β} {hc : k ∈ t.modify k f}, (t.modify k f)[k] = f t[k] | true |
Lean.initFn._@.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.671733626._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | IO (Lean.Option Bool) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.