name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.rfindOpt.eq_1 | Mathlib.Computability.PartrecBasis | ∀ {α : Type u_1} (f : ℕ → Option α), Nat.rfindOpt f = (Nat.rfind fun n => ↑(some (f n).isSome)).bind fun n => ↑(f n) | null | true |
sdiff_sup_sdiff_cancel'._to_dual_1 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b c : α}, b ≤ a ⊔ c → a ⊓ c ≤ b → (b ⇨ a) ⊓ (c ⇨ b) = c ⇨ a | null | false |
_private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosed.lift._proof_3 | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {M : Type u_2} [inst : Field M] {R : Type u_1} [inst_1 : CommRing R] [inst_2 : IsDomain R] {S : Type u_3}
[inst_3 : CommRing S] [inst_4 : IsDomain S] [inst_5 : Algebra R S] [inst_6 : Algebra R M]
[inst_7 : Module.IsTorsionFree R S] [inst_8 : Module.IsTorsionFree R M], IsScalarTower R (FractionRing R) M | null | false |
Algebra.Extension.σ_smul | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (P : Algebra.Extension R S)
(x y : S), P.σ x • y = x * y | null | true |
Submodule.instIdemCommSemiring._proof_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(a b : Submodule R A), a + b = a ⊔ b | null | false |
EuclideanGeometry.Sphere.polar_center | Mathlib.Geometry.Euclidean.Sphere.PolePolar | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (s : EuclideanGeometry.Sphere P), s.polar s.center = ⊤ | null | true |
_private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.realizeExtTheorem | Lean.Elab.Tactic.Ext | Lean.Name → Bool → Lean.Elab.TermElabM Lean.Name | Ensures that the given structure has an ext theorem, without validating any pre-existing theorems.
Returns the name of the ext theorem.
See `Lean.Elab.Tactic.Ext.withExtHyps` for an explanation of the `flat` argument.
| true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.partialMatch_add_one_add_one_iff._proof_1_6 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat : ByteArray} {s : ByteArray} {stackPos : ℕ} {needlePos : ℕ},
needlePos + 1 ≤ pat.size → ¬needlePos ≤ pat.size → False | null | false |
List.Vector.empty_toList_eq_ff | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (v : List.Vector α (n + 1)), v.toList.isEmpty = false | null | true |
CategoryTheory.Functor.whiskerLeft_id | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
{G : CategoryTheory.Functor D E}, F.whiskerLeft (CategoryTheory.NatTrans.id G) = CategoryTheory.NatTran... | null | true |
CategoryTheory.Grothendieck.grothendieckTypeToCat._proof_2 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (G : CategoryTheory.Functor C (Type u_3))
(X : CategoryTheory.Grothendieck (G.comp CategoryTheory.typeToCat)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Grothendieck.grothendieckTypeToCatFunctor G).map
((CategoryTheory.Iso.refl
... | null | false |
Lean.Meta.FunInd.Call.relevantArgs | Lean.Meta.Tactic.FunIndCollect | Lean.Meta.FunInd.Call → Lean.Expr | null | true |
MeasureTheory.SimpleFunc.instStar | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [Star β] → Star (MeasureTheory.SimpleFunc α β) | null | true |
Aesop.ForwardStateStats.mk.sizeOf_spec | Aesop.Stats.Basic | ∀ (ruleStateStats : Array Aesop.ForwardRuleStateStats),
sizeOf { ruleStateStats := ruleStateStats } = 1 + sizeOf ruleStateStats | null | true |
PSum._sizeOf_1.eq._@.Mathlib.Util.CompileInductive.2377832586._hygCtx._hyg.8 | Mathlib.Util.CompileInductive | @PSum._sizeOf_1 = @PSum._sizeOf_1✝ | null | false |
_private.Mathlib.Topology.LocallyClosed.0.isLocallyClosedAt_tfae._simp_1_8 | Mathlib.Topology.LocallyClosed | ∀ {α : Type u} {s t : Set α} {l : Filter α}, (s =ᶠ[l] t) = ∀ᶠ (x : α) in l, x ∈ s ↔ x ∈ t | null | false |
Std.ToStream.noConfusionType | Init.Data.Stream | Sort u_1 →
{collection stream : Type u} →
Std.ToStream collection stream → {collection' stream' : Type u} → Std.ToStream collection' stream' → Sort u_1 | null | false |
Std.Internal.List.Const.getKey?_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [inst_1 : EquivBEq α] {β : Type v} {f : α → β → Bool} {l : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKey? k (List.filter (fun p => f p.fst p.snd) l) =
(Std.Internal.List.getKey? k l).pfilter fun x h => f x (Std.Internal.List.getValue x... | null | true |
MeasurableSpace.DynkinSystem.ctorIdx | Mathlib.MeasureTheory.PiSystem | {α : Type u_4} → MeasurableSpace.DynkinSystem α → ℕ | null | false |
CategoryTheory.Limits.IsLimit.binaryFanSwap._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {s : CategoryTheory.Limits.BinaryFan X Y}
(I : CategoryTheory.Limits.IsLimit s) (t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair Y X))
(m : t.pt ⟶ s.swap.pt),
(∀ (j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
... | null | false |
CategoryTheory.Discrete.sumEquiv_functor_obj | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} (a : CategoryTheory.Discrete (J ⊕ K)),
CategoryTheory.Discrete.sumEquiv.functor.obj a =
match a.as with
| Sum.inl j => Sum.inl { as := j }
| Sum.inr k => Sum.inr { as := k } | null | true |
IsLocalization.Away.tensorRight | Mathlib.RingTheory.Localization.BaseChange | ∀ {R : Type u_7} {S : Type u_8} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (r : R)
(A : Type u_9) [inst_3 : CommSemiring A] [inst_4 : Algebra R A] [IsLocalization.Away r A],
IsLocalization.Away ((algebraMap R S) r) (TensorProduct R A S) | null | true |
Lean.ModuleData.constNames | Lean.Environment | Lean.ModuleData → Array Lean.Name | `constNames` contains all constant names in `constants`.
This information is redundant. It is equal to `constants.map fun c => c.name`,
but it improves the performance of `importModules`. `perf` reports that 12% of the
runtime was being spent on `ConstantInfo.name` when importing a file containing only `import Lean`
| true |
_private.Init.Data.List.Nat.Sublist.0.List.IsSuffix.getElem._proof_1_1 | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys : List α} {i : ℕ},
i < xs.length → xs.length ≤ ys.length → ¬ys.length - 1 - (xs.length - 1 - i) = ys.length - xs.length + i → False | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances.0.CFC.exists_sqrt_of_isSelfAdjoint_of_quasispectrumRestricts._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [IsScalarTower ℝ A A] [SMulCommClass ℝ A A] {a : A},
QuasispectrumRestricts a ⇑ContinuousMap.realToNNReal = ∀ x ∈ quasispectrum ℝ a, 0 ≤ x | null | false |
Lean.logNamedWarningAt | Lean.Log | {m : Type → Type} →
[Monad m] →
[Lean.MonadLog m] →
[Lean.AddMessageContext m] → [Lean.MonadOptions m] → Lean.Syntax → Lean.Name → Lean.MessageData → m Unit | Log a named error warning using the given message data. The position is provided by `ref`.
Note: Use the macro `logNamedWarningAt`, which validates error names, instead of calling this function
directly.
| true |
UInt8.toUInt16_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a <<< b).toUInt16 = a.toUInt16 <<< (b % 8).toUInt16 % 256 | null | true |
_private.Mathlib.Algebra.Order.CauSeq.Basic.0.CauSeq.inf_limZero.match_1_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] (motive : (x : α) → x > 0 → Prop) (x : α) (x_1 : x > 0),
(∀ (ε : α) (ε0 : ε > 0), motive ε ε0) → motive x x_1 | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.sliceFrom_lt_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceFrom p₀).Pos} {q : s.Pos} {h : p₀ ≤ q},
(p ≤ p₀.sliceFrom q h) = (String.Pos.ofSliceFrom p ≤ q) | null | false |
ProbabilityTheory.Kernel.IsIrreducible.mk | Mathlib.Probability.Kernel.Irreducible | ∀ {α : Type u_1} {mα : MeasurableSpace α} {φ : MeasureTheory.Measure α} {κ : ProbabilityTheory.Kernel α α},
(∀ ⦃A : Set α⦄, MeasurableSet A → φ A > 0 → ∀ (a : α), ∃ n, ((κ ^ n) a) A > 0) →
ProbabilityTheory.Kernel.IsIrreducible φ κ | null | true |
SSetPair.chainComplexShortComplex | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Limits.HasCoproducts C] →
[inst_2 : CategoryTheory.Preadditive C] → SSetPair → C → CategoryTheory.ShortComplex (ChainComplex C ℕ) | Given a pair of simplicial sets corresponding to a monomorphism `i : X ⟶ Y`,
this is the (short exact) short complex which relates
the chain complex of `X`, of `Y` and of the pair. | true |
Std.ExtHashMap.getKey!_filter_key | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → Bool} {k : α},
(Std.ExtHashMap.filter (fun k x => f k) m).getKey! k = (Option.filter f (m.getKey? k)).get! | null | true |
RootPairing.zero_lt_pairingIn_iff | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing S]
[inst_1 : LinearOrder S] [inst_2 : CommRing R] [inst_3 : Algebra S R] [inst_4 : AddCommGroup M] [inst_5 : Module R M]
[inst_6 : AddCommGroup N] [inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsValuedIn S]
... | null | true |
CategoryTheory.Bicategory.Adjunction.compUnit | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f₁ : a ⟶ b} →
{g₁ : b ⟶ a} →
{f₂ : b ⟶ c} →
{g₂ : c ⟶ b} →
CategoryTheory.Bicategory.Adjunction f₁ g₁ →
CategoryTheory.Bicategory.Adjunction f₂ g₂ →
(CategoryTh... | Auxiliary definition for `Adjunction.comp`. | true |
Lean.PPContext.mk.injEq | Lean.Data.PPContext | ∀ (env : Lean.Environment) (mctx : Lean.MetavarContext) (lctx : Lean.LocalContext) (opts : Lean.Options)
(currNamespace : Lean.Name) (openDecls : List Lean.OpenDecl) (env_1 : Lean.Environment) (mctx_1 : Lean.MetavarContext)
(lctx_1 : Lean.LocalContext) (opts_1 : Lean.Options) (currNamespace_1 : Lean.Name) (openDecl... | null | true |
Algebra.IsStandardSmooth | Mathlib.RingTheory.Smooth.StandardSmooth | (R : Type u) → (S : Type v) → [inst : CommRing R] → [inst_1 : CommRing S] → [Algebra R S] → Prop | An `R`-algebra `S` is called standard smooth, if there
exists a submersive presentation.
| true |
Lean.Grind.PowIdentity.pow_eq | Init.Grind.Ring.Basic | ∀ {α : Type u} {inst : Lean.Grind.CommSemiring α} {p : outParam ℕ} [self : Lean.Grind.PowIdentity α p] (x : α),
x ^ p = x | Every element satisfies `x ^ p = x`. | true |
Lattice.mem_ideal_sup_principal | Mathlib.Order.PrimeSeparator | ∀ {α : Type u_1} [inst : Lattice α] (a b : α) (J : Order.Ideal α), b ∈ J ⊔ Order.Ideal.principal a ↔ ∃ j ∈ J, b ≤ j ⊔ a | null | true |
ONote.mulNat | Mathlib.SetTheory.Ordinal.Notation | ONote → ℕ → ONote | `mulNat o n` is the ordinal notation for `o * n`. | true |
_private.Mathlib.Algebra.GroupWithZero.WithZero.0.WithZero.map'_surjective_iff._proof_1_3 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} [inst : MulOneClass α] [inst_1 : MulOneClass β] {f : α →* β} (b : β) (a : α),
f a = b → ∃ a, f a = b | null | false |
CategoryTheory.Limits.FormalCoproduct.evalCompInclIsoId | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
(A : Type u₁) →
[inst_1 : CategoryTheory.Category.{v₁, u₁} A] →
[inst_2 : CategoryTheory.Limits.HasCoproducts A] →
(CategoryTheory.Limits.FormalCoproduct.eval C A).comp
((CategoryTheory.Functor.whiskeringLeft C (Categ... | `eval(F)` restricted to the original category (via `incl`) is the original copresheaf `F`. | true |
AntilipschitzWith.of_subsingleton._simp_1 | Mathlib.Topology.MetricSpace.Antilipschitz | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β}
[Subsingleton α] {K : NNReal}, AntilipschitzWith K f = True | null | false |
PresheafOfModules.epi_iff_surjective | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂),
CategoryTheory.Epi f ↔ ∀ ⦃X : Cᵒᵖ⦄, Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X)) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_minKey?._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.limsup_mu_le._simp_1_3 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a : α}, (a ∈ lowerBounds s) = ∀ x ∈ s, a ≤ x | null | false |
MulEquiv.op._proof_3 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β],
Function.LeftInverse
(fun f =>
{ toFun := MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op, invFun := MulOpposite.unop ∘ ⇑f.symm ∘ MulOpposite.op,
left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯ })
fun f =>
{ toFun := MulOpposite.op ∘ ⇑f ∘ ... | null | false |
_private.Lean.Util.SCC.0.Lean.SCC.addSCC.add._unsafe_rec | Lean.Util.SCC | {α : Type} → [inst : BEq α] → [inst_1 : Hashable α] → α → List α → List α → Lean.SCC.M α Unit | null | false |
Poly.instAddGroupWithOne._proof_4 | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} (n : ℕ), Poly.const (Int.negSucc n) = -↑(n + 1) | null | false |
CochainComplex.HomComplex.Cocycle.instAddCommGroup._proof_16 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(F G : CochainComplex C ℤ) (n : ℤ),
autoParam (∀ (a b : CochainComplex.HomComplex.Cocycle F G n), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.extractBind.extract?.match_3 | Lean.Elab.Do.Legacy | (motive : Option Lean.Elab.Term.ExtractMonadResult → Sort u_1) →
(__do_lift : Option Lean.Elab.Term.ExtractMonadResult) →
((r : Lean.Elab.Term.ExtractMonadResult) → motive (some r)) → (Unit → motive none) → motive __do_lift | null | false |
MonoidAlgebra.domCongrAut._proof_2 | 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] (x x_1 : MulAut M),
MonoidAlgebra.domCongr R A (x * x_1) = MonoidAlgebra.domCongr R A x * MonoidAlgebra.domCongr R A x_1 | null | false |
_private.Std.Sat.AIG.Basic.0.Std.Sat.AIG.instHashableFanin.hash.match_1 | Std.Sat.AIG.Basic | (motive : Std.Sat.AIG.Fanin → Sort u_1) → (x : Std.Sat.AIG.Fanin) → ((a : ℕ) → motive { val := a }) → motive x | null | false |
LieAlgebra.ExtendScalars.instLieRing._proof_3 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_3) (A : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (x y z : TensorProduct R A L), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆ | null | false |
Finset.sum_subtype_of_mem | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] (f : ι → M) {p : ι → Prop}
[inst_1 : DecidablePred p], (∀ x ∈ s, p x) → ∑ x ∈ Finset.subtype p s, f ↑x = ∑ x ∈ s, f x | If all elements of a `Finset` satisfy the predicate `p`, a sum
over `s.subtype p` equals that sum over `s`. | true |
AlgEquiv.restrictNormalHom_id | Mathlib.FieldTheory.Normal.Defs | ∀ (F : Type u_6) (K : Type u_7) [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K] [inst_3 : Normal F K],
AlgEquiv.restrictNormalHom K = MonoidHom.id Gal(K/F) | The group homomorphism given by restricting an algebra isomorphism to itself
is the identity map. | true |
Fin.val_one | Init.Data.Fin.Lemmas | ∀ (n : ℕ), ↑1 = 1 | null | true |
Std.Http.Server.instToStringRemoteAddr | Std.Http.Server.Connection | ToString Std.Http.Server.RemoteAddr | null | true |
ImportGraph.Shake.Needs.applyAt | ImportGraph.Shake.Basic | {β : Sort u_1} → ImportGraph.Shake.Needs → ImportGraph.Shake.NeedsKind → (ImportGraph.Shake.Bitset → β) → β | Apply `f` to the component bitset of `n : Needs` at the given `NeedsKind`.
Rephrasing of `f (n.get k)` for readability. | true |
Lean.Meta.mkFreshTypeMVar | Lean.Meta.Basic | optParam Lean.MetavarKind Lean.MetavarKind.natural → optParam Lean.Name Lean.Name.anonymous → Lean.MetaM Lean.Expr | null | true |
FiniteArchimedeanClass.mem_ball_iff | Mathlib.Algebra.Order.Module.Archimedean | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : LinearOrder K] [inst_5 : IsOrderedRing K] [inst_6 : Archimedean K] [inst_7 : Module K M]
[inst_8 : PosSMulMono K M] {a : M} {c : FiniteArchimedeanClass M},
a ∈ FiniteArchime... | null | true |
OrderEmbedding.preimage_Ioi | Mathlib.Order.Interval.Set.OrderEmbedding | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ↪o β) (x : α),
⇑e ⁻¹' Set.Ioi (e x) = Set.Ioi x | null | true |
_private.Lake.Util.Version.0.Lake.VerComponent.wild | Lake.Util.Version | Lake.VerComponent✝ | null | true |
_private.Mathlib.Data.List.MinMax.0.List.maximum_ne_bot_of_ne_nil.match_1_1 | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} (motive : (l : List α) → l ≠ [] → Prop) (l : List α) (h : l ≠ []),
(∀ (head : α) (tail : List α) (x : head :: tail ≠ []), motive (head :: tail) x) → motive l h | null | false |
finrank_quotient_span_eq_natDegree | Mathlib.RingTheory.AdjoinRoot | ∀ {K : Type u_5} [inst : Field K] {f : Polynomial K}, Module.finrank K (Polynomial K ⧸ Ideal.span {f}) = f.natDegree | See `finrank_quotient_span_eq_natDegree'` for a version over a ring when `f` is monic.
| true |
Std.DHashMap.markLinear._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} (m : Std.DHashMap α β), m.inner.markLinear.WF | null | false |
ContMDiffConstVAdd.recOn | Mathlib.Geometry.Manifold.Algebra.SMul | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{n : WithTop ℕ∞} →
... | null | false |
CategoryTheory.Functor.Monoidal.toUnit_ε_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X : C) {Z : D}
(h : F.obj (Cat... | null | true |
Nat.zero_of_testBit_eq_false | Mathlib.Data.Nat.Bitwise | ∀ {n : ℕ}, (∀ (i : ℕ), n.testBit i = false) → n = 0 | null | true |
Multiplicative.toNNNorm | Mathlib.Analysis.Normed.Group.Constructions | {E : Type u_3} → [NNNorm E] → NNNorm (Multiplicative E) | null | true |
Subalgebra.baseChange._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_1} [inst : CommSemiring R] (B : Type u_2) [inst_1 : CommSemiring B] [inst_2 : Algebra R B],
SMulCommClass R B B | null | false |
FormalGroup.map | Mathlib.RingTheory.FormalGroup.Basic | {R : Type u_1} →
[inst : CommRing R] → {S : Type u_2} → [inst_1 : CommRing S] → FormalGroup R → (R →+* S) → FormalGroup S | Given an algebra map `f : R →+* S` and a formal group law `F` over `R`, then `f_* F` is a
formal group law formal group law over `S`. This is constructed by applying `f` to all coefficients
of the underlying power series. | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Option.get_eq_iff_eq_some._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {o : Option α} {a : α}, (o = some a) = ∃ (h : o.isSome = true), o.get h = a | null | false |
Nat.Icc_eq_range' | Mathlib.Order.Interval.Finset.Nat | ∀ (a b : ℕ), Finset.Icc a b = { val := ↑(List.range' a (b + 1 - a)), nodup := ⋯ } | null | true |
ZNum.bit0 | Mathlib.Data.Num.Basic | ZNum → ZNum | `bit0 n` appends a `0` to the end of `n`, where `bit0 n = n0`. | true |
CategoryTheory.Presieve.IsSheafFor.isAmalgamation | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
{R : CategoryTheory.Presieve X} (t : CategoryTheory.Presieve.IsSheafFor P R)
{x : CategoryTheory.Presieve.FamilyOfElements P R} (hx : x.Compatible), x.IsAmalgamation (t.amalgamate x hx) | null | true |
MonoidAlgebra.mapDomainRingHom._proof_1 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_1) {M : Type u_3} {N : Type u_2} [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Monoid N] (f : M →* N),
MonoidAlgebra.mapDomain (⇑f) 1 = 1 | null | false |
_private.Init.Data.UInt.Lemmas.0._aux_Init_Data_UInt_Lemmas___macroRules_commandDeclare_uint_theorems___1._sparseCasesOn_1 | Init.Data.UInt.Lemmas | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Limits.createsColimitsOfShapeOfCreatesCoequalizersAndCoproducts._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{K : CategoryTheory.Functor J C},
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete J) C →
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1... | null | false |
Std.Ric.eq_succMany?_of_toList_eq_append_cons | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Ric α} [inst : Std.PRange.Least? α] [inst_1 : LE α] [inst_2 : DecidableLE α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[inst_5 : Std.PRange.LawfulUpwardEnumerableLE α] [inst_6 : Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxc.IsAlw... | null | true |
TopologicalSpace.completelyMetrizableMetric._proof_1 | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ (X : Type u_1) [inst : TopologicalSpace X] [h : TopologicalSpace.IsCompletelyMetrizableSpace X],
inst = PseudoMetricSpace.toUniformSpace.toTopologicalSpace | null | false |
_private.Mathlib.CategoryTheory.Center.NegOnePow.0.CategoryTheory.CatCenter.app_neg_one_zpow._simp_1_1 | Mathlib.CategoryTheory.Center.NegOnePow | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α) (n : ℤ), a ^ n * b ^ n = (a * b) ^ n | null | false |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.isCongruentCheck | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool | Returns `true` if we can generate a congruence proof for `e₁ = e₂`.
See paper: Congruence Closure in Intensional Type Theory for additional details.
| true |
ENNReal.ofReal_le_ofNat._simp_1 | Mathlib.Basic.ENNReal.Real | ∀ {r : ℝ} {n : ℕ} [inst : n.AtLeastTwo], (ENNReal.ofReal r ≤ OfNat.ofNat n) = (r ≤ OfNat.ofNat n) | null | false |
Matrix.IsHermitian.coe_re_diag | Mathlib.Analysis.Matrix.Hermitian | ∀ {𝕜 : Type u_1} {n : Type u_3} {A : Matrix n n 𝕜} [inst : RCLike 𝕜],
A.IsHermitian → (fun i => ↑(RCLike.re (A.diag i))) = A.diag | The diagonal elements of a complex Hermitian matrix are real. | true |
monotone_add_nat_of_le_succ | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} [inst : Preorder α] {f : ℕ → α} {k : ℕ}, (∀ n ≥ k, f n ≤ f (n + 1)) → Monotone fun n => f (n + k) | null | true |
Std.DHashMap.contains_map | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {γ : α → Type w} [EquivBEq α]
[LawfulHashable α] {f : (a : α) → β a → γ a} {k : α}, (Std.DHashMap.map f m).contains k = m.contains k | null | true |
_private.Mathlib.NumberTheory.DirichletCharacter.Basic.0.DirichletCharacter.not_even_and_odd._simp_1_2 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
PresheafOfModules.Sheafify.SMulCandidate._sizeOf_inst | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} →
{R : CategoryTheory.Sheaf J RingCat} →
(α : R₀ ⟶ R.obj) →
{M₀ : PresheafOfModules R₀} →
{A : CategoryTheory.Shea... | null | false |
_private.Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM.0.UniformConvergenceCLM.isVonNBounded_iff._simp_1_3 | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.MulStruct.assocAux.isCompatible_α._proof_1_10 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {n : ℕ} {i : Fin n} (j : Fin (n + 2)), i.succ.succ.succ < j.castSucc → i.succ.succ.succ < j.castSucc | null | false |
codisjoint_bihimp_sup | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : BooleanAlgebra α] (a b : α), Codisjoint (bihimp a b) (a ⊔ b) | null | true |
_private.Lean.Data.Lsp.Basic.0.Lean.Lsp.instHashableMarkupContent.hash.match_1 | Lean.Data.Lsp.Basic | (motive : Lean.Lsp.MarkupContent → Sort u_1) →
(x : Lean.Lsp.MarkupContent) →
((a : Lean.Lsp.MarkupKind) → (a_1 : String) → motive { kind := a, value := a_1 }) → motive x | null | false |
CommMonCat.instConcreteCategoryMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : CommMonCat} (f : X ⟶ Y), { hom' := f.hom' } = f | null | false |
MeasureTheory.MeasurePreserving.lintegral_comp | Mathlib.MeasureTheory.Integral.Lebesgue.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} {g : α → β},
MeasureTheory.MeasurePreserving g μ ν →
∀ {f : β → ENNReal}, Measurable f → ∫⁻ (a : α), f (g a) ∂μ = ∫⁻ (b : β), f b ∂ν | null | true |
instBooleanAlgebraAsBoolAlg | Mathlib.Algebra.Ring.BooleanRing | {α : Type u_1} → [BooleanRing α] → BooleanAlgebra (AsBoolAlg α) | null | true |
_private.Mathlib.SetTheory.Cardinal.Cofinality.Club.0.IsClub.diag.match_1_3 | Mathlib.SetTheory.Cardinal.Cofinality.Club | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : WellFoundedLT α] {f : α → Set α} (this : Nonempty α) (b b' : α)
(motive : (∃ y ∈ ⋂₀ (f '' Set.Iio b), b' ≤ y) → Prop) (x : ∃ y ∈ ⋂₀ (f '' Set.Iio b), b' ≤ y),
(∀ (c : α) (hc : c ∈ ⋂₀ (f '' Set.Iio b)) (hbc : b' ≤ c), motive ⋯) → motive x | null | false |
Vector.instLT | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [LT α] → LT (Vector α n) | null | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.mem_pairs._simp_1 | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) [inst : DecidableEq σ] [inst_1 : Fintype σ] (k : ℕ) (t : Finset σ × σ),
(t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k) = (t.1.card ≤ k ∧ (t.1.card = k → t.2 ∈ t.1)) | null | false |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkBinaryRel | Lean.Meta.AppBuilder | Lean.Name → Lean.Name → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Returns `a r b`, where `r` has name `rName` and is implemented using the typeclass `className`.
This method assumes `a` and `b` have the same type.
Examples of supported classes: `LE` and `LT`.
We use heterogeneous operators to ensure we have a uniform representation.
| true |
USize.ofBitVec_xor | Init.Data.UInt.Bitwise | ∀ (a b : BitVec System.Platform.numBits), { toBitVec := a ^^^ b } = { toBitVec := a } ^^^ { toBitVec := b } | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.