name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
alternatingGroup.normal | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], (alternatingGroup α).Normal | true |
SemimoduleCat.MonoidalCategory.associator | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | {R : Type u} →
[inst : CommSemiring R] →
(M : SemimoduleCat R) →
(N : SemimoduleCat R) →
(K : SemimoduleCat R) →
SemimoduleCat.MonoidalCategory.tensorObj (SemimoduleCat.MonoidalCategory.tensorObj M N) K ≅
SemimoduleCat.MonoidalCategory.tensorObj M (SemimoduleCat.MonoidalCategor... | true |
AddUnits.val_zero | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α], ↑0 = 0 | true |
StalkSkyscraperPresheafAdjunctionAuxs.fromStalk._proof_2 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_2, u_1} C] [inst_2 : CategoryTheory.Limits.HasTerminal C] {c : C}
(U : (TopologicalSpace.OpenNhds p₀)ᵒᵖ), (if p₀ ∈ ↑(Opposite.unop U) then c else ⊤_ C) = c | false |
Stream'.Seq.Corec.f.match_1 | Mathlib.Data.Seq.Defs | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((b : β) → motive (some b)) → motive x | false |
RCLike.re_eq_complex_re | Mathlib.Analysis.Complex.Basic | ⇑RCLike.re = Complex.re | true |
_private.Mathlib.Lean.Expr.Basic.0.Lean.ConstantInfo.isDef.match_1 | Mathlib.Lean.Expr.Basic | (motive : Lean.ConstantInfo → Sort u_1) →
(x : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((x : Lean.ConstantInfo) → motive x) → motive x | false |
Aesop.GoalData.lastExpandedInIteration | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → Aesop.Iteration | true |
isCycle_finRotate_of_le | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ}, 2 ≤ n → (finRotate n).IsCycle | true |
Lean.Grind.CommRing.Expr.toPolyC.go._unsafe_rec | Init.Grind.Ring.CommSolver | ℕ → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Poly | false |
OpenPartialHomeomorph.contDiff_unitBallBall | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ {n : ℕ∞} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {c : E} {r : ℝ} (hr : 0 < r),
ContDiff ℝ ↑n ↑(OpenPartialHomeomorph.unitBallBall c r hr) | true |
Algebra.RingHom.adjoinAlgebraMap.congr_simp | Mathlib.RingTheory.Adjoin.Singleton | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommSemiring A] [inst_1 : CommSemiring B]
[inst_2 : CommSemiring C] [inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C]
[inst_6 : IsScalarTower A B C] (b : B), Algebra.RingHom.adjoinAlgebraMap b = Algebra.RingHom.adjoinAlgebraMap b | true |
EReal.coe_zsmul | Mathlib.Data.EReal.Operations | ∀ (n : ℤ) (x : ℝ), ↑(n • x) = n • ↑x | true |
Std.Roc.toList_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.Rxc.IsAlwaysFinite α], r.toArray.toList = r.toList | true |
_private.Mathlib.Logic.Relation.0.Relation.map_onFun_map_eq_map._proof_1_2 | Mathlib.Logic.Relation | ∀ {α : Sort u_2} {β : Sort u_1} {r : α → α → Prop} (f : α → β),
Relation.Map (fun x y => Relation.Map r f f (f x) (f y)) f f = Relation.Map r f f | false |
PairReduction.edist_le_of_mem_pairSet | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : PseudoEMetricSpace T] {a c : ENNReal} {n : ℕ} {J : Finset T} [inst_1 : DecidableEq T],
1 < a → ↑J.card ≤ a ^ n → ∀ {s t : T}, (s, t) ∈ PairReduction.pairSet J a c → edist s t ≤ ↑n * c | true |
_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAnalysis.testTacticSeq._sparseCasesOn_9 | Mathlib.Tactic.TacticAnalysis | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
AlgebraicGeometry.PresheafedSpace.Hom.mk._flat_ctor | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : AlgebraicGeometry.PresheafedSpace C} →
(base : ↑X ⟶ ↑Y) → (Y.presheaf ⟶ (TopCat.Presheaf.pushforward C base).obj X.presheaf) → X.Hom Y | false |
Lean.Grind.ToInt.wrap_toInt | Init.Grind.ToInt | ∀ {α : Type u_1} (I : Lean.Grind.IntInterval) [inst : Lean.Grind.ToInt α I] (x : α), I.wrap ↑x = ↑x | true |
Language.isRegular_iff_finite_range_leftQuotient | Mathlib.Computability.MyhillNerode | ∀ {α : Type u} {L : Language α}, L.IsRegular ↔ (Set.range L.leftQuotient).Finite | true |
_private.Lean.Widget.InteractiveGoal.0.Lean.Widget.withGoalCtx.match_1 | Lean.Widget.InteractiveGoal | (motive : Option Lean.MetavarDecl → Sort u_1) →
(x : Option Lean.MetavarDecl) →
((mvarDecl : Lean.MetavarDecl) → motive (some mvarDecl)) → ((x : Option Lean.MetavarDecl) → motive x) → motive x | false |
Lean.Meta.DiagSummary._sizeOf_inst | Lean.Meta.Diagnostics | SizeOf Lean.Meta.DiagSummary | false |
UInt16.neg_neg | Init.Data.UInt.Lemmas | ∀ {a : UInt16}, - -a = a | true |
Lean.Meta.Match.MatcherInfo.noConfusion | Lean.Meta.Match.MatcherInfo | {P : Sort u} → {t t' : Lean.Meta.MatcherInfo} → t = t' → Lean.Meta.Match.MatcherInfo.noConfusionType P t t' | false |
CategoryTheory.MonoidalCoherence.right'_iso | Mathlib.Tactic.CategoryTheory.MonoidalComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
[inst_2 : CategoryTheory.MonoidalCoherence X Y],
CategoryTheory.MonoidalCoherence.iso =
CategoryTheory.MonoidalCoherence.iso ≪≫ (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).symm | true |
Lean.Parser.Command.macroArg.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | true |
Array.Matcher.Iterator.noConfusion | Batteries.Data.Array.Match | {P : Sort u} →
{σ : Type u_1} →
{n : Type u_1 → Type u_2} →
{α : Type u_1} →
{inst : BEq α} →
{m : Array.Matcher α} →
{inst_1 : Std.Iterator σ n α} →
{t : Array.Matcher.Iterator σ n α m} →
{σ' : Type u_1} →
{n' : Type u_1 → Type u... | false |
SSet.Truncated.liftOfStrictSegal.spineEquiv_f₂_arrow_one | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X Y : SSet.Truncated 2}
(f₀ :
X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := _proof_11✝ }) →
Y.obj (Opposite.op { obj := SimplexCategory.mk 0, property := _proof_11✝¹ }))
(f₁ :
X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := _proof_12✝ }) →
Y.obj (Opposite.op { ob... | true |
_private.Aesop.Forward.LevelIndex.0.Aesop.instHashableLevelIndex.hash.match_1 | Aesop.Forward.LevelIndex | (motive : Aesop.LevelIndex → Sort u_1) → (x : Aesop.LevelIndex) → ((a : ℕ) → motive { toNat := a }) → motive x | false |
Set.Icc_subset_Icc_union_Icc | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Icc a c ⊆ Set.Icc a b ∪ Set.Icc b c | true |
CoheytingHom.id._proof_2 | Mathlib.Order.Heyting.Hom | ∀ (α : Type u_1) [inst : CoheytingAlgebra α] (x x_1 : α),
(LatticeHom.id α).toFun (x \ x_1) = (LatticeHom.id α).toFun (x \ x_1) | false |
Lean.Elab.Term.Do.ToTerm.Context.rec | Lean.Elab.Do.Legacy | {motive : Lean.Elab.Term.Do.ToTerm.Context → Sort u} →
((m returnType : Lean.Syntax) →
(uvars : Array Lean.Elab.Term.Do.Var) →
(kind : Lean.Elab.Term.Do.ToTerm.Kind) →
motive { m := m, returnType := returnType, uvars := uvars, kind := kind }) →
(t : Lean.Elab.Term.Do.ToTerm.Context) → moti... | false |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizePattern.go._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Internalize | {motive : Lean.Meta.Grind.Origin → Sort u} →
(t : Lean.Meta.Grind.Origin) →
((declName : Lean.Name) → motive (Lean.Meta.Grind.Origin.decl declName)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
variationOnFromTo | Mathlib.Topology.EMetricSpace.BoundedVariation | {α : Type u_1} → [LinearOrder α] → {E : Type u_2} → [PseudoEMetricSpace E] → (α → E) → Set α → α → α → ℝ | true |
Lean.Parser.Category.prec | Init.Notation | Lean.Parser.Category | true |
Aesop.runFirstNormRule | Aesop.Search.Expansion.Norm | Lean.MVarId →
Aesop.UnorderedArraySet Lean.MVarId →
Array (Aesop.IndexMatchResult Aesop.NormRule) → Aesop.NormM (Option (Aesop.DisplayRuleName × Aesop.NormRuleResult)) | true |
FundamentalGroupoid.nonempty_iff._simp_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (X : Type u_3), Nonempty (FundamentalGroupoid X) = Nonempty X | false |
Nat.perfect_iff_sum_properDivisors | Mathlib.NumberTheory.Divisors | ∀ {n : ℕ}, 0 < n → (n.Perfect ↔ ∑ i ∈ n.properDivisors, i = n) | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValInfo.parent? | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.DerivedValInfo✝ → Option Lean.FVarId | true |
ContDiffAt.hasStrictDerivAt | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {n : WithTop ℕ∞} {𝕂 : Type u_1} [inst : RCLike 𝕂] {F' : Type u_3} [inst_1 : NormedAddCommGroup F']
[inst_2 : NormedSpace 𝕂 F'] {f : 𝕂 → F'} {x : 𝕂}, ContDiffAt 𝕂 n f x → n ≠ 0 → HasStrictDerivAt f (deriv f x) x | true |
Lean.Grind.Linarith.zero_ne_one_of_charC | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.Linarith.Context α)
(p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.zero_ne_one_of_charC_cert c p = true →
Lean.Grind.Linarith.Var.denote ctx 0 = One.one → Lean.Grind.Linarith.Poly.denote' ctx p ≠ 0 | true |
Nonneg.zero._proof_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α], 0 ≤ 0 | false |
PadicInt.nonarchimedean | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℤ_[p]), ‖q + r‖ ≤ max ‖q‖ ‖r‖ | true |
_private.Mathlib.Algebra.Module.Presentation.Basic.0.Module.Relations.Solution.surjective_fromQuotient_iff_surjective_π._simp_1_1 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (solution : relations.Solution M), solution.π = solution.fromQuotient ∘ₗ relations.toQuotient | false |
EisensteinSeries.isLittleO_const_left_of_properSpace_of_discreteTopology | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {α : Type u_1} (a : α) [inst : NormedAddCommGroup α] [DiscreteTopology α] [ProperSpace α],
(fun x => a) =o[Filter.cofinite] fun x => ‖x‖ | true |
_private.Mathlib.NumberTheory.FLT.Basic.0.fermatLastTheoremWith_of_fermatLastTheoremWith_coprime._simp_1_1 | Mathlib.NumberTheory.FLT.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b ≠ 0) = (a ≠ 0 ∧ b ≠ 0) | false |
Int.toArray_roo_eq_singleton | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, n = m + 2 → (m<...n).toArray = #[m + 1] | true |
Quaternion.instIsStarNormal | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), IsStarNormal a | true |
Lean.Widget.TaggedText.forM._unsafe_rec | Lean.Widget.TaggedText | {m : Type → Type u_1} →
{α : Type u_2} → [Monad m] → (α → Lean.Widget.TaggedText α → m Unit) → Lean.Widget.TaggedText α → m Unit | false |
Equiv.Set.rangeInl.match_3 | Mathlib.Logic.Equiv.Set | ∀ (α : Type u_1) (β : Type u_2) (motive : ↑(Set.range Sum.inl) → Prop) (x : ↑(Set.range Sum.inl)),
(∀ (val : α), motive ⟨Sum.inl val, ⋯⟩) → motive x | false |
Aesop.Subgoal.diff | Aesop.RuleTac.Basic | Aesop.Subgoal → Aesop.GoalDiff | true |
Metric.Snowflaking.isBounded_image_ofSnowflaking_iff._simp_1 | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : Bornology X] {s : Set (Metric.Snowflaking X α hα₀ hα₁)},
Bornology.IsBounded (⇑Metric.Snowflaking.ofSnowflaking '' s) = Bornology.IsBounded s | false |
HopfAlgCat.instMonoidalCategoryStruct | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | (R : Type u) → [inst : CommRing R] → CategoryTheory.MonoidalCategoryStruct (HopfAlgCat R) | true |
Continuous.of_neg | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous (-f) → Continuous f | true |
BialgEquiv.ofBialgHom._proof_3 | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
CStarMatrix.instSMul._aux_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} →
{n : Type u_2} → {R : Type u_4} → {A : Type u_3} → [SMul R A] → R → CStarMatrix m n A → CStarMatrix m n A | false |
Ordinal.type_sum_lex | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s],
Ordinal.type (Sum.Lex r s) = Ordinal.type r + Ordinal.type s | true |
Algebra.Generators.toExtension_σ | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Generators R S ι) (a : S), P.toExtension.σ a = P.σ a | true |
_private.Mathlib.AlgebraicGeometry.ZariskisMainTheorem.0.AlgebraicGeometry.Scheme.Hom.exists_mem_and_isIso_morphismRestrict_toNormalization._simp_1_2 | Mathlib.AlgebraicGeometry.ZariskisMainTheorem | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsOpenImmersion f]
[inst_1 : AlgebraicGeometry.IsOpenImmersion g],
(AlgebraicGeometry.Scheme.Hom.opensFunctor g).obj (AlgebraicGeometry.Scheme.Hom.opensRange f) =
AlgebraicGeometry.Scheme.Hom.opensRange (CategoryTheory.Catego... | false |
Set.eq_top_of_card_le_of_finite | Mathlib.Data.Finite.Card | ∀ {α : Type u_1} [Finite α] {s : Set α}, Nat.card α ≤ Nat.card ↑s → s = ⊤ | true |
PadicInt.continuousAddCharEquiv.match_1 | Mathlib.NumberTheory.Padics.AddChar | (p : ℕ) →
[inst : Fact (Nat.Prime p)] →
(R : Type u_1) →
[inst_1 : NormedRing R] →
(motive : { κ // Continuous ⇑κ } → Sort u_2) →
(x : { κ // Continuous ⇑κ }) → ((κ : AddChar ℤ_[p] R) → (hκ : Continuous ⇑κ) → motive ⟨κ, hκ⟩) → motive x | false |
Lean.Widget.RpcEncodablePacket.range?._@.Lean.Widget.UserWidget.3433604829._hygCtx._hyg.1 | Lean.Widget.UserWidget | Lean.Widget.RpcEncodablePacket✝ → Option Lean.Json | false |
Continuous.rpow | Mathlib.Analysis.SpecialFunctions.Pow.Continuity | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f g : α → ℝ},
Continuous f → Continuous g → (∀ (x : α), f x ≠ 0 ∨ 0 < g x) → Continuous fun x => f x ^ g x | true |
CategoryTheory.SmallObject.SuccStruct.Iteration.casesOn | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
{Φ : CategoryTheory.SmallObject.SuccStruct C} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : CategoryTheory.Limits.HasIterationOfShape J C] →
... | false |
Cardinal.toNat_strictMonoOn | Mathlib.SetTheory.Cardinal.ToNat | StrictMonoOn (⇑Cardinal.toNat) (Set.Iio Cardinal.aleph0) | true |
PFunctor.M.IsBisimulation.mk | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {R : F.M → F.M → Prop},
(∀ {a a' : F.A} {f : F.B a → F.M} {f' : F.B a' → F.M}, R (PFunctor.M.mk ⟨a, f⟩) (PFunctor.M.mk ⟨a', f'⟩) → a = a') →
(∀ {a : F.A} {f f' : F.B a → F.M},
R (PFunctor.M.mk ⟨a, f⟩) (PFunctor.M.mk ⟨a, f'⟩) → ∀ (i : F.B a), R (f i) (f' i)) →
PFunctor.M.IsB... | true |
CategoryTheory.Limits.IsInitial.subsingleton_to | Mathlib.CategoryTheory.Limits.Shapes.StrictInitial | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C}
(hI : CategoryTheory.Limits.IsInitial I) {A : C}, Subsingleton (A ⟶ I) | true |
List.perm_cons_append_cons | Init.Data.List.Perm | ∀ {α : Type u_1} {l l₁ l₂ : List α} (a : α), l.Perm (l₁ ++ l₂) → (a :: l).Perm (l₁ ++ a :: l₂) | true |
_private.Init.Data.Slice.Array.Lemmas.0.Subarray.size_mkSlice_rco._simp_1_1 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α}, Std.Slice.size xs = (Std.Slice.toList xs).length | false |
Equiv.Finset.union_symm_right | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} (h : Disjoint s t) {i : α} (hi : i ∈ t) (hi' : i ∈ s ∪ t),
(Equiv.Finset.union s t h).symm ⟨i, hi'⟩ = Sum.inr ⟨i, hi⟩ | true |
Nat.succ.elim | Init.Prelude | {motive : ℕ → Sort u} → (t : ℕ) → t.ctorIdx = 1 → ((n : ℕ) → motive n.succ) → motive t | false |
Diffeomorph.coe_refl | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_5} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_9)
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] (n : WithTop ℕ∞), ⇑(Diffeomorph.refl I ... | true |
Plausible.Random.instBoundedRandomFin | Plausible.Random | {m : Type → Type u_1} → [Monad m] → {n : ℕ} → Plausible.BoundedRandom m (Fin n) | true |
WithTop.LinearOrderedAddCommGroup.instLinearOrderedAddCommGroupWithTopOfIsOrderedAddMonoid._proof_8 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {G : Type u_1} [inst : AddCommGroup G], WithTop.map (fun a => -a) ⊤ = ⊤ | false |
Std.DTreeMap.Internal.RxoIterator._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) →
(β : α → Type v) →
{inst : Ord α} → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Std.DTreeMap.Internal.RxoIterator α β) | false |
OpenPartialHomeomorph.subtypeRestr_target_subset | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : TopologicalSpace.Opens X} (hs : Nonempty ↥s),
(e.subtypeRestr hs).target ⊆ e.target | true |
_private.Mathlib.Geometry.Manifold.Riemannian.Basic.0.setOf_riemannianEDist_lt_subset_nhds._simp_1_3 | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {r : NNReal}, (0 < ↑r) = (0 < r) | false |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_14 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : ↥(Unitization.unitsFstOne R A)),
⟨{
val :=
1 +
↑(PreQuasiregular.equiv.symm
↑{ val := PreQuasi... | false |
Nat.preimage_Iic | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R},
0 ≤ a → Nat.cast ⁻¹' Set.Iic a = Set.Iic ⌊a⌋₊ | true |
CategoryTheory.Abelian.Ext.mapExactFunctor._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Map | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u_4}
[inst_2 : CategoryTheory.Category.{u_2, u_4} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
[F.Additive], F.PreservesZeroMorphisms | false |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.iUnion_Ioc_right._simp_1_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b | false |
Finset.smul_finset_univ | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {a : α}
[inst_3 : Fintype β], a • Finset.univ = Finset.univ | true |
Std.DHashMap.Internal.Raw₀.contains_of_contains_union_of_contains_eq_false_right | 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 → ∀ {k : α}, (m₁.union m₂).contains k = true → m₂.contains k = false → m₁.contains k = true | true |
BitVec.ofFin_le | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x : Fin (2 ^ n)} {y : BitVec n}, { toFin := x } ≤ y ↔ x ≤ y.toFin | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.denselyOrdered_iff_denselyOrdered_units_and_nontrivial_units._simp_1_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | false |
ContinuousAffineMap.noConfusion | Mathlib.Topology.Algebra.ContinuousAffineMap | {P : Sort u} →
{R : Type u_1} →
{V : Type u_2} →
{W : Type u_3} →
{P_1 : Type u_4} →
{Q : Type u_5} →
{inst : Ring R} →
{inst_1 : AddCommGroup V} →
{inst_2 : Module R V} →
{inst_3 : TopologicalSpace P_1} →
{ins... | false |
FirstOrder.Language.Equiv.coe_toElementaryEmbedding | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Equiv M N), ⇑f.toElementaryEmbedding = ⇑f | true |
_private.Mathlib.LinearAlgebra.TensorProduct.Graded.External.0.TensorProduct.term𝒜ℬ | Mathlib.LinearAlgebra.TensorProduct.Graded.External | Lean.ParserDescr | true |
Nat.pairEquiv_symm_apply | Mathlib.Data.Nat.Pairing | ⇑Nat.pairEquiv.symm = Nat.unpair | true |
CategoryTheory.Functor.mapHomologicalComplex._proof_1 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_5} {W₁ : Type u_4} {W₂ : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} W₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (F : CategoryTheory.Functor W₁ W₂) [F.PreservesZeroMorphisms]
(... | false |
Lean.Meta.hcongrThmSuffixBase | Lean.Meta.CongrTheorems | String | true |
Lean.IR.Alt.ctorElim | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
(ctorIdx : ℕ) → (t : Lean.IR.Alt) → ctorIdx = t.ctorIdx → Lean.IR.Alt.ctorElimType ctorIdx → motive_1 t | false |
ProbabilityTheory.mgf_zero_fun | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {t : ℝ},
ProbabilityTheory.mgf 0 μ t = μ.real Set.univ | true |
Lean.Compiler.LCNF.Simp.JpCasesInfo._sizeOf_inst | Lean.Compiler.LCNF.Simp.JpCases | SizeOf Lean.Compiler.LCNF.Simp.JpCasesInfo | false |
denseRange_stoneCechUnit | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u} [inst : TopologicalSpace α], DenseRange stoneCechUnit | true |
CategoryTheory.Limits.widePullback.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (B : C) (objs : J → C)
(arrows arrows_1 : (j : J) → objs j ⟶ B) (e_arrows : arrows = arrows_1)
[inst_1 : CategoryTheory.Limits.HasWidePullback B objs arrows],
CategoryTheory.Limits.widePullback B objs arrows = CategoryTheory.Limits.widePullback... | true |
Lean.Parser.Attr.class.parenthesizer | Lean.Parser.Attr | Lean.PrettyPrinter.Parenthesizer | true |
_private.Mathlib.LinearAlgebra.Span.Basic.0.Submodule.biSup_comap_subtype_eq_top.match_1_1 | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_3}
(s : Set ι) (p : ι → Submodule R M) (motive : (x : ↥(⨆ i ∈ s, p i)) → x ∈ ⊤ → Prop) (x : ↥(⨆ i ∈ s, p i))
(x_1 : x ∈ ⊤), (∀ (x : M) (hx : x ∈ ⨆ i ∈ s, p i) (x_2 : ⟨x, hx⟩ ∈ ⊤), motive ⟨x, hx⟩ x_2) → m... | false |
CategoryTheory.Functor.Initial.extendCone_obj_pt | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} [inst_2 : F.Initial] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
{G : CategoryTheory.Functor D E} (c : CategoryTheory.Limits.Cone (F.comp G)),
(C... | true |
IsLocalRing.ResidueField.instMulSemiringAction | Mathlib.RingTheory.LocalRing.ResidueField.Basic | {R : Type u_1} →
[inst : CommRing R] →
[inst_1 : IsLocalRing R] →
(G : Type u_4) → [inst_2 : Group G] → [MulSemiringAction G R] → MulSemiringAction G (IsLocalRing.ResidueField R) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.