name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Grind.instCommRingBitVec._proof_2 | Init.GrindInstances.Ring.BitVec | ∀ {w : ℕ} (n : ℕ) (a : BitVec w), n • a = ↑n * a | null | false |
ContinuousLinearMap.piEquivL._proof_9 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ (𝕜 : Type u_1) [inst : NormedField 𝕜] (E : Type u_2) {ι : Type u_4} (F : ι → Type u_3) [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : (i : ι) → AddCommGroup (F i)]
[inst_5 : (i : ι) → Module 𝕜 (F i)] [inst_6 : (i : ι) → TopologicalSpace (F i)]
[inst_7 : ∀ (i : ι), Is... | null | false |
CategoryTheory.Limits.pushoutPushoutRightIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ X₃ Z₁ Z₂ : C} →
(g₁ : Z₁ ⟶ X₁) →
(g₂ : Z₁ ⟶ X₂) →
(g₃ : Z₂ ⟶ X₂) →
(g₄ : Z₂ ⟶ X₃) →
[inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂] →
[inst_2 : CategoryTheory.Limits.HasPushout g₃ ... | `X₁ ⨿[Z₁] (X₂ ⨿[Z₂] X₃)` is the pushout `(X₁ ⨿[Z₁] X₂) ×[X₂] (X₂ ⨿[Z₂] X₃)`. | true |
Affine.Simplex.exsphere_compl | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1))),
s.exsphere signsᶜ = s.exsphere signs | null | true |
Subspace.orderIsoFiniteCodimDim | Mathlib.LinearAlgebra.Dual.Lemmas | {K : Type u_4} →
{V : Type u_5} →
[inst : Field K] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module K V] → { W // FiniteDimensional K (V ⧸ W) } ≃o { W // FiniteDimensional K ↥W }ᵒᵈ | For any vector space, `dualAnnihilator` and `dualCoannihilator` gives an antitone order
isomorphism between the finite-codimensional subspaces in the vector space and the
finite-dimensional subspaces in its dual. | true |
MeasureTheory.Measure.ae_le_pi | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] {β : ι → Type u_4}
[inst_3 : (i : ι) → Preorder (β i)] {f f' : (i : ι) → α i → β i},
(∀ (i : ι), f i ≤ᵐ[μ i] f' i) → (fun x i =... | null | true |
Aesop.ForwardRulePriority.normSafe.sizeOf_spec | Aesop.Rule.Forward | ∀ (n : ℤ), sizeOf (Aesop.ForwardRulePriority.normSafe n) = 1 + sizeOf n | null | true |
LinearMap.kerComplementEquivRange._proof_1 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} [inst : Ring R], RingHomSurjective (RingHom.id R) | null | false |
Function.Bijective.existsUnique_iff | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → ∀ {p : β → Prop}, (∃! y, p y) ↔ ∃! x, p (f x) | null | true |
BitVec.msb_neg_of_ne_intMin_of_ne_zero | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x ≠ BitVec.intMin w → x ≠ 0#w → (-x).msb = !x.msb | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.card_nonuniformWitness_sdiff_biUnion_star._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
CharTwo.natCast_cases | Mathlib.Algebra.CharP.Two | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] [CharP R 2] (n : ℕ), ↑n = 0 ∨ ↑n = 1 | null | true |
Std.Internal.List.getValue?_filter_not_contains_map_fst_of_contains_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getValue? k (List.filter (fun p => !(List.map Sigma.fst l₂).contains p.fst) l₁) = none | null | true |
Int.log_zpow | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
{b : ℕ}, 1 < b → ∀ (z : ℤ), Int.log b (↑b ^ z) = z | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb_flattenList._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ (hi lo : ℕ) {w : ℕ} (vs : List (BitVec w)),
w * (lo / w) ≤ lo → ∀ (i : ℕ), ¬lo + i - w * (lo / w) = lo - w * (lo / w) + i → False | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_39 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'},
¬p₁.Nil →
∀ (k : ℕ),
(∀ (i : ℕ) (h : i < p₁.darts.length), p₂.darts[i + k]? = some p₁.darts[i]) →
∀ (i : ℕ), i = p₁.length → k < p₂.support.tail.length | null | false |
ProbabilityTheory.condExpKernel_ae_eq_condExp | Mathlib.Probability.Kernel.Condexp | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ],
m ≤ mΩ →
∀ {s : Set Ω},
MeasurableSet s → (fun ω => ((ProbabilityTheory.condExpKernel μ m) ω).real s) =ᵐ[μ] μ[s.indicator fun ω => 1 | m... | null | true |
Subfield.mk.injEq | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u} [inst : DivisionRing K] (toSubring : Subring K)
(inv_mem' : ∀ x ∈ toSubring.carrier, x⁻¹ ∈ toSubring.carrier) (toSubring_1 : Subring K)
(inv_mem'_1 : ∀ x ∈ toSubring_1.carrier, x⁻¹ ∈ toSubring_1.carrier),
({ toSubring := toSubring, inv_mem' := inv_mem' } = { toSubring := toSubring_1, inv_mem' := in... | null | true |
Lean.Compiler.LCNF.JoinPointFinder.FindState.mk.injEq | Lean.Compiler.LCNF.JoinPoints | ∀ (candidates candidates_1 : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo),
({ candidates := candidates } = { candidates := candidates_1 }) = (candidates = candidates_1) | null | true |
RCLike.realRingEquiv._proof_1 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.I = 0 → ∀ (x : K), ↑(RCLike.re x) = x | null | false |
CategoryTheory.Triangulated.Octahedron'.triangle_mor₁ | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | null | true |
_private.Mathlib.RingTheory.MvPolynomial.EulerIdentity.0.MvPolynomial.IsWeightedHomogeneous.sum_weight_X_mul_pderiv._simp_1_3 | Mathlib.RingTheory.MvPolynomial.EulerIdentity | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : ℕ) (a : α), ↑n * a = n • a | null | false |
FirstOrder.Language.Substructure.gciMapComap | Mathlib.ModelTheory.Substructures | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type u_1} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{f : L.Hom M N} →
Function.Injective ⇑f →
GaloisCoinsertion (FirstOrder.Language.Substructure.map f) (FirstOrder.Language.Substructure.comap f) | `map f` and `comap f` form a `GaloisCoinsertion` when `f` is injective. | true |
ContinuousMonoidHom.instContinuousEval | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ (A : Type u_1) (B : Type u_2) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] [LocallyCompactPair A B], ContinuousEval (A →ₜ* B) A B | null | true |
Polynomial.Splits.neg | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Ring R] {f : Polynomial R}, f.Splits → (-f).Splits | null | true |
ContinuousMap.liftCover_coe' | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {A : Set (Set α)}
{F : (s : Set α) → s ∈ A → C(↑s, β)}
{hF :
∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
(F s hs) ⟨x, hxi⟩ = (F t ht) ⟨x, hxj⟩}
{hA : ∀ (x : α), ∃ i ∈ A,... | null | true |
_private.Mathlib.Tactic.Echelon.Bareiss.0.Mathlib.Tactic.Echelon.mkBareissDecomposition.match_1 | Mathlib.Tactic.Echelon.Bareiss | (carrier : Mathlib.Tactic.Echelon.Carrier) →
(motive : Array (Array carrier.type) × Array (Option carrier.type) → Sort u_1) →
(x : Array (Array carrier.type) × Array (Option carrier.type)) →
((values : Array (Array carrier.type)) → (scales : Array (Option carrier.type)) → motive (values, scales)) →
... | null | false |
Std.Time.Day.instLEOffset._aux_1 | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Day.Offset → Prop | null | false |
AffineSubspace.instCompleteLattice._proof_13 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_3} {V : Type u_2} {P : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (x : k) (x_1 x_2 x_3 : P), False → x_2 ∈ ∅ → x_3 ∈ ∅ → x • (x_1 -ᵥ x_2) +ᵥ x_3 ∈ ∅ | null | false |
CategoryTheory.Sieve._sizeOf_1 | Mathlib.CategoryTheory.Sites.Sieves.Basic | {C : Type u₁} → {inst : CategoryTheory.Category.{v₁, u₁} C} → {X : C} → [SizeOf C] → CategoryTheory.Sieve X → ℕ | null | false |
Ideal.minimalPrimes.equivIrreducibleComponents._proof_4 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} [inst : CommSemiring R] (I : Ideal R) (x : ↑{p | p.IsPrime ∧ I ≤ p}),
(↑⟨{ asIdeal := ↑x, isPrime := ⋯ }, ⋯⟩).asIdeal.IsPrime ∧ I ≤ (↑⟨{ asIdeal := ↑x, isPrime := ⋯ }, ⋯⟩).asIdeal | null | false |
Std.Time.TimeZone.TransitionRule.casesOn | Std.Time.Zoned.RecurringRule | {motive : Std.Time.TimeZone.TransitionRule → Sort u} →
(t : Std.Time.TimeZone.TransitionRule) →
((spec : Std.Time.TimeZone.TransitionSpec) →
(time : Std.Time.Second.Offset) → motive { spec := spec, time := time }) →
motive t | null | false |
Lean.SubExpr.Pos.typeCoord | Lean.SubExpr | ℕ | The coordinate `3 = maxChildren - 1` is
reserved to denote the type of the expression. | true |
_private.Mathlib.GroupTheory.Commutator.Basic.0.Subgroup.commutator_prod_prod._simp_1_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_4} [inst_1 : Group N] {H : Subgroup G} {K : Subgroup N}
{J : Subgroup (G × N)},
(J ≤ H.prod K) = (Subgroup.map (MonoidHom.fst G N) J ≤ H ∧ Subgroup.map (MonoidHom.snd G N) J ≤ K) | null | false |
Std.Http.Status.expectationFailed.elim | Std.Http.Data.Status | {motive : Std.Http.Status → Sort u} →
(t : Std.Http.Status) → t.ctorIdx = 40 → motive Std.Http.Status.expectationFailed → motive t | null | false |
Lean.Widget.InteractiveGoal | Lean.Widget.InteractiveGoal | Type | An interactive tactic-mode goal. | true |
Membership.ctorIdx | Init.Prelude | {α : outParam (Type u)} → {γ : Type v} → Membership α γ → ℕ | null | false |
TopModuleCat.delabOf | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | Lean.PrettyPrinter.Delaborator.Delab | This prints `TopModuleCat.of R X` as `↧X`. | true |
Interval.coe_le_coe | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s t : NonemptyInterval α}, ↑s ≤ ↑t ↔ s ≤ t | null | true |
HomologicalComplex.instIsStrictlySupportedTruncLE | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : 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') [inst_2 : e.IsTruncLE] [inst_3 : ∀ (i' : ι'), K.HasHomology i']
[inst_4 :... | null | true |
Hyperreal.epsilon_ne_zero | Mathlib.Analysis.Real.Hyperreal | Hyperreal.epsilon ≠ 0 | null | true |
String.Slice.ByteIterator.s | Init.Data.String.Iterate | String.Slice.ByteIterator → String.Slice | null | true |
Circle.instIsTopologicalGroup | Mathlib.Analysis.Complex.Circle | IsTopologicalGroup Circle | null | true |
CategoryTheory.Groupoid.isoEquivHom._proof_6 | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] (X Y : C),
Function.RightInverse (fun f => { hom := f, inv := CategoryTheory.Groupoid.inv f, hom_inv_id := ⋯, inv_hom_id := ⋯ })
CategoryTheory.Iso.hom | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.parseQuarterNumber | Std.Time.Format.Basic | Std.Internal.Parsec.String.Parser Std.Time.Month.Quarter | null | true |
TopologicalSpace.Opens.functor_map_eq_inf | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U V : TopologicalSpace.Opens ↑X),
⋯.functor.obj ((TopologicalSpace.Opens.map U.inclusion').obj V) = V ⊓ U | null | true |
Set.subset_accumulate | Mathlib.Order.SetAccumulate | ∀ {α : Type u_1} {β : Type u_2} {s : α → Set β} [inst : Preorder α] {x : α}, s x ⊆ Set.accumulate s x | null | true |
Filter.Tendsto.limsup_comp_le_limsup._auto_3 | Mathlib.Order.LiminfLimsup | Lean.Syntax | null | false |
WithAbs.map_apply | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) {T : Type u_3} [inst_3 : Semiring T] (w : AbsoluteValue T S) (f : R →+* T) (x : WithAbs v),
(WithAbs.map v w f) x = WithAbs.toAbs w (f x.ofAbs) | null | true |
contDiff_prodMk_right | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
(e₀ : E), ContDiff 𝕜 n fun f => (e₀, f) | null | true |
SSet.anodyneExtensions | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic | CategoryTheory.MorphismProperty SSet | In the category of simplicial sets, an anodyne extension is a morphism
that has the left lifting property with respect to fibrations, where
a fibration is a morphism that has the right lifting property with respect
to horn inclusions. We do not introduce a typeclass for anodyne extensions
because when the Quillen model... | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.noConfusionType | Mathlib.Tactic.Linter.TextBased | Sort u → Mathlib.Linter.TextBased.StyleError✝ → Mathlib.Linter.TextBased.StyleError✝ → Sort u | null | false |
PEquiv.mk.inj | Mathlib.Basic.PEquiv | ∀ {α : Type u} {β : Type v} {toFun : α → Option β} {invFun : β → Option α}
{inv : ∀ (a : α) (b : β), invFun b = some a ↔ toFun a = some b} {toFun_1 : α → Option β} {invFun_1 : β → Option α}
{inv_1 : ∀ (a : α) (b : β), invFun_1 b = some a ↔ toFun_1 a = some b},
{ toFun := toFun, invFun := invFun, inv := inv } = { ... | null | true |
_private.Mathlib.Analysis.Matrix.Normed.0.Matrix.norm_unitOf | Mathlib.Analysis.Matrix.Normed | ∀ {α : Type u_5} [inst : NormedDivisionRing α] [inst_1 : NormedAlgebra ℝ α] (a : α), ‖Matrix.unitOf✝ a‖₊ = 1 | null | true |
instTotallyDisconnectedSpaceSum | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [TotallyDisconnectedSpace α]
[TotallyDisconnectedSpace β], TotallyDisconnectedSpace (α ⊕ β) | null | true |
Topology.CWComplex.instRelCWComplex._proof_5 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (C : Set X) [inst_1 : Topology.CWComplex C],
∀ A ⊆ C,
(∀ (n : ℕ) (j : Topology.CWComplex.cell C n),
IsClosed (A ∩ ↑(Topology.CWComplex.map n j) '' Metric.closedBall 0 1)) ∧
IsClosed (A ∩ ∅) →
IsClosed A | null | false |
Nat.fermatNumber | Mathlib.NumberTheory.Fermat | ℕ → ℕ | Fermat numbers: the `n`-th Fermat number is defined as `2^(2^n) + 1`. | true |
Std.Time.instHAddOffsetOffset | Std.Time.Date.Basic | HAdd Std.Time.Nanosecond.Offset Std.Time.Millisecond.Offset Std.Time.Nanosecond.Offset | null | true |
ωCPO.instLargeCategory._proof_3 | Mathlib.Order.Category.OmegaCompletePartialOrder | ∀ {W X Y Z : ωCPO} (f : W.carrier →𝒄 X.carrier) (g : X.carrier →𝒄 Y.carrier) (h : Y.carrier →𝒄 Z.carrier),
h.comp (g.comp f) = (h.comp g).comp f | null | false |
CategoryTheory.Linear.homCongr_symm_apply | Mathlib.CategoryTheory.Linear.Basic | ∀ (k : Type u_1) {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C] [inst_1 : Semiring k]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear k C] {X Y W Z : C} (f₁ : X ≅ Y) (f₂ : W ≅ Z)
(f : Y ⟶ Z),
(CategoryTheory.Linear.homCongr k f₁ f₂).symm f =
CategoryTheory.CategoryStruct.... | null | true |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.Result.and.match_1 | Lean.Meta.Tactic.Grind.PP | (motive : Lean.Meta.Grind.Result✝ → Lean.Meta.Grind.Result✝ → Sort u_1) →
(x x_1 : Lean.Meta.Grind.Result✝) →
((x : Lean.Meta.Grind.Result✝) → motive Lean.Meta.Grind.Result.no✝ x) →
((x : Lean.Meta.Grind.Result✝) → motive x Lean.Meta.Grind.Result.no✝) →
((x : Lean.Meta.Grind.Result✝) → motive Lean.M... | null | false |
ONote.NF.mk | Mathlib.SetTheory.Ordinal.Notation | ∀ {o : ONote}, Exists o.NFBelow → o.NF | null | true |
CategoryTheory.Functor.CoreMonoidal.associativity._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
AddAction.compHom._proof_1 | Mathlib.Algebra.Group.Action.Hom | ∀ {M : Type u_3} {N : Type u_2} (α : Type u_1) [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : AddMonoid N]
(g : N →+ M) (x x_1 : N) (x_2 : α), (x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | null | false |
_private.Init.Meta.Defs.0.Lean.Syntax.structEq._sparseCasesOn_2 | Init.Meta.Defs | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
_private.Mathlib.Topology.Connected.Clopen.0.IsClopen.isPreconnected_iff._proof_1_5 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u_1} {s : Set α} (a b : Set α), s ∩ (a ∩ b) = ∅ → Disjoint (s ∩ a) (s ∩ b) | null | false |
USize.recOn.eq._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.298 | Mathlib.Util.CompileInductive | @USize.recOn = @USize.recOn✝ | null | false |
Nat.digits_of_two_le_of_pos | Mathlib.Data.Nat.Digits.Defs | ∀ {n b : ℕ}, 2 ≤ b → 0 < n → b.digits n = n % b :: b.digits (n / b) | null | true |
Antitone.le_csInf_image | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice β] [inst_1 : Preorder α] {f : α → β},
Antitone f → ∀ {s : Set α}, s.Nonempty → ∀ {B : α}, B ∈ upperBounds s → f B ≤ sInf (f '' s) | null | true |
NonUnitalAlgHom.inr_apply | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} [inst : Monoid R] {A : Type v} {B : Type w} [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : DistribMulAction R B] (x : B),
(NonUnitalAlgHom.inr R A B) x = (0, x) | null | true |
Pi.instLattice._proof_2 | Mathlib.Order.Lattice | ∀ {ι : Type u_1} {α' : ι → Type u_2} [inst : (i : ι) → Lattice (α' i)] (a b : (i : ι) → α' i),
SemilatticeInf.inf a b ≤ b | null | false |
deriv_riemannZeta_eq_neg_inv_sub_sq_add | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {s : ℂ}, s ≠ 1 → deriv riemannZeta s = -(s - 1)⁻¹ ^ 2 + deriv riemannZeta₀ s | null | true |
OpenPartialHomeomorph.lift_openEmbedding_symm | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_7} {X' : Type u_8} {Z : Type u_9} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace X']
[inst_2 : TopologicalSpace Z] [inst_3 : Nonempty Z] {f : X → X'} (e : OpenPartialHomeomorph X Z)
(hf : Topology.IsOpenEmbedding f), ↑(e.lift_openEmbedding hf).symm = f ∘ ↑e.symm | null | true |
CategoryTheory.Functor.LeftLinear.μₗIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | ∀ {D : Type u_6} {D' : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} D]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D'] (F : CategoryTheory.Functor D D') {C : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} C] [inst_3 : CategoryTheory.MonoidalCategory C]
[inst_4 : CategoryTheory.MonoidalCategory.Mo... | null | false |
Batteries.Tactic._aux_Batteries_Tactic_NoMatch___elabRules_Batteries_Tactic_matchWithDot_1 | Batteries.Tactic.NoMatch | Lean.Elab.Term.TermElab | The syntax `match ⋯ with.` has been deprecated in favor of `nomatch ⋯`.
Both now support multiple discriminants.
| false |
ProbabilityTheory.«termEVar[_]» | Mathlib.Probability.Moments.Variance | Lean.ParserDescr | The `ℝ≥0∞`-valued variance of the real-valued random variable `X` according to the volume
measure.
This is defined as the Lebesgue integral of `(X - 𝔼[X])^2`. | true |
Array.all_filterMap | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Option β} {p : β → Bool},
(Array.filterMap f xs).all p =
xs.all fun a =>
match f a with
| some b => p b
| none => true | null | true |
List.findIdx_add_mem_findIdxs | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} (s : ℕ),
List.findIdx p xs < xs.length → List.findIdx p xs + s ∈ List.findIdxs p xs s | null | true |
String.getUTF8Byte | Init.Data.String.PosRaw | (s : String) → (p : String.Pos.Raw) → p < s.rawEndPos → UInt8 | Accesses the indicated byte in the UTF-8 encoding of a string.
At runtime, this function is implemented by efficient, constant-time code.
| true |
CategoryTheory.MonoidalCategory.tensorHom_comp_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {V W X Y Z : C}
(f : V ⟶ W) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g)
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft W h) =
Cate... | null | true |
CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac_assoc | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Balanced C] {n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)} (hS : S.Exact) (k : ℕ)
(hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1)
... | null | true |
CategoryTheory.Presieve.isSheaf_sup | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C] (K L : CategoryTheory.Coverage C)
(P : CategoryTheory.Functor Cᵒᵖ (Type u_1)),
CategoryTheory.Presieve.IsSheaf (K ⊔ L).toGrothendieck P ↔
CategoryTheory.Presieve.IsSheaf K.toGrothendieck P ∧ CategoryTheory.Presieve.IsSheaf L.toGrothendieck P | A presheaf is a sheaf for the Grothendieck topology generated by a union of coverages iff it is a
sheaf for the Grothendieck topology generated by each coverage separately.
| true |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.StarAlgEquiv.eq_linearIsometryEquivConjStarAlgEquiv._simp_1_3 | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} {M₁ : Type u_4} [inst_3 : TopologicalSpace M₁]
[inst_4 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_5 : TopologicalSpace M₂] [inst_6 : AddCommMonoid... | null | false |
ContinuousMultilinearMap.toContinuousLinearMap | Mathlib.Topology.Algebra.Module.Multilinear.Basic | {R : Type u} →
{ι : Type v} →
{M₁ : ι → Type w₁} →
{M₂ : Type w₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
[i... | If `f` is a continuous multilinear map, then `f.toContinuousLinearMap m i` is the continuous
linear map obtained by fixing all coordinates but `i` equal to those of `m`, and varying the
`i`-th coordinate. | true |
Array.uget.eq_1 | Init.Data.Array.Basic | ∀ {α : Type u} (xs : Array α) (i : USize) (h : i.toNat < xs.size), xs.uget i h = xs[i.toNat] | null | true |
List.eraseP_subset | Init.Data.List.Erase | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.eraseP p l ⊆ l | null | true |
instAddCommGroupWithOneGradedTensorProduct._proof_30 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ (R : Type u_3) {ι : Type u_4} {A : Type u_1} {B : Type u_2} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
Plausible.Nat.shrinkable | Plausible.Shrinkable | Plausible.Shrinkable ℕ | null | true |
Std.ExtHashMap.getElem_filter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Bool} {k : α} {h' : k ∈ Std.ExtHashMap.filter f m},
(Std.ExtHashMap.filter f m)[k] = m[k] | null | true |
CategoryTheory.Functor.CoconeTypes.IsColimitCore.down._proof_2 | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} J] {F : CategoryTheory.Functor J (Type u_3)}
{c : F.CoconeTypes} (hc : c.IsColimitCore) {T : Type u_2} {f g : c.pt → T}, (∀ (j : J), f ∘ c.ι j = g ∘ c.ι j) → f = g | null | false |
Std.Http.Protocol.H1.StepResult.mk.inj | Std.Http.Protocol.H1 | ∀ {dir : Std.Http.Protocol.H1.Direction} {events : Array (Std.Http.Protocol.H1.Event dir)}
{output : Std.Http.Internal.ChunkedBuffer} {events_1 : Array (Std.Http.Protocol.H1.Event dir)}
{output_1 : Std.Http.Internal.ChunkedBuffer},
{ events := events, output := output } = { events := events_1, output := output_1 ... | null | true |
Lean.Lsp.CallHierarchyPrepareParams.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CallHierarchyPrepareParams → Sort u} →
(t : Lean.Lsp.CallHierarchyPrepareParams) →
((toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams) →
motive { toTextDocumentPositionParams := toTextDocumentPositionParams }) →
motive t | null | false |
FractionalIdeal.mk0.congr_simp | Mathlib.RingTheory.ClassGroup.Basic | ∀ {R : Type u_1} (K : Type u_2) [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDomain R] [inst_5 : IsDedekindDomain R],
FractionalIdeal.mk0 K = FractionalIdeal.mk0 K | null | true |
instModuleZModOfNatNatAdditiveUnitsInt._proof_7 | Mathlib.Data.ZMod.IntUnitsPower | ∀ (z₁ z₂ : ZMod 2) (au : Additive ℤˣ), (z₁ + z₂) • au = z₁ • au + z₂ • au | null | false |
ContinuousAlternatingMap.prod | Mathlib.Topology.Algebra.Module.Alternating.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_4} →
{N' : Type u_5} →
{ι : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace M] →
[inst_4 : AddCommMonoid N] →
... | The Cartesian product of two continuous alternating maps, as a continuous alternating map. | true |
Std.DHashMap.Internal.AssocList.getCast!._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] → [LawfulBEq α] → (a : α) → [Inhabited (β a)] → Std.DHashMap.Internal.AssocList α β → β a | null | false |
LinearEquiv.prodProdProdComm_toAddEquiv | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) (M₃ : Type y) (M₄ : Type z) [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : AddCommMonoid M₄] [inst_5 : Module R M]
[inst_6 : Module R M₂] [inst_7 : Module R M₃] [inst_8 : Module R M₄],
↑(LinearEquiv.prodPro... | null | true |
_private.Mathlib.Algebra.Order.Module.Field.0.Mathlib.Meta.Positivity.evalSMul.match_14 | Mathlib.Algebra.Order.Module.Field | {_u : Lean.Level} →
{α : Q(Type _u)} →
(motive : Option Q(PartialOrder «$α») → Sort u_1) →
(pα? : Option Q(PartialOrder «$α»)) →
(Unit → motive none) → ((pα : Q(PartialOrder «$α»)) → motive (some pα)) → motive pα? | null | false |
_aux_Mathlib_GroupTheory_GroupAction_Hom___unexpand_MulActionHom_2 | Mathlib.GroupTheory.GroupAction.Hom | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.CastKind.mkProof.match_1 | Mathlib.Tactic.Translate.TagUnfoldBoundary | (motive : Mathlib.Tactic.Translate.CastKind✝ → Sort u_1) →
(x : Mathlib.Tactic.Translate.CastKind✝) →
(Unit → motive Mathlib.Tactic.Translate.CastKind.eq✝) →
((x : Mathlib.Tactic.Translate.CastKind✝) → motive x) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.