name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Int.dvd_add_self_mul | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a ∣ b + a * c ↔ a ∣ b | null | true |
_private.Mathlib.Util.WhatsNew.0.Mathlib.WhatsNew.whatsNew.match_1 | Mathlib.Util.WhatsNew | (motive : Lean.Name × Lean.ConstantInfo → Sort u_1) →
(x : Lean.Name × Lean.ConstantInfo) → ((c : Lean.Name) → (i : Lean.ConstantInfo) → motive (c, i)) → motive x | null | false |
Set.piecewise_preimage | Mathlib.Data.Set.Piecewise | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) [inst : (j : α) → Decidable (j ∈ s)] (f g : α → β) (t : Set β),
s.piecewise f g ⁻¹' t = s.ite (f ⁻¹' t) (g ⁻¹' t) | null | true |
Submodule.hasDistribPointwiseNeg._proof_3 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] (S : Submodule R A),
(-S).toAddSubmonoid = -S.toAddSubmonoid | null | false |
Lean.Meta.Grind.instInhabitedEntry | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.Entry | null | true |
List.findIdx_singleton | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {p : α → Bool}, List.findIdx p [a] = if p a = true then 0 else 1 | null | true |
Polynomial.normUnit_X | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : CommRing R] [inst_1 : NoZeroDivisors R] [inst_2 : NormalizationMonoid R],
normUnit Polynomial.X = 1 | null | true |
ProofWidgets.FilterDetailsProps.recOn | ProofWidgets.Component.FilterDetails | {motive : ProofWidgets.FilterDetailsProps → Sort u} →
(t : ProofWidgets.FilterDetailsProps) →
((summary filtered all : ProofWidgets.Html) →
(initiallyFiltered : Bool) →
motive { summary := summary, filtered := filtered, all := all, initiallyFiltered := initiallyFiltered }) →
motive t | null | false |
CategoryTheory.Limits.functorCategoryHasLimitsOfShape | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Functor K C) | null | true |
_private.Aesop.Options.Public.0.Aesop.initFn._@.Aesop.Options.Public.3910975230._hygCtx._hyg.4 | Aesop.Options.Public | IO (Lean.Option String) | null | false |
Pi.Lex.wellFounded | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} (r : ι → ι → Prop) {s : (i : ι) → α i → α i → Prop} [IsStrictTotalOrder ι r]
[Finite ι] [hs : ∀ (i : ι), WellFounded (s i)], WellFounded (Pi.Lex r fun {i} => s i) | null | true |
LinearEquiv.conjRingEquiv._proof_1 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_4} {M₁ : Type u_2} {M₂ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M₁] [inst_5 : Module R₂ M₂]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_6 : RingHomInvPair σ₁₂ σ₂₁] [inst_7 : RingHomInvPair σ₂₁ σ₁₂... | null | false |
_private.Mathlib.Topology.Instances.Irrational.0.dense_irrational._simp_1_2 | Mathlib.Topology.Instances.Irrational | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
InfiniteGalois.GaloisCoinsertionIntermediateFieldSubgroup._proof_2 | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] [IsGalois k K]
(K_1 : IntermediateField k K),
((fun H => IntermediateField.fixedField H) ∘ ⇑OrderDual.toDual)
((⇑OrderDual.toDual ∘ fun E => E.fixingSubgroup) K_1) ≤
K_1 | null | false |
AddSubsemigroup.prod_eq_top_iff | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] [Nonempty M] [Nonempty N] {s : AddSubsemigroup M}
{t : AddSubsemigroup N}, s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ | null | true |
Aesop.RuleStatsTotals.compareByTotalElapsed | Aesop.Stats.Basic | Aesop.RuleStatsTotals → Aesop.RuleStatsTotals → Ordering | null | true |
AlgebraicClosure.instCommRing._aux_18 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | (k : Type u_1) → [inst : Field k] → ℕ → AlgebraicClosure k → AlgebraicClosure k | null | false |
WeierstrassCurve.Jacobian.Point.toAffineAddEquiv_symm_apply | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] (W : WeierstrassCurve.Jacobian F) [inst_1 : DecidableEq F] (a : W.toAffine.Point),
(WeierstrassCurve.Jacobian.Point.toAffineAddEquiv W).symm a = WeierstrassCurve.Jacobian.Point.fromAffine a | null | true |
CategoryTheory.toPresheafToSheafCompComposeAndSheafify | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
(F : CategoryTheory.Funct... | The canonical natural transformation from
`(whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B` to
`presheafToSheaf J A ⋙ Sheaf.composeAndSheafify J F`. | true |
Isometry.isometryEquivOnRange | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} →
{β : Type v} →
[inst : EMetricSpace α] → [inst_1 : PseudoEMetricSpace β] → {f : α → β} → Isometry f → α ≃ᵢ ↑(Set.range f) | An isometry induces an isometric isomorphism between the source space and the
range of the isometry. | true |
Ideal.instAddCommGroupCotangent._proof_9 | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R),
autoParam (∀ (n : ℕ) (x : I.Cotangent), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
Lean.Server.Snapshots.Snapshot.mk.injEq | Lean.Server.Snapshots | ∀ (stx : Lean.Syntax) (mpState : Lean.Parser.ModuleParserState) (cmdState : Lean.Elab.Command.State)
(stx_1 : Lean.Syntax) (mpState_1 : Lean.Parser.ModuleParserState) (cmdState_1 : Lean.Elab.Command.State),
({ stx := stx, mpState := mpState, cmdState := cmdState } =
{ stx := stx_1, mpState := mpState_1, cmdSt... | null | true |
Lean.CodeAction.CommandCodeActionEntry.noConfusion | Lean.Server.CodeActions.Attr | {P : Sort u} →
{t t' : Lean.CodeAction.CommandCodeActionEntry} →
t = t' → Lean.CodeAction.CommandCodeActionEntry.noConfusionType P t t' | null | false |
CategoryTheory.CommRingObjCat.Hom._sizeOf_inst | Mathlib.CategoryTheory.Monoidal.Ring | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} →
(R₁ R₂ : CategoryTheory.CommRingObjCat C) → [SizeOf C] → SizeOf (R₁.Hom R₂) | null | false |
Std.Do.SPred.entails.trans' | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, (P ⊢ₛ Q) → (P ∧ Q ⊢ₛ R) → P ⊢ₛ R | null | true |
CategoryTheory.Subobject.Classifier.mk.inj | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {Ω₀ Ω : C} {truth : Ω₀ ⟶ Ω}
{mono_truth : autoParam (CategoryTheory.Mono truth) CategoryTheory.Subobject.Classifier.mono_truth._autoParam}
{χ₀ : (U : C) → U ⟶ Ω₀} {χ : {U X : C} → (m : U ⟶ X) → [CategoryTheory.Mono m] → X ⟶ Ω}
{isPullback :
∀ {U X : C} ... | null | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.done.noConfusion | Lean.Meta.Tactic.Grind.Intro | {P : Sort u} →
{goal goal' : Lean.Meta.Grind.Goal} →
Lean.Meta.Grind.IntroResult.done✝ goal = Lean.Meta.Grind.IntroResult.done✝ goal' → (goal = goal' → P) → P | null | false |
Iff.not | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop}, (a ↔ b) → (¬a ↔ ¬b) | **Alias** of `not_congr`. | true |
HurwitzZeta.hurwitzZetaEven_apply_zero | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle), HurwitzZeta.hurwitzZetaEven a 0 = if a = 0 then -1 / 2 else 0 | null | true |
Lean.Elab.Command.instInhabitedPreElabHeaderResult | Lean.Elab.MutualInductive | Inhabited Lean.Elab.Command.PreElabHeaderResult | null | true |
ComplexShape.embeddingDown'Add._proof_1 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ {A : Type u_1} [inst : AddCommSemigroup A] [inst_1 : IsRightCancelAdd A] (a b i₁ i₂ : A),
(ComplexShape.down' a).Rel i₁ i₂ ↔ (ComplexShape.down' a).Rel (i₁ + b) (i₂ + b) | null | false |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.largeSchroderSeries_eq_one_add_X_mul_largeSchroderSeries_add_X_mul_largeSchroderSeries_sq._proof_1_3 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ (n : ℕ), 0 < n → ¬n = n - 1 + 1 → False | null | false |
SimpleGraph.Walk.IsCircuit.egirth_le_length | Mathlib.Combinatorics.SimpleGraph.Girth | ∀ {α : Type u_1} {G : SimpleGraph α} {a : α} {w : G.Walk a a}, w.IsCircuit → G.egirth ≤ ↑w.length | null | true |
Subarray.mkSlice_roc_eq_mkSlice_rcc | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo hi : ℕ},
(Std.Roc.Sliceable.mkSlice xs lo<...=hi) = Std.Rcc.Sliceable.mkSlice xs (lo + 1)...=hi | null | true |
Std.Http.Internal.Mock.Client.casesOn | Std.Http.Transport | {motive : Std.Http.Internal.Mock.Client → Sort u} →
(t : Std.Http.Internal.Mock.Client) →
((shared : Std.Http.Internal.Mock.SharedState✝) → motive { shared := shared }) → motive t | null | false |
instTransIff | Init.Core | Trans Iff Iff Iff | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Tactic.open._regBuiltin.Lean.Parser.Tactic.open.docString_3 | Lean.Parser.Command | IO Unit | null | false |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.algebra₂._proof_4 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_2) [inst : CommRing R] {A : Type u_1} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B)
(r : ↥(Algebra.Smooth.DescentAux.subalgebra✝ R D)) (x : B),
r • x = (Algebra.Smooth.DescentAux.algebra₂._aux_1✝ R D) r *... | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.whereDecls._regBuiltin.Lean.Parser.Term.whereFinallySubsection.parenthesizer_15 | Lean.Parser.Term | IO Unit | null | false |
_private.Std.Http.Data.URI.Parser.0.Std.Http.URI.Parser.parseQuery._sparseCasesOn_1 | Std.Http.Data.URI.Parser | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Limits.hasPullback_op_iff_hasPushout | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z),
CategoryTheory.Limits.HasPullback f.op g.op ↔ CategoryTheory.Limits.HasPushout f g | null | true |
Set.Icc.instOrderBotElemOfFactLe.eq_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a b : α} [inst : Preorder α] [inst_1 : Fact (a ≤ b)], Set.Icc.instOrderBotElemOfFactLe = ⋯.orderBot | null | true |
AddSubmonoid.toNatSubmodule._proof_2 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {M : Type u_1} [inst : AddCommMonoid M],
Function.RightInverse Submodule.toAddSubmonoid fun S => { toAddSubmonoid := S, smul_mem' := ⋯ } | null | false |
List.findIdxNth.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (xs : List α) (n : ℕ), List.findIdxNth p xs n = List.findIdxNth.go p xs n 0 | null | true |
Real.sinc_apply | Mathlib.Analysis.SpecialFunctions.Trigonometric.Sinc | ∀ {x : ℝ}, Real.sinc x = if x = 0 then 1 else Real.sin x / x | null | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mpullback_mlieBracket._simp_1_2 | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : 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}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
IsStrictlyPositive.isUnit_cfcSqrt | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [IsSemitopologicalRing A] [T2Space A] (a : A),
autoParam (... | null | true |
Nucleus.instFrame._proof_4 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (a b : Nucleus X), Lattice.inf a b ≤ b | null | false |
Lean.IR.FnBody.set | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → Lean.IR.Arg → Lean.IR.FnBody → Lean.IR.FnBody | Store `y` at Position `sizeof(void*)*i` in `x`. `x` must be a Constructor object and `RC(x)` must be 1.
This operation is not part of λPure is only used during optimization. | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex.0.SSet.Subcomplex.Pairing.RankFunction.range_homOfLE_app_union_range_b_app._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | null | false |
Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n n_1 : ℕ),
(Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n = Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n_1) = (n = n_1) | null | true |
Real.instNormedAddCommGroupAngle._proof_30 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (x y z : Real.Angle), dist x z ≤ dist x y + dist y z | null | false |
Std.IterM.TerminationMeasures.Finite.mk._flat_ctor | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} → [inst : Std.Iterator α m β] → Std.IterM m β → Std.IterM.TerminationMeasures.Finite α m | null | false |
iSup_symmDiff_iSup_le | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : CompleteBooleanAlgebra α] {f g : ι → α},
symmDiff (⨆ i, f i) (⨆ i, g i) ≤ ⨆ i, symmDiff (f i) (g i) | The symmetric difference of two `iSup`s is at most the `iSup` of the symmetric differences. | true |
_private.Mathlib.Algebra.GroupWithZero.Invertible.0.invertibleDiv._simp_1 | Mathlib.Algebra.GroupWithZero.Invertible | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b c : G), a * (b / c) = a * b / c | null | false |
Filter.le_map₂_iff | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {h : Filter γ},
h ≤ Filter.map₂ m f g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → Set.image2 m s t ∈ h | null | true |
Set.image_val_sUnion | Mathlib.Data.Set.Subset | ∀ {α : Type u_2} {A : Set α} {T : Set (Set ↑A)}, Subtype.val '' ⋃₀ T = ⋃₀ {x | ∃ B ∈ T, Subtype.val '' B = x} | null | true |
Lean.JsonNumber.recOn | Lean.Data.Json.Basic | {motive : Lean.JsonNumber → Sort u} →
(t : Lean.JsonNumber) →
((mantissa : ℤ) → (exponent : ℕ) → motive { mantissa := mantissa, exponent := exponent }) → motive t | null | false |
Numbering.prefixedEquiv._proof_4 | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] (s : Finset X), Fintype.card ↥s ≤ Fintype.card X | null | false |
Subgroup.transferTransversal | Mathlib.GroupTheory.Transfer | {G : Type u_1} → [inst : Group G] → (H : Subgroup G) → G → H.LeftTransversal | The transfer transversal. Contains elements of the form `g ^ k • g₀` for fixed choices
of representatives `g₀` of fixed choices of representatives `q₀` of `⟨g⟩`-orbits in `G ⧸ H`. | true |
AddAction.IsBlock.orbit_of_normal | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {N : AddSubgroup G} [N.Normal] (a : X),
AddAction.IsBlock G (AddAction.orbit (↥N) a) | An orbit of a normal subgroup is a block | true |
IsZGroup.instQuotientSubgroupOfFinite | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] [Finite G] [IsZGroup G] (H : Subgroup G) [inst_3 : H.Normal], IsZGroup (G ⧸ H) | null | true |
CartanMatrix.C | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | (n : ℕ) → Matrix (Fin n) (Fin n) ℤ | The Cartan matrix of type Cₙ (rank n, corresponding to sp(2n)). | true |
Matrix.instPartialOrder | Mathlib.Analysis.Matrix.Order | {𝕜 : Type u_1} → {n : Type u_2} → [RCLike 𝕜] → PartialOrder (Matrix n n 𝕜) | The partial order on matrices given by `A ≤ B := (B - A).PosSemidef`. | true |
UniformOnFun.instPseudoEMetricSpace._proof_5 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : PseudoEMetricSpace β] [inst_1 : Finite ↑𝔖],
uniformity (UniformOnFun α β 𝔖) = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} | null | false |
ArithmeticFunction.instModule | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} →
{S : Type u_2} → [inst : Semiring R] → [inst_1 : AddCommMonoid S] → [Module R S] → Module R (ArithmeticFunction S) | null | true |
NumberField.instCommRingInfiniteAdeleRing._aux_34 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | (K : Type u_1) →
[inst : Field K] → NumberField.InfiniteAdeleRing K → NumberField.InfiniteAdeleRing K → NumberField.InfiniteAdeleRing K | null | false |
RingTheory.LinearMap._aux_Mathlib_Algebra_Algebra_Defs___unexpand_Algebra_linearMap_2 | Mathlib.Algebra.Algebra.Defs | Lean.PrettyPrinter.Unexpander | null | false |
Set.disjoint_image_inl_image_inr | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {u : Set α} {v : Set β}, Disjoint (Sum.inl '' u) (Sum.inr '' v) | null | true |
Int8.not_xor | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, ~~~a ^^^ b = ~~~(a ^^^ b) | null | true |
MvPolynomial.aeval_expand | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (p : ℕ) {A : Type u_5} [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] (f : σ → A) (φ : MvPolynomial σ R),
(MvPolynomial.aeval f) ((MvPolynomial.expand p) φ) = (MvPolynomial.aeval (f ^ p)) φ | null | true |
CategoryTheory.MorphismProperty.precoverage_top | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C], ⊤.precoverage = ⊤ | null | true |
CategoryTheory.Limits.coneRightOpOfCoconeEquiv | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor Jᵒᵖ C} → (CategoryTheory.Limits.Cocone F)ᵒᵖ ≌ CategoryTheory.Limits.Cone F.rightOp | Cocones on `F : Jᵒᵖ ⥤ C` are equivalent to cones on `F.rightOp : J ⥤ Cᵒᵖ`. | true |
StrictConvexOn.strictMonoOn_derivWithin | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, StrictConvexOn ℝ S f → DifferentiableOn ℝ f S → StrictMonoOn (derivWithin f S) S | If `f` is convex on `S` and differentiable on `S`, then its derivative within `S` is monotone
on `S`. | true |
Lean.LeanOptionValue._sizeOf_inst | Lean.Util.LeanOptions | SizeOf Lean.LeanOptionValue | null | false |
_private.Mathlib.Data.Bool.Basic.0.Bool.injective_iff._proof_1_1 | Mathlib.Data.Bool.Basic | ∀ {α : Sort u_1} {f : Bool → α}, f false ≠ f true → ∀ (x y : Bool), f x = f y → x = y | null | false |
_private.Mathlib.LinearAlgebra.Pi.0.LinearEquiv.piOptionEquivProd._simp_1 | Mathlib.LinearAlgebra.Pi | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
Set.orderIsoOfEq._proof_1 | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} [inst : Preorder α] (s t : Set α) (h : s = t) {a b : ↑s},
(Set.equivOfEq h) a ≤ (Set.equivOfEq h) b ↔ (Set.equivOfEq h) a ≤ (Set.equivOfEq h) b | null | false |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.regularity.match_1_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x z w : ZFSet.{u_1}) (motive : w ∈ x ∧ w ∈ z → Prop) (x_1 : w ∈ x ∧ w ∈ z),
(∀ (wx : w ∈ x) (wz : w ∈ z), motive ⋯) → motive x_1 | null | false |
Std.Http.Protocol.H1.Reader.State.closed.sizeOf_spec | Std.Http.Protocol.H1.Reader | ∀ {dir : Std.Http.Protocol.H1.Direction}, sizeOf Std.Http.Protocol.H1.Reader.State.closed = 1 | null | true |
CategoryTheory.AddMon.trivial_addMon_zero | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.AddMonObj.zero = CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | null | true |
CategoryTheory.Bicategory.InducedBicategory.Hom₂.casesOn | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {B : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Bicategory C] →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → Sort u} →
(t : CategoryTheory.Bicatego... | null | false |
Monotone.antitone_iterate_of_map_le | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x : α}, Monotone f → f x ≤ x → Antitone fun n => f^[n] x | If `f` is a monotone map and `f x ≤ x` at some point `x`, then the iterates `f^[n] x` form
an antitone sequence. | true |
Std.HashMap.Raw.valuesIter | Std.Data.HashMap.Iterator | {α β : Type u} → Std.HashMap.Raw α β → Std.Iter β | Returns a finite iterator over the values of a hash map.
The iterator yields the values in order and then terminates.
The key and value types must live in the same universe.
**Termination properties:**
* `Finite` instance: always
* `Productive` instance: always
| true |
CategoryTheory.ObjectProperty.extensionProductIter_le_of_isTriangulatedClosed₂' | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | true |
lift_rank_range_le | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
Cardinal.lift.{v, v'} (Module.rank R ↥f.range) ≤ Cardinal.lift.{v', v} (Module.rank R M) | The rank of the range of a linear map is at most the rank of the source. | true |
Nat.lt | Init.Prelude | ℕ → ℕ → Prop | Strict inequality of natural numbers, usually accessed via the `<` operator.
It is defined as `n < m = n + 1 ≤ m`.
| true |
Dioph.«term_D*_» | Mathlib.NumberTheory.Dioph | Lean.TrailingParserDescr | Diophantine functions are closed under multiplication. | true |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic.0.IsIntegral.of_pow.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic | ∀ {R : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] {x : B} {n : ℕ}
(motive : IsIntegral R (x ^ n) → Prop) (hx : IsIntegral R (x ^ n)),
(∀ (p : Polynomial R) (hmonic : p.Monic) (heval : Polynomial.eval₂ (algebraMap R B) (x ^ n) p = 0), motive ⋯) →
motive hx | null | false |
Turing.ToPartrec.Code.brecOn.eq | Mathlib.Computability.TuringMachine.Config | ∀ {motive : Turing.ToPartrec.Code → Sort u} (t : Turing.ToPartrec.Code)
(F_1 : (t : Turing.ToPartrec.Code) → Turing.ToPartrec.Code.below t → motive t),
Turing.ToPartrec.Code.brecOn t F_1 = F_1 t (Turing.ToPartrec.Code.brecOn.go t F_1).2 | null | true |
CategoryTheory.MonObj.mk | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
(one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
(mul : CategoryTheory.MonoidalCategoryStruct.tensorObj X X ⟶ X) →
autoParam
(C... | null | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitWithM | Mathlib.Tactic.DefEqAbuse | {m : Type → Type} →
[Monad m] →
{α : Type} →
{β : Type u_1} →
Array β →
(β → m α) →
autoParam α Lean.MessageData.visitWithM._auto_1✝ →
autoParam (α → α → α) Lean.MessageData.visitWithM._auto_3✝ → m α | Convenience wrapper which accumulates the results of `visitM` across `arr`, attempting to
produce `empty` and `combine` from `{}` and `(· ++ ·)` or `(· ∪ ·)`. | true |
Lean.Server.Ilean.rec | Lean.Server.References | {motive : Lean.Server.Ilean → Sort u} →
((version : ℕ) →
(module : Lean.Name) →
(directImports : Array Lean.Lsp.ImportInfo) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) →
motive
{ version := version, module := module, directImports :... | null | false |
_private.Mathlib.Tactic.DuplicateDecls.0.Mathlib.Tactic.DuplicateDecls.isAlias.isConstBVarApp._f | Mathlib.Tactic.DuplicateDecls | (a : Lean.Expr) → Lean.Expr.below a → Bool | null | false |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.exists_isBasis.match_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) (X : Set α) (motive : (∃ J, M.IsBasis J X ∧ ∅ ⊆ J) → Prop)
(x : ∃ J, M.IsBasis J X ∧ ∅ ⊆ J), (∀ (w : Set α) (hI : M.IsBasis w X) (right : ∅ ⊆ w), motive ⋯) → motive x | null | false |
RootPairing.reflectionPerm_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (self : RootPairing ι R M N) (i j : ι),
self.root j - (self.toLinearMap (self.root j)) (self.coroot i) • self.root i = self.root ((self.re... | null | true |
Set.LeftInvOn.image_inter | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {f : α → β} {f' : β → α},
Set.LeftInvOn f' f s → f '' (s₁ ∩ s) = f' ⁻¹' (s₁ ∩ s) ∩ f '' s | null | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.noConfusion | Lean.DocString.Extension | {P : Sort u} →
{content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock)} →
{priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)} →
{titleString : String} →
{title : Array (Lean.Doc.Inline Lean.ElabInline)} →
{content' : Array (Lean.Doc.Block Lean.ElabInline Lean... | null | false |
Std.DTreeMap.Internal.Impl.link.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hr_2 : Std.DTreeMap.Internal.Impl.leaf.Balanced),
Std.DTreeMap.Internal.Impl.link k v Std.DTreeMap.Internal.Impl.leaf r hr_2 hr =
{ impl := (Std.DTreeMap.Internal.Impl.insertMin k v r ⋯).impl, balanced_impl... | null | true |
Filter.Germ.LiftRel._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (r : β → γ → Prop) (_f : α → β) (_g : α → γ) (_f' : α → β)
(_g' : α → γ),
(l.germSetoid β) _f _f' →
(l.germSetoid γ) _g _g' → (∀ᶠ (x : α) in l, r (_f x) (_g x)) = ∀ᶠ (x : α) in l, r (_f' x) (_g' x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.