name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IsPrecomplete.map_algebraMap_iff | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : CommRing S] [inst_4 : Module S M] [inst_5 : Algebra R S] [IsScalarTower R S M],
IsPrecomplete (Ideal.map (algebraMap R S) I) M ↔ IsPrecomplete I M | null | true |
_private.Mathlib.Data.Vector3.0.Vector3.eq_nil.match_1_1 | Mathlib.Data.Vector3 | ∀ (motive : Fin2 0 → Prop) (i : Fin2 0), motive i | null | false |
PosNum.ldiff._sparseCasesOn_1 | Mathlib.Data.Num.Bitwise | {motive : PosNum → Sort u} →
(t : PosNum) → ((a : PosNum) → motive a.bit0) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
AddMonoidAlgebra.lift_mapRangeRingHom_algebraMap | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : AddMonoid M]
[inst_2 : Semiring A] [inst_3 : Algebra R A] [inst_4 : CommSemiring S] [inst_5 : Algebra S A] [inst_6 : Algebra R S]
[IsScalarTower R S A] (f : Multiplicative M →* A) (x : AddMonoidAlgebra R M),
((AddMonoi... | **Alias** of `AddMonoidAlgebra.lift_mapRingHom_algebraMap`. | true |
MvPowerSeries.nat_le_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R} {n : ℕ},
(∀ (d : σ →₀ ℕ), (Finsupp.weight w) d < n → (MvPowerSeries.coeff d) f = 0) → ↑n ≤ MvPowerSeries.weightedOrder w f | The order of a formal power series is at least `n` if
the `d`th coefficient is `0` for all `d` such that `weight w d < n`. | true |
CategoryTheory.CategoryOfElements.instHasInitialElementsOppositeOfIsRepresentable | Mathlib.CategoryTheory.Limits.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
[F.IsRepresentable], CategoryTheory.Limits.HasInitial F.Elements | null | true |
instSemiringCorner._aux_8 | Mathlib.RingTheory.Idempotents | {R : Type u_1} → (e : R) → [inst : NonUnitalSemiring R] → (idem : IsIdempotentElem e) → ℕ → idem.Corner → idem.Corner | null | false |
SzemerediRegularity.card_eq_of_mem_parts_chunk | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {s : Finset α},
s ∈ (SzemerediRegularity.chunk hP G ε hU).parts →
s.card = Fintype.card α / SzemerediRe... | null | true |
OptionT.instMonadAttach | Init.Control.Option | {m : Type u → Type v} → [Monad m] → [MonadAttach m] → MonadAttach (OptionT m) | null | true |
CategoryTheory.CosimplicialObject.Augmented.const_obj_hom | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.CosimplicialObject.Augmented.const.obj X).hom =
CategoryTheory.CategoryStruct.id ((CategoryTheory.CosimplicialObject.const C).obj X) | null | true |
_private.Init.Control.State.0.ForM.forIn.match_3 | Init.Control.State | {β : Type u_1} →
(motive : Except β (PUnit.{u_1 + 1} × β) → Sort u_2) →
(__do_lift : Except β (PUnit.{u_1 + 1} × β)) →
((a : PUnit.{u_1 + 1} × β) → motive (Except.ok a)) → ((a : β) → motive (Except.error a)) → motive __do_lift | null | false |
sSetTopAdj_unit_app_app_down | Mathlib.AlgebraicTopology.SingularSet | ∀ (S : SSet) (m : SimplexCategoryᵒᵖ) (a : S.obj m),
((CategoryTheory.ConcreteCategory.hom ((sSetTopAdj.unit.app S).app m)) a).down =
CategoryTheory.CategoryStruct.comp (SSet.toTopSimplex.inv.app (Opposite.unop m))
(SSet.toTop.map (SSet.yonedaEquiv.symm a)) | null | true |
instAddCommGroupTangentSpace._proof_11 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [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] (_x : M),
autoParam
(∀ (n : ℕ) (x... | null | false |
_private.Init.Data.SInt.Lemmas.0.Int16.le_total._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : Int16}, (x ≤ y) = (x.toInt ≤ y.toInt) | null | false |
IsHomeomorph.toEquiv_homeomorph | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y)
(hf : IsHomeomorph f), (IsHomeomorph.homeomorph f hf).toEquiv = Equiv.ofBijective f ⋯ | null | true |
Stream'.get_of_bisim._f | Mathlib.Data.Stream.Init | ∀ {α : Type u} (R : Stream' α → Stream' α → Prop),
Stream'.IsBisimulation R →
∀ (x : ℕ)
(f :
Nat.below (motive := fun x =>
∀ {s₁ s₂ : Stream' α}, R s₁ s₂ → s₁.get x = s₂.get x ∧ R (Stream'.drop (x + 1) s₁) (Stream'.drop (x + 1) s₂))
x)
{s₁ s₂ : Stream' α}, R s₁ s₂ → s₁.get ... | null | false |
RestrictScalars.addEquiv | Mathlib.Algebra.Algebra.RestrictScalars | (R : Type u_1) → (S : Type u_2) → (M : Type u_3) → [inst : AddCommMonoid M] → RestrictScalars R S M ≃+ M | `RestrictScalars.addEquiv` is the additive equivalence with the original module. | true |
MeasureTheory.Measure.count_ne_zero | Mathlib.MeasureTheory.Measure.Count | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α}, s.Nonempty → MeasureTheory.Measure.count s ≠ 0 | **Alias** of the reverse direction of `MeasureTheory.Measure.count_ne_zero_iff`. | true |
Num.decidablePrime | Mathlib.Data.Num.Prime | DecidablePred Num.Prime | null | true |
Prod.toSigma_inj._simp_1 | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_7} {β : Type u_8} {x y : α × β}, (x.toSigma = y.toSigma) = (x = y) | null | false |
_private.Lean.Elab.Tactic.Impossible.0.Lean.Elab.Tactic.mkImpossibleNegType | Lean.Elab.Tactic.Impossible | Lean.MVarId → Lean.Expr → Lean.Parser.Tactic.ImpossibleConfig → Lean.MetaM (Lean.Expr × Array Lean.Name) | Builds the negated reverted target the user must inhabit, of the shape
`∀ ms, ¬(∀ xs, body)` where `ms` are the goal's expression metavariables
(abstracted via `mkValueTypeClosure`, which handles arbitrary mctx depths)
and `xs` are the reverted local hypotheses. With `+levels`, the surrounding
declaration's universe pa... | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.getElem_succ_leftInvSeq_alternatingWord._simp_1_2 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {G : Type u_1} [inst : Mul G] [IsRightCancelMul G] (a : G) {b c : G}, (b * a = c * a) = (b = c) | null | false |
StandardSubspace.toClosedSubmodule_inj._simp_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] {S T : StandardSubspace H},
(S.toClosedSubmodule = T.toClosedSubmodule) = (S = T) | null | false |
SeminormedRing.mk._flat_ctor | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
(norm : α → ℝ) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoPar... | null | false |
CategoryTheory.Over.iteratedSliceBackward | Mathlib.CategoryTheory.Comma.Over.Basic | {T : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} T] →
{X : T} → (f : CategoryTheory.Over X) → CategoryTheory.Functor (CategoryTheory.Over f.left) (CategoryTheory.Over f) | Given f : Y ⟶ X, this is the obvious functor from T/Y to (T/X)/f | true |
CategoryTheory.Functor.PushoutObjObj.ι.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₂ Y₂ : C₂} {f₂ : X₂ ⟶ Y₂}
(sq : F.P... | null | true |
CategoryTheory.Functor.IsLocallyFull.recOn | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | {C : Type uC} →
[inst : CategoryTheory.Category.{vC, uC} C] →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{vD, uD} D] →
{G : CategoryTheory.Functor C D} →
{K : CategoryTheory.GrothendieckTopology D} →
{motive : G.IsLocallyFull K → Sort u} →
(t : G.IsLocallyF... | null | false |
HomologicalComplex.IsStrictlySupportedOutside.mk._flat_ctor | Mathlib.Algebra.Homology.Embedding.IsSupported | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : HomologicalComplex C c'} {e : c.Embedding c'},
(∀ (i : ι), CategoryTheory.Limits.IsZero (K.X (e.f i))) → K.IsStrictlySu... | null | false |
UpperHemicontinuousWithinAt.union | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_3} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → Set β} {s : Set α}
{x : α},
UpperHemicontinuousWithinAt f s x →
UpperHemicontinuousWithinAt g s x → UpperHemicontinuousWithinAt (fun x => f x ∪ g x) s x | Pointwise unions of upper hemicontinuous maps are upper hemicontinuous. | true |
ENNReal.eq_top_of_forall_nnreal_le | Mathlib.Data.ENNReal.Inv | ∀ {x : ENNReal}, (∀ (r : NNReal), ↑r ≤ x) → x = ⊤ | null | true |
Std.DTreeMap.Internal.Impl.getKeyD_minKey | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {he : t.isEmpty = false} {fallback : α}, t.getKeyD (t.minKey he) fallback = t.minKey he | null | true |
AlgebraicGeometry.instCompactSpaceCarrierCarrierCommRingCatPullbackSchemeOfQuasiCompact | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [AlgebraicGeometry.QuasiCompact f] [CompactSpace ↥Y],
CompactSpace ↥(CategoryTheory.Limits.pullback f g) | null | true |
Codisjoint.sup_right | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α} (c : α),
Codisjoint a b → Codisjoint a (b ⊔ c) | null | true |
Cycle.formPerm_eq_self_of_notMem | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Cycle α) (h : s.Nodup), ∀ x ∉ s, (s.formPerm h) x = x | null | true |
Lean.Elab.Tactic.Do.ProofMode.addLocalVarInfo | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Syntax → Lean.LocalContext → Lean.Expr → Option Lean.Expr → optParam Bool false → Lean.MetaM Unit | null | true |
InnerProductSpace.Core.norm_eq_sqrt_re_inner | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), ‖x‖ = √(RCLike.re (inner 𝕜 x x)) | null | true |
CategoryTheory.Sheaf.over | Mathlib.CategoryTheory.Sites.Over | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
CategoryTheory.Sheaf J A → (X : C) → CategoryTheory.Sheaf (J.over X) A | Given `F : Sheaf J A` and `X : C`, this is the pullback of `F` on `J.over X`. | true |
_private.Mathlib.Algebra.Homology.Embedding.Connect.0.CochainComplex.ConnectData.d_comp_d._proof_1_6 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (m p : ℤ), m + 1 = p → ∀ (n : ℕ), Int.negSucc (n + 1 + 1) + 1 = m → m = Int.negSucc (n + 1) | null | false |
_private.Mathlib.Combinatorics.Enumerative.Schroder.0.Nat.smallSchroder.match_1.eq_1 | Mathlib.Combinatorics.Enumerative.Schroder | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ => h_3 n) =
h_1 () | null | true |
IsCoprime.neg_neg | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y : R}, IsCoprime x y → IsCoprime (-x) (-y) | null | true |
Std.IsPartialOrder.of_le | Init.Data.Order.Factories | ∀ {α : Type u} [inst : LE α],
autoParam (Std.Refl fun x1 x2 => x1 ≤ x2) Std.IsPartialOrder.of_le._auto_1 →
autoParam (Std.Antisymm fun x1 x2 => x1 ≤ x2) Std.IsPartialOrder.of_le._auto_3 →
∀
(le_trans :
autoParam (Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2)
... | If an `LE α` is reflexive, antisymmetric and transitive, then it represents a partial order.
| true |
Lean.SubExpr.Pos | Lean.SubExpr | Type | A position of a subexpression in an expression.
We use a simple encoding scheme for expression positions `Pos`:
every `Expr` constructor has at most 3 direct expression children. Considering an expression's type
to be one extra child as well, we can injectively map a path of `childIdxs` to a natural number
by computin... | true |
StandardEtalePair.instCommRingRing._proof_6 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R) (a : P.Ring), 0 + a = a | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_of_not_smulOverflow._proof_1_7 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
x.toInt * y.toInt < 2 ^ w ∧ -2 ^ w ≤ x.toInt * y.toInt → ¬x.toInt * y.toInt < (2 ^ (w + 1) + 1) / 2 → False | null | false |
VectorFourier.fourierIntegral.eq_1 | Mathlib.Analysis.Fourier.FourierTransform | ∀ {𝕜 : Type u_1} [inst : CommRing 𝕜] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : MeasurableSpace V] {W : Type u_3} [inst_4 : AddCommGroup W] [inst_5 : Module 𝕜 W] {E : Type u_4}
[inst_6 : NormedAddCommGroup E] [inst_7 : NormedSpace ℂ E] (e : AddChar 𝕜 Circle) (μ : MeasureTheory.Mea... | null | true |
padicNorm_two_harmonic | Mathlib.NumberTheory.Harmonic.Int | ∀ {n : ℕ}, n ≠ 0 → ‖↑(harmonic n)‖ = 2 ^ Nat.log 2 n | The 2-adic norm of the n-th harmonic number is 2 raised to the logarithm of n in base 2. | true |
CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
[inst_1 : W.HasLeftCalculusOfFractions] →
{X Y : C} →
(s : X ⟶ Y) →
W s →
((CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj Y ⟶
... | The morphism in `Localization W` that is the formal inverse of a morphism
which belongs to `W`. | true |
List.length_take_le' | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} (i : ℕ) (l : List α), (List.take i l).length ≤ l.length | null | true |
essInf_antitone_measure._auto_1 | Mathlib.MeasureTheory.Function.EssSup | Lean.Syntax | null | false |
WithZero.coe_expEquiv_apply | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {G : Type u_5} [inst : AddGroup G] (a : G), ↑(WithZero.expEquiv a) = WithZero.exp a | null | true |
Function.Embedding.trans_arrowCongrLeft | Mathlib.Logic.Embedding.Basic | ∀ {α₁ : Sort u} {α₂ : Sort v} {α₃ : Sort x} {γ : Sort w} [inst : Inhabited γ] (e₁₂ : α₁ ↪ α₂) (e₂₃ : α₂ ↪ α₃),
e₁₂.arrowCongrLeft.trans e₂₃.arrowCongrLeft = (e₁₂.trans e₂₃).arrowCongrLeft | null | true |
leansearchclient.backend | LeanSearchClient.Basic | Lean.Option String | null | true |
ModelWithCorners._sizeOf_1 | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : Type u_1} →
{inst : NontriviallyNormedField 𝕜} →
{E : Type u_2} →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : NormedSpace 𝕜 E} →
{H : Type u_3} →
{inst_3 : TopologicalSpace H} → [SizeOf 𝕜] → [SizeOf E] → [SizeOf H] → ModelWithCorners 𝕜 E H → ℕ | null | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.equivMapDomain._simp_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_9} {M : Type u_10} [inst : Zero M] (self : α →₀ M) (a : α), (a ∈ self.support) = (self.toFun a ≠ 0) | null | false |
_private.Init.Data.String.Slice.0.String.Slice.lines.lineMap.match_1 | Init.Data.String.Slice | (motive : Option String.Slice → Sort u_1) →
(x : Option String.Slice) → ((s : String.Slice) → motive (some s)) → ((x : Option String.Slice) → motive x) → motive x | null | false |
ModuleCat.addCommGroupObj._proof_23 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (ModuleCat R)) (j : J) (a b : (F.comp (CategoryTheory.forget (ModuleCat R))).obj j),
a + b = b + a | null | false |
Complex.tan_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.tan ↑x).im = 0 | null | true |
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.isTactic._sparseCasesOn_1 | Lean.Parser.Tactic.Doc | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Aesop.Frontend.Priority.ctorIdx | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority → ℕ | null | false |
PredSubOrder.mk._flat_ctor | Mathlib.Algebra.Order.SuccPred | {α : Type u_1} →
[inst : Preorder α] →
[inst_1 : Sub α] →
[inst_2 : One α] →
(pred : α → α) →
(∀ (a : α), pred a ≤ a) →
(∀ {a : α}, a ≤ pred a → IsMin a) →
(∀ {a b : α}, a < b → a ≤ pred b) → (∀ (x : α), pred x = x - 1) → PredSubOrder α | null | false |
SimpleGraph.isAcyclic_starGraph | Mathlib.Combinatorics.SimpleGraph.Star | ∀ {V : Type u_1} (r : V), (SimpleGraph.starGraph r).IsAcyclic | null | true |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.WF.merge'.match_1_5 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} {le : α → α → Bool} {n : ℕ} (r₁ : ℕ) (t₁ t₂ : Batteries.BinomialHeap.Imp.Heap α) (a : α)
(n_1 : Batteries.BinomialHeap.Imp.HeapNode α)
(motive :
Batteries.BinomialHeap.Imp.Heap.WF le n
(Batteries.BinomialHeap.Imp.Heap.merge le t₁ (Batteries.BinomialHeap.Imp.Heap.cons r₁.succ a n_1 t₂)... | null | false |
Std.DTreeMap.Internal.Impl.containsThenInsertIfNew!.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (v : β k) (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.containsThenInsertIfNew! k v t =
if Std.DTreeMap.Internal.Impl.contains k t = true then (true, t)
else (false, Std.DTreeMap.Internal.Impl.insert! k v t) | null | true |
Nat.b_eq_digitChar | Init.Data.Nat.ToString | ∀ {n : ℕ}, 'b' = n.digitChar ↔ n = 11 | null | true |
DyckWord.equivTree_apply | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord), DyckWord.equivTree p = p.toTree | null | true |
Module.preReflection | Mathlib.LinearAlgebra.Reflection | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → M → Module.Dual R M → Module.End R M | Given an element `x` in a module `M` and a linear form `f` on `M`, we define the endomorphism
of `M` for which `y ↦ y - (f y) • x`.
One is typically interested in this endomorphism when `f x = 2`; this definition exists to allow the
user defer discharging this proof obligation. See also `Module.reflection`. | true |
Std.LawfulOrderMax.rec | Init.Data.Order.Classes | {α : Type u} →
[inst : Max α] →
[inst_1 : LE α] →
{motive : Std.LawfulOrderMax α → Sort u_1} →
([toMaxEqOr : Std.MaxEqOr α] → [toLawfulOrderSup : Std.LawfulOrderSup α] → motive ⋯) →
(t : Std.LawfulOrderMax α) → motive t | null | false |
Ideal.prod_span_singleton | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {ι : Type u_2} (s : Finset ι) (I : ι → R),
∏ i ∈ s, Ideal.span {I i} = Ideal.span {∏ i ∈ s, I i} | null | true |
instLawfulCommIdentityUInt16HXorOfNat | Init.Data.UInt.Bitwise | Std.LawfulCommIdentity (fun x1 x2 => x1 ^^^ x2) 0 | null | true |
_private.Mathlib.Data.List.OfFn.0.List.find?_ofFn_eq_some._proof_1_5 | Mathlib.Data.List.OfFn | ∀ {n : ℕ} (i : Fin n), ∀ j < ↑i, j < n | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.H2π_eq_zero_iff._simp_1_5 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
CategoryTheory.ShortComplex.leftHomologyMap' e.inv h₂ h₁ =
(CategoryTheory.ShortComplex.... | null | false |
FirstOrder.Language.ClosedUnder.sInf | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {n : ℕ} {f : L.Functions n} {S : Set (Set M)},
(∀ s ∈ S, FirstOrder.Language.ClosedUnder f s) → FirstOrder.Language.ClosedUnder f (sInf S) | null | true |
Infinite.of_not_fintype | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1}, (∀ (a : Fintype α), False) → Infinite α | null | true |
Lean.ModuleDoc.casesOn | Lean.DocString.Extension | {motive : Lean.ModuleDoc → Sort u} →
(t : Lean.ModuleDoc) →
((doc : String) →
(declarationRange : Lean.DeclarationRange) → motive { doc := doc, declarationRange := declarationRange }) →
motive t | null | false |
Lean.Meta.ApplyNewGoals.recOn | Init.Meta.Defs | {motive : Lean.Meta.ApplyNewGoals → Sort u} →
(t : Lean.Meta.ApplyNewGoals) →
motive Lean.Meta.ApplyNewGoals.nonDependentFirst →
motive Lean.Meta.ApplyNewGoals.nonDependentOnly → motive Lean.Meta.ApplyNewGoals.all → motive t | null | false |
Polynomial.toFinsuppIsoLinear | Mathlib.Algebra.Polynomial.Basic | (R : Type u) → [inst : Semiring R] → Polynomial R ≃ₗ[R] AddMonoidAlgebra R ℕ | Linear isomorphism between `R[X]` and `R[ℕ]`. This is just an
implementation detail, but it can be useful to transfer results from `Finsupp` to polynomials. | true |
Nat.sqrt.iter._unsafe_rec | Batteries.Data.Nat.Basic | ℕ → ℕ → ℕ | null | false |
Rep.resFunctor._proof_3 | Mathlib.RepresentationTheory.Rep.Res | ∀ {k : Type u_2} [inst : Semiring k] {G : Type u_3} {H : Type u_4} [inst_1 : Monoid G] [inst_2 : Monoid H] (f : H →* G)
{X Y Z : Rep.{u_1, u_2, u_3} k G} (f_1 : X ⟶ Y) (g : Y ⟶ Z),
Rep.ofHom { toLinearMap := ↑(Rep.Hom.hom (CategoryTheory.CategoryStruct.comp f_1 g)), isIntertwining' := ⋯ } =
CategoryTheory.Categ... | null | false |
Real.sin_sq_pi_over_two_pow | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℕ), Real.sin (Real.pi / 2 ^ (n + 1)) ^ 2 = 1 - (Real.sqrtTwoAddSeries 0 n / 2) ^ 2 | null | true |
TwoSidedIdeal.finsetProd_mem | Mathlib.RingTheory.TwoSidedIdeal.BigOperators | ∀ {R : Type u_1} [inst : CommRing R] (I : TwoSidedIdeal R) {ι : Type u_2} (s : Finset ι) (f : ι → R),
(∃ x ∈ s, f x ∈ I) → s.prod f ∈ I | null | true |
TrivSqZeroExt.inl_neg | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} (M : Type v) [inst : Neg R] [inst_1 : NegZeroClass M] (r : R),
TrivSqZeroExt.inl (-r) = -TrivSqZeroExt.inl r | null | true |
_private.Mathlib.Topology.Homotopy.HSpaces.0.HSpace.prod._simp_2 | Mathlib.Topology.Homotopy.HSpaces | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}, ((a₁, b₁) = (a₂, b₂)) = (a₁ = a₂ ∧ b₁ = b₂) | null | false |
CategoryTheory.Limits.IsLimit.binaryFanSwap._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {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))
(j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.... | null | false |
NumberField.mixedEmbedding.polarSpaceCoord.eq_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.polarSpaceCoord K =
(NumberField.mixedEmbedding.polarCoord K).transHomeomorph
(NumberField.mixedEmbedding.homeoRealMixedSpacePolarSpace K) | null | true |
Topology.isEmbedding_sigmoid | Mathlib.Analysis.SpecialFunctions.Sigmoid | Topology.IsEmbedding unitInterval.sigmoid | null | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.ker_eval₂Hom_universalFactorizationMap._simp_1_4 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), a * c - b * c = (a - b) * c | null | false |
ContinuousOrderHom.instContinuousOrderHomClass | Mathlib.Topology.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : TopologicalSpace β]
[inst_3 : Preorder β], ContinuousOrderHomClass (α →Co β) α β | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt16.reduceGE.declare_127._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.211 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
differentiableAt_natCast | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] [inst_7 : NatCast F] (n : ℕ) (x : E), DifferentiableAt 𝕜 (↑n) x | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Partial.0.hasStrictFDerivAt_uncurry_coprod.match_1_1 | Mathlib.Analysis.Calculus.FDeriv.Partial | {E₁ : Type u_1} →
{E₂ : Type u_2} →
(motive : (E₁ × E₂) × E₁ × E₂ → Sort u_3) → (x : (E₁ × E₂) × E₁ × E₂) → ((v w : E₁ × E₂) → motive (v, w)) → motive x | null | false |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.processAssignmentFOApprox.loop | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Lean.Expr → Lean.MetaM Bool | null | true |
Std.DTreeMap.Internal.Impl.Const.maxEntry.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : Type u_2} →
(motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α fun x => β) →
(x_1 : x.isEmpty = false) →
((size : ℕ) →
(k : α) →
(v : β) →
(l : Std... | null | false |
intervalIntegral.integral_finset_sum | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
{ι : Type u_8} {s : Finset ι} {f : ι → ℝ → E},
(∀ i ∈ s, IntervalIntegrable (f i) μ a b) →
∫ (x : ℝ) in a..b, ∑ i ∈ s, f i x ∂μ = ∑ i ∈ s, ∫ (x : ℝ) in a..b, f i x ∂μ | **Alias** of `intervalIntegral.integral_finsetSum`. | true |
ContinuousAffineEquiv.prodAssoc_toAffineEquiv | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ (k : Type u_1) (P₁ : Type u_2) (P₂ : Type u_3) (P₃ : Type u_4) {V₁ : Type u_6} {V₂ : Type u_7} {V₃ : Type u_8}
[inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁]
[inst_4 : TopologicalSpace P₁] [inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂]
... | null | true |
Std.DTreeMap.maxKeyD_insert | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β k}
{fallback : α}, (t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | null | true |
CategoryTheory.instInhabitedMkId | Mathlib.CategoryTheory.Category.KleisliCat | {α : Type u} → [Inhabited α] → Inhabited (CategoryTheory.KleisliCat.mk id α) | null | true |
CategoryTheory.ProjectiveResolution.homotopyEquiv_inv_π_assoc | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(P Q : CategoryTheory.ProjectiveResolution X) {Z : HomologicalComplex C (ComplexShape.down ℕ)}
(h : (ChainComplex.single₀ C).obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp (P.homotopyEquiv Q).inv (CategoryTheory.C... | null | true |
CommGrpCat.coyoneda.eq_1 | Mathlib.Algebra.Category.Grp.Yoneda | CommGrpCat.coyoneda =
{
obj := fun M =>
{ obj := fun N => CommGrpCat.of (↑(Opposite.unop M) →* ↑N),
map := fun {X Y} f => CommGrpCat.ofHom (MonoidHom.compHom (CommGrpCat.Hom.hom f)), map_id := ⋯, map_comp := ⋯ },
map := fun {X Y} f => { app := fun N => CommGrpCat.ofHom (CommGrpCat.Hom.hom f.unop... | null | true |
ContinuousLinearEquiv.isAddHaarMeasure_map | Mathlib.MeasureTheory.Group.Measure | ∀ {E : Type u_3} {F : Type u_4} {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommGroup E] [inst_3 : Module R E] [inst_4 : AddCommGroup F] [inst_5 : Module S F]
[inst_6 : TopologicalSpace E] [IsTopologicalAddGroup E] [inst_8 : TopologicalSpace F] [IsTopologicalAddGroup F]
{σ... | A convenience wrapper for `MeasureTheory.Measure.isAddHaarMeasure_map`. | true |
SemiRingCat.hom_ext | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : SemiRingCat} {f g : R ⟶ S}, SemiRingCat.Hom.hom f = SemiRingCat.Hom.hom g → f = g | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.