name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.IsCofiltered.nonempty | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.IsCofiltered C], Nonempty C | true |
Lean.Widget.inst._@.Lean.Widget.Basic.2038268869._hygCtx._hyg.3 | Lean.Widget.Basic | TypeName Lean.Elab.InfoWithCtx | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate.noConfusionType | Lean.Meta.Tactic.Grind.Split | Sort u → Lean.Meta.Grind.SplitCandidate✝ → Lean.Meta.Grind.SplitCandidate✝ → Sort u | false |
CategoryTheory.Retract.op_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Retract X Y), h.op.i = h.r.op | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.isHashSelf_filterMapₘ._simp_1_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | false |
Std.DHashMap.isEmpty_insertMany_list | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)}, (m.insertMany l).isEmpty = (m.isEmpty && l.isEmpty) | true |
CategoryTheory.Limits.spanExt_inv_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z X' Y' Z' : C} (iX : X ≅ X') (iY : Y ≅ Y') (iZ : Z ≅ Z')
{f : X ⟶ Y} {g : X ⟶ Z} {f' : X' ⟶ Y'} {g' : X' ⟶ Z'}
(wf : CategoryTheory.CategoryStruct.comp iX.hom f' = CategoryTheory.CategoryStruct.comp f iY.hom)
(wg : CategoryTheory.CategoryStruct.comp i... | true |
CategoryTheory.IsAccessibleCategory.rec | Mathlib.CategoryTheory.Presentable.LocallyPresentable | {C : Type u} →
[hC : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.IsAccessibleCategory.{w, v, u} C → Sort u_1} →
((exists_cardinal : ∃ κ, ∃ (x : Fact κ.IsRegular), CategoryTheory.IsCardinalAccessibleCategory C κ) → motive ⋯) →
(t : CategoryTheory.IsAccessibleCategory.{w, v, u} C) → m... | false |
IntermediateField.isIntegral_iff | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {S : IntermediateField K L}
{x : ↥S}, IsIntegral K x ↔ IsIntegral K ↑x | true |
Lean.PrettyPrinter.Parenthesizer.ident.parenthesizer._regBuiltin.Lean.PrettyPrinter.Parenthesizer.ident.parenthesizer_1 | Lean.Parser | IO Unit | false |
AlgebraicGeometry.Scheme.IdealSheafData.support_antitone | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Antitone AlgebraicGeometry.Scheme.IdealSheafData.support | true |
CategoryTheory.CatCenter.localizationRingHom | Mathlib.CategoryTheory.Center.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →
[inst_3 : CategoryTheory.Preadditive C... | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary._proof_3 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ),
acc + ↑(Std.Time.Month.Ordinal.days leap idx) - acc = ↑(Std.Time.Month.Ordinal.days leap idx) | false |
Std.DHashMap.Internal.Raw₀.insertIfNew_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α} {v : β k}, (↑(m₁.insertIfNew k v)).Equiv ↑(m₂.insertIfNew k v) | true |
CategoryTheory.AddMon.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.AddMon C} →
{motive : M.Hom N → Sort u} →
(t : M.Hom N) →
((hom : M.X ⟶ N.X) →
[isAddMonHom_hom : CategoryTheory.IsAddMonHom hom] →... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.inter_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
IsCompact.locallyCompactSpace_of_mem_nhds_of_group | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {K : Set G},
IsCompact K → ∀ {x : G}, K ∈ nhds x → LocallyCompactSpace G | true |
ringChar.of_eq | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] {p : ℕ}, ringChar R = p → CharP R p | true |
WittVector.poly_eq_of_wittPolynomial_bind_eq | Mathlib.RingTheory.WittVector.IsPoly | ∀ (p : ℕ) [Fact (Nat.Prime p)] (f g : ℕ → MvPolynomial ℕ ℤ),
(∀ (n : ℕ), (MvPolynomial.bind₁ f) (wittPolynomial p ℤ n) = (MvPolynomial.bind₁ g) (wittPolynomial p ℤ n)) → f = g | true |
TwoSidedIdeal.orderIsoIsTwoSided_symm_apply | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : { I // I.IsTwoSided }),
(RelIso.symm TwoSidedIdeal.orderIsoIsTwoSided) I =
have this := ⋯;
(↑I).toTwoSided | true |
IsPreconnected.eq_one_or_eq_neg_one_of_sq_eq | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} {𝕜 : Type u_3} {f : α → 𝕜} {S : Set α} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace 𝕜]
[T1Space 𝕜] [inst_3 : Ring 𝕜] [NoZeroDivisors 𝕜],
IsPreconnected S → ContinuousOn f S → Set.EqOn (f ^ 2) 1 S → Set.EqOn f 1 S ∨ Set.EqOn f (-1) S | true |
Fin.preimage_natAdd_uIoc_natAdd | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n), Fin.natAdd m ⁻¹' Set.uIoc (Fin.natAdd m i) (Fin.natAdd m j) = Set.uIoc i j | true |
FirstOrder.Language.Substructure.closure_induction | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {s : Set M} {p : M → Prop} {x : M},
x ∈ (FirstOrder.Language.Substructure.closure L).toFun s →
(∀ x ∈ s, p x) → (∀ {n : ℕ} (f : L.Functions n), FirstOrder.Language.ClosedUnder f (setOf p)) → p x | true |
Equiv.compl | Mathlib.Order.OrderDual | {α : Type u_1} → {β : Type u_2} → α ≃ β → [Compl β] → Compl α | true |
Lean.Meta.Tactic.Cbv.CbvSimprocs.mk._flat_ctor | Lean.Meta.Tactic.Cbv.CbvSimproc | Lean.Meta.DiscrTree Lean.Meta.Tactic.Cbv.CbvSimprocEntry →
Lean.Meta.DiscrTree Lean.Meta.Tactic.Cbv.CbvSimprocEntry →
Lean.Meta.DiscrTree Lean.Meta.Tactic.Cbv.CbvSimprocEntry →
Lean.PHashSet Lean.Name → Lean.PHashSet Lean.Name → Lean.Meta.Tactic.Cbv.CbvSimprocs | false |
String.utf8ByteSize_sliceFrom | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos}, (s.sliceFrom p).utf8ByteSize = s.utf8ByteSize - p.offset.byteIdx | true |
CategoryTheory.CartesianClosed.uncurry | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{A X Y : C} →
[inst_2 : CategoryTheory.Closed A] → (Y ⟶ A ⟹ X) → (CategoryTheory.MonoidalCategoryStruct.tensorObj A Y ⟶ X) | true |
Mathlib.Tactic.Conv.Path.ctorElimType | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} → ℕ → Sort (max 1 u) | false |
_private.Std.Data.TreeSet.Lemmas.0.Std.TreeSet.size_toArray._simp_1_1 | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp}, t.toArray = t.toList.toArray | false |
Set.preimage_const | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} (b : β) (s : Set β) [inst : Decidable (b ∈ s)],
(fun x => b) ⁻¹' s = if b ∈ s then Set.univ else ∅ | true |
Multiset.union_le_iff | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Multiset α}, s ∪ t ≤ u ↔ s ≤ u ∧ t ≤ u | true |
genericPoint_specializes | Mathlib.Topology.Sober | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : QuasiSober α] [inst_2 : IrreducibleSpace α] (x : α),
genericPoint α ⤳ x | true |
Mathlib.Meta.NormNum.Result.toSimpResult.match_1 | Mathlib.Tactic.NormNum.Result | {u : Lean.Level} →
{α : Q(Type u)} →
{e : Q(«$α»)} →
(motive : (e' : Q(«$α»)) × Q(«$e» = «$e'») → Sort u_1) →
(x : (e' : Q(«$α»)) × Q(«$e» = «$e'»)) →
((expr : Q(«$α»)) → (proof? : Q(«$e» = «$expr»)) → motive ⟨expr, proof?⟩) → motive x | false |
PositiveLinearMap.gnsStarAlgHom._proof_13 | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : StarOrderedRing A] (f : A →ₚ[ℂ] ℂ),
IsScalarTower ℂ ℂ (UniformSpace.Completion f.PreGNS) | false |
Batteries.BinomialHeap.Imp.Heap.headD._f | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
(α → α → Bool) →
(x : Batteries.BinomialHeap.Imp.Heap α) → Batteries.BinomialHeap.Imp.Heap.below (motive := fun x => α → α) x → α → α | false |
Algebra.Extension.algebraBaseChange._proof_3 | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u_1} [inst : CommRing R] (T : Type u_2) [inst_1 : CommRing T] [inst_2 : Algebra R T], SMulCommClass R R T | false |
Filter.HasBasis.inf_neBot_iff | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s → ((l ⊓ l').NeBot ↔ ∀ ⦃i : ι⦄, p i → ∀ ⦃s' : Set α⦄, s' ∈ l' → (s i ∩ s').Nonempty) | true |
BialgEquiv.ofAlgEquiv._proof_7 | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Bialgebra R A] [inst_4 : Bialgebra R B] (f : A ≃ₐ[R] B), Function.LeftInverse f.invFun f.toFun | false |
CategoryTheory.Functor.PreservesRightHomologyOf.mk._flat_ctor | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {F : CategoryTheory.Functor C D}
[inst_4 : F.PreservesZeroMorphisms] {S : CategoryTh... | false |
_private.Aesop.Forward.State.0.Aesop.VariableMap.modifyM.match_3 | Aesop.Forward.State | (motive : Option Aesop.InstMap → Sort u_1) →
(x : Option Aesop.InstMap) → (Unit → motive none) → ((m : Aesop.InstMap) → motive (some m)) → motive x | false |
Matroid.mapSetEmbedding_indep_iff' | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {M : Matroid α} {f : ↑M.E ↪ β} {I : Set β},
(M.mapSetEmbedding f).Indep I ↔ ∃ I₀, M.Indep (Subtype.val '' I₀) ∧ I = ⇑f '' I₀ | true |
Topology.IsEmbedding.comapUniformSpace | Mathlib.Topology.UniformSpace.UniformEmbedding | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] → [u : UniformSpace β] → (f : α → β) → Topology.IsEmbedding f → UniformSpace α | true |
_private.Mathlib.NumberTheory.DirichletCharacter.Orthogonality.0.DirichletCharacter.sum_char_inv_mul_char_eq._simp_1_1 | Mathlib.NumberTheory.DirichletCharacter.Orthogonality | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | false |
Nat.add_mod_add_ite | Mathlib.Data.Nat.ModEq | ∀ (a b c : ℕ), ((a + b) % c + if c ≤ a % c + b % c then c else 0) = a % c + b % c | true |
Algebra.idealMap._proof_1 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : Semiring S] [inst_2 : Algebra R S] (I : Ideal R),
∀ x ∈ I, (algebraMap R S) x ∈ Ideal.map (algebraMap R S) I | false |
_private.Mathlib.RingTheory.WittVector.TeichmullerSeries.0.WittVector._aux_Mathlib_RingTheory_WittVector_TeichmullerSeries___unexpand_WittVector_1 | Mathlib.RingTheory.WittVector.TeichmullerSeries | Lean.PrettyPrinter.Unexpander | false |
Finset.toRight_union | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {u v : Finset (α ⊕ β)} [inst : DecidableEq α] [inst_1 : DecidableEq β],
(u ∪ v).toRight = u.toRight ∪ v.toRight | true |
HasSum.mul_of_nonarchimedean | Mathlib.Topology.Algebra.InfiniteSum.Nonarchimedean | ∀ {α : Type u_1} {β : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : UniformSpace R] [IsUniformAddGroup R]
[NonarchimedeanRing R] {f : α → R} {g : β → R} {a b : R},
HasSum f a → HasSum g b → HasSum (fun i => f i.1 * g i.2) (a * b) | true |
Asymptotics.isEquivalent_of_tendsto_one | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedField β] {u v : α → β} {l : Filter α},
Filter.Tendsto (u / v) l (nhds 1) → Asymptotics.IsEquivalent l u v | true |
Lean.Compiler.LCNF.CSE.State.noConfusion | Lean.Compiler.LCNF.CSE | {P : Sort u} → {t t' : Lean.Compiler.LCNF.CSE.State} → t = t' → Lean.Compiler.LCNF.CSE.State.noConfusionType P t t' | false |
Aesop.Queue.mk._flat_ctor | Aesop.Search.Queue.Class | {Q : Type} → BaseIO Q → (Q → Array Aesop.GoalRef → BaseIO Q) → (Q → BaseIO (Option Aesop.GoalRef × Q)) → Aesop.Queue Q | false |
TopologicalSpace.Clopens.coe_inf | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] (s t : TopologicalSpace.Clopens α), ↑(s ⊓ t) = ↑s ∩ ↑t | true |
Lean.Elab.Term.StructInst.FieldLHS.fieldIndex.injEq | Lean.Elab.StructInst | ∀ (ref : Lean.Syntax) (idx : ℕ) (ref_1 : Lean.Syntax) (idx_1 : ℕ),
(Lean.Elab.Term.StructInst.FieldLHS.fieldIndex ref idx = Lean.Elab.Term.StructInst.FieldLHS.fieldIndex ref_1 idx_1) =
(ref = ref_1 ∧ idx = idx_1) | true |
SimpleGraph.center_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1}, ⊤.center = Set.univ | true |
CategoryTheory.RetractArrow.map_i_left | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W} (h : CategoryTheory.RetractArrow f g) (F : CategoryTheory.Functor C D),
(h.map F).i.left = F.map (CategoryTheory.Arrow.Hom.left h.i) | true |
ContDiffMapSupportedIn.integralAgainstBilinLM_eq_integral | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {n : ℕ∞} {K : TopologicalSpace.Compacts E} {m : MeasurableSpace E}
[inst_3 : OpensMeasurableSpace E] {F₁ : Type u_5} {F₂ : Type u_6} {F₃ : Type u_7} [inst_4 : NormedAddCommGroup F₁]
[ins... | true |
_private.Mathlib.Data.Int.Interval.0.Finset.Ioc_succ_succ._simp_1_2 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | false |
Finset.filter_subset._simp_1 | Mathlib.Data.Finset.Filter | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Finset α), (Finset.filter p s ⊆ s) = True | false |
SheafOfModules.hom_ext_iff | Mathlib.Algebra.Category.ModuleCat.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} {X Y : SheafOfModules R} {f g : X ⟶ Y}, f = g ↔ f.val = g.val | true |
algebraMap_smul | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : Semiring A] [inst_2 : Algebra R A] {M : Type u_3}
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [IsScalarTower R A M] (r : R) (m : M),
(algebraMap R A) r • m = r • m | true |
pi_generateFrom_eq_finite | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {X : ι → Type u_9} {g : (a : ι) → Set (Set (X a))} [Finite ι],
(∀ (a : ι), ⋃₀ g a = Set.univ) →
Pi.topologicalSpace = TopologicalSpace.generateFrom {t | ∃ s, (∀ (a : ι), s a ∈ g a) ∧ t = Set.univ.pi s} | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_11 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ (A : Type u) [inst : CommRing A] (K : Type v) [inst_1 : Field K] [inst_2 : Algebra A K] [inst_3 : IsDomain A]
[inst_4 : ValuationRing A] [inst_5 : IsFractionRing A K] (x : K),
(x ∈ (ValuationRing.valuation A K).integer) = ∃ a, (algebraMap A K) a = x | false |
TwoSidedIdeal.asIdealOpposite | Mathlib.RingTheory.TwoSidedIdeal.Operations | {R : Type u_1} → [inst : Ring R] → TwoSidedIdeal R →o Ideal Rᵐᵒᵖ | true |
Mathlib.Meta.NormNum.evalIsSquareRat | Mathlib.Tactic.NormNum.IsSquare | Mathlib.Meta.NormNum.NormNumExt | true |
Std.MaxEqOr | Init.Data.Order.Classes | (α : Type u) → [Max α] → Prop | true |
BitVec.ofInt_iSizeToInt | Init.Data.SInt.Lemmas | ∀ (x : ISize), BitVec.ofInt System.Platform.numBits x.toInt = x.toBitVec | true |
Btw.rec | Mathlib.Order.Circular | {α : Type u_1} → {motive : Btw α → Sort u} → ((btw : α → α → α → Prop) → motive { btw := btw }) → (t : Btw α) → motive t | false |
MeasurableSpace.DynkinSystem.instPartialOrder._proof_3 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} (x x_1 x_2 : MeasurableSpace.DynkinSystem α), x ≤ x_1 → x_1 ≤ x_2 → x ≤ x_2 | false |
Std.DTreeMap.Internal.Impl.getKey._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] → (t : Std.DTreeMap.Internal.Impl α β) → (k : α) → Std.DTreeMap.Internal.Impl.contains k t = true → α | false |
Lean.Meta.Grind.AC.DiseqCnstrProof.erase_dup | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.DiseqCnstr → Lean.Meta.Grind.AC.DiseqCnstrProof | true |
Sum.swap_swap_eq | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2}, Sum.swap ∘ Sum.swap = id | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_382 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
UniformSpace.hausdorff | Mathlib.Topology.UniformSpace.Closeds | (α : Type u_1) → [UniformSpace α] → UniformSpace (Set α) | true |
CovariantDerivative.difference | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | {𝕜 : 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} →
... | true |
CategoryTheory.MorphismProperty.HasPushoutsAgainst.casesOn | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{P P' : CategoryTheory.MorphismProperty C} →
{motive : P.HasPushoutsAgainst P' → Sort u_1} →
(t : P.HasPushoutsAgainst P') →
((hasPushoutsAlong : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), P' f → P.HasPushoutsAlong f) → motive ⋯) → motive t | false |
Sum.getRight_eq_getRight? | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {x : α ⊕ β} (h₁ : x.isRight = true) (h₂ : x.getRight?.isSome = true),
x.getRight h₁ = x.getRight?.get h₂ | true |
Lean.Meta.Sym.getInt16Value? | Lean.Meta.Sym.LitValues | Lean.Expr → OptionT Id Int16 | true |
Submodule.instDiv._proof_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(I J : Submodule R A) {a b : A},
a ∈ {x | ∀ y ∈ J, x * y ∈ I} → b ∈ {x | ∀ y ∈ J, x * y ∈ I} → ∀ y ∈ J, (a + b) * y ∈ I | false |
SeminormedCommGroup | Mathlib.Analysis.Normed.Group.Defs | Type u_8 → Type u_8 | true |
Topology.IsQuotientMap.trivializationOfVAddDisjoint._proof_8 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_2} {X : Type u_1} {f : E → X} {G : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G E] (U : Set E),
(∀ (g : G) (e : E), f (g +ᵥ e) = f e) → ∀ (g : G) ⦃x : X⦄, x ∈ f '' U → x ∈ f '' (fun x => g +ᵥ x) ⁻¹' U | false |
Computability.«term_≡ᵀ_» | Mathlib.Computability.TuringDegree | Lean.TrailingParserDescr | true |
Vector.push_inj_left | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a : α} {xs ys : Vector α n}, xs.push a = ys.push a ↔ xs = ys | true |
Lean.mkPtrSet | Lean.Util.PtrSet | {α : Type} → optParam ℕ 64 → Lean.PtrSet α | true |
Subtype.forall_set_subtype | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {t : Set α} (p : Set α → Prop), (∀ (s : Set ↑t), p (Subtype.val '' s)) ↔ ∀ s ⊆ t, p s | true |
Lean.Widget.GetGoToLocationParams.noConfusionType | Lean.Server.FileWorker.WidgetRequests | Sort u → Lean.Widget.GetGoToLocationParams → Lean.Widget.GetGoToLocationParams → Sort u | false |
SimpleGraph.Subgraph.botIso._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (x : ↑⊥.verts), (False.elim ⋯).elim = x | false |
CategoryTheory.Grothendieck.map._proof_2 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat}
(α : F ⟶ G) (X : CategoryTheory.Grothendieck F),
{ base := (CategoryTheory.CategoryStruct.id X).base,
fiber :=
CategoryTheory.CategoryStruct.comp ((CategoryTheory.eqToHom ⋯).toNatTrans.ap... | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.isSeparated._simp_5 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map g) (AlgebraicGeometry.Spec.map f) =
AlgebraicGeometry.Spec.map (CategoryTheory.CategoryStruct.comp f g) | false |
String.Slice.contains_char_eq_contains_beq | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice}, s.contains c = s.contains fun x => x == c | true |
CategoryTheory.SimplicialObject.Splitting.IndexSet.id | Mathlib.AlgebraicTopology.SimplicialObject.Split | (Δ : SimplexCategoryᵒᵖ) → CategoryTheory.SimplicialObject.Splitting.IndexSet Δ | true |
Turing.TM1to0.trAux._sunfold | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
(M : Λ → Turing.TM1.Stmt Γ Λ σ) → Γ → Turing.TM1.Stmt Γ Λ σ → σ → Turing.TM1to0.Λ' M × Turing.TM0.Stmt Γ | false |
ContinuousAlternatingMap.piLIE._proof_6 | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {ι' : Type u_2} {F : ι' → Type u_3}
[inst_1 : (i' : ι') → SeminormedAddCommGroup (F i')] [inst_2 : (i' : ι') → NormedSpace 𝕜 (F i')],
SMulCommClass 𝕜 𝕜 ((i : ι') → F i) | false |
Function.IsFixedPt.eq_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u₁} (f : α → α) (x : α), Function.IsFixedPt f x = (f x = x) | true |
Dvd.noConfusion | Init.Prelude | {P : Sort u} →
{α : Type u_1} → {t : Dvd α} → {α' : Type u_1} → {t' : Dvd α'} → α = α' → t ≍ t' → Dvd.noConfusionType P t t' | false |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁.elim | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
t.ctorIdx = 9 →
((c : Lean.Meta.Grind.Arith.Cutsat.CooperSplit) →
motive_7 (Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁ c)) →
motive_7 t | false |
Algebra.WeaklyQuasiFiniteAt.of_quasiFiniteAt_residueField | Mathlib.RingTheory.QuasiFinite.Weakly | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
(q : Ideal S) [inst_3 : q.IsPrime] [inst_4 : p.IsPrime] [q.LiesOver p] (Q : Ideal (p.Fiber S)) [inst_6 : Q.IsPrime],
Ideal.comap Algebra.TensorProduct.includeRight.toRingHom Q = q →
∀ [Algebra.QuasiFin... | true |
Std.TreeSet.Raw.maxD_eq_iff_mem_and_forall | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp],
t.WF → t.isEmpty = false → ∀ {km fallback : α}, t.maxD fallback = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp k km).isLE = true | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.σ₀Iter_succ._proof_1_4 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ} (h : n + (i + 1) = m) (k : Fin ({ len := m }.len + 1)),
(CategoryTheory.ConcreteCategory.hom (SimplexCategory.σ₀Iter i ⋯)) k ≤ Fin.castSucc 0 →
(CategoryTheory.ConcreteCategory.hom (SimplexCategory.σ₀Iter i ⋯)) k ≠ Fin.last (n + 1) | false |
CompactlySupportedContinuousMap.instInf._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : SemilatticeInf β] [inst_2 : Zero β]
[inst_3 : TopologicalSpace β] (f g : CompactlySupportedContinuousMap α β), HasCompactSupport (⇑f ⊓ ⇑g) | false |
_private.Mathlib.Algebra.Algebra.Bilinear.0.LinearMap.pow_mulLeft.match_1_1 | Mathlib.Algebra.Algebra.Bilinear | ∀ (motive : ℕ → Prop) (n : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive n | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.