name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Transform.0.Lean.Meta.unfoldIfArgIsAppOf._sparseCasesOn_1 | Lean.Meta.Transform | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Order.UpperLower.Closure.0.IsAntichain.minimal_mem_upperClosure_iff_mem._simp_1_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : LE α] {s : Set α} (hs : IsUpperSet s) {a : α}, (a ∈ { carrier := s, upper' := hs }) = (a ∈ s) | null | false |
CategoryTheory.Limits.HasWideCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} → {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (J → (X ⟶ Y)) → Prop | A family `f` of parallel morphisms has a wide coequalizer if the diagram `parallelFamily f` has
a colimit. | true |
_private.Batteries.Data.Array.Scan.0.Array.getElem_succ_scanl._proof_1_4 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {b : β} {as : Array α} {f : β → α → β} (h : i + 1 < (Array.scanl f b as).size),
(List.scanl f b as.toList)[i + 1] = f (List.scanl f b as.toList)[i] as[i] | null | false |
IsCompact.of_subset_of_specializes | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X},
IsCompact s → t ⊆ s → (∀ x ∈ s, ∃ y ∈ t, x ⤳ y) → IsCompact t | null | true |
RootPairing.RootPositiveForm.posForm._proof_5 | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {S : Type u_1} [inst : CommRing S], RingHomSurjective (RingHom.id S) | null | false |
_private.Init.Data.String.Basic.0.String.Pos.ofSliceTo_sliceTo._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.TFAE_exists_lt_isLittleO_pow.match_1_7 | Mathlib.Analysis.SpecificLimits.Normed | ∀ (f : ℕ → ℝ) (R : ℝ) (motive : (∃ a ∈ Set.Ioo 0 R, f =O[Filter.atTop] fun x => a ^ x) → Prop)
(x : ∃ a ∈ Set.Ioo 0 R, f =O[Filter.atTop] fun x => a ^ x),
(∀ (a : ℝ) (ha : a ∈ Set.Ioo 0 R) (H : f =O[Filter.atTop] fun x => a ^ x), motive ⋯) → motive x | null | false |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor? | Lean.Meta.Tactic.Grind.PropagateInj | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Option (Lean.Expr × Lean.Expr)) | null | true |
Std.DHashMap.Const.get!_inter_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α}, k ∉ m₂ → Std.DHashMap.Const.get! (m₁.inter m₂) k = default | null | true |
Std.TreeMap.minKey_le_minKey_erase | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{he : (t.erase k).isEmpty = false}, (cmp (t.minKey ⋯) ((t.erase k).minKey he)).isLE = true | null | true |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
Quaternion.imI_sub | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a b : Quaternion R), (a - b).imI = a.imI - b.imI | null | true |
contDiffGroupoid_prod | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : 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] {E' : Type u_5} {H' : Type u_6}
[inst_4 : NormedAddCommGroup E'] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : TopologicalSpace H']
... | The product of two `C^n` open partial homeomorphisms is `C^n`. | true |
LinOrd.hom_comp | Mathlib.Order.Category.LinOrd | ∀ {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z),
LinOrd.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (LinOrd.Hom.hom g).comp (LinOrd.Hom.hom f) | null | true |
_private.Mathlib.Data.Num.Basic.0.PosNum.sqrtAux._unsafe_rec | Mathlib.Data.Num.Basic | PosNum → Num → Num → Num | null | false |
LE.le.lt_or_eq_dec | Mathlib.Order.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} [DecidableLE α], a ≤ b → a < b ∨ a = b | **Alias** of `Decidable.lt_or_eq_of_le`. | true |
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 ι], (∀ (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 |
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 |
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 |
_private.Lean.Meta.LevelDefEq.0.Lean.Meta.solve.match_3 | Lean.Meta.LevelDefEq | (motive : Lean.Level → Lean.Level → Sort u_1) →
(u v : Lean.Level) →
((mvarId : Lean.LMVarId) → (x : Lean.Level) → motive (Lean.Level.mvar mvarId) x) →
((x : Lean.Level) → (a : Lean.LMVarId) → motive x (Lean.Level.mvar a)) →
((v₁ v₂ : Lean.Level) → motive Lean.Level.zero (v₁.max v₂)) →
((a... | null | false |
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.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 |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt64.reduceDiv._regBuiltin.UInt64.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.99 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
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 |
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 | (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 |
_private.Mathlib.Logic.Nonempty.0.exists_const_iff.match_1_1 | Mathlib.Logic.Nonempty | ∀ {α : Sort u_1} {P : Prop} (motive : (∃ x, P) → Prop) (x : ∃ x, P), (∀ (a : α) (h : P), motive ⋯) → motive x | 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.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.Tactic.Linter.Style.0.Mathlib.Linter.Style.cdotLinter.match_3 | Mathlib.Tactic.Linter.Style | (motive : Option Unit → Sort u_1) → (x : Option Unit) → (Unit → motive none) → ((a : Unit) → motive (some a)) → motive x | 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 |
_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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.