name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.condVar_of_aestronglyMeasurable | Mathlib.Probability.CondVar | ∀ {Ω : Type u_1} {m₀ m : MeasurableSpace Ω} {hm : m ≤ m₀} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω}
[hμm : MeasureTheory.SigmaFinite (μ.trim hm)],
MeasureTheory.AEStronglyMeasurable X μ →
MeasureTheory.Integrable ((X - μ[X | m]) ^ 2) μ → ProbabilityTheory.condVar m X μ =ᵐ[μ] (X - μ[X | m]) ^ 2 | null | true |
SSet.Homotopy.toSimplicialObjectHomotopy | Mathlib.AlgebraicTopology.SimplicialSet.Homotopy | {X Y : SSet} → {f g : X ⟶ Y} → SSet.Homotopy f g → CategoryTheory.SimplicialObject.Homotopy f g | If `H : Homotopy f g` is a homotopy between morphisms of simplicial sets
`f : X ⟶ Y` and `g : X ⟶ Y` (i.e. `H.h` is a morphism `X ⊗ Δ[1] ⟶ Y` inducing
`f` and `g`), then this is the corresponding (combinatorial) homotopy of
morphisms of simplicial objects between `f` and `g`. | true |
TensorProduct.prodRight._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Prod | ∀ (R : Type u_1) (S : Type u_2) (M₁ : Type u_3) (M₂ : Type u_4) (M₃ : Type u_5) [inst : CommSemiring R]
[inst_1 : Semiring S] [inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : AddCommMonoid M₃]
[inst_5 : Algebra R S] [inst_6 : Module R M₁] [inst_7 : Module S M₁] [inst_8 : IsScalarTower R S M₁]
[in... | null | false |
ZeroLEOneClass.neZero.three | Mathlib.Algebra.Order.Monoid.NatCast | ∀ (α : Type u_1) [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1] [AddLeftMono α],
NeZero 3 | null | true |
_private.Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects.0.CategoryTheory.Limits.inr_pushoutZeroZeroIso_inv._simp_1_1 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Braided.Reflection.0.CategoryTheory.Monoidal.Reflective.isIso_tfae._simp_1_8 | Mathlib.CategoryTheory.Monoidal.Braided.Reflection | ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [inst : EquivLike E α β] (e : E) (f : β → γ),
Function.Bijective (f ∘ ⇑e) = Function.Bijective f | null | false |
AddConstMap.ext_iff | Mathlib.Algebra.AddConstMap.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H} {f g : AddConstMap G H a b},
f = g ↔ ∀ (x : G), f x = g x | null | true |
NumberField.instCommRingInfiniteAdeleRing._proof_17 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | ∀ (K : Type u_1) [inst : Field K] (a b c : NumberField.InfiniteAdeleRing K), a * b * c = a * (b * c) | null | false |
Chebyshev.theta_zero | Mathlib.NumberTheory.Chebyshev | Chebyshev.theta 0 = 0 | null | true |
RingCat.Colimits.Relation.below.add_1 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J RingCat}
{motive : (a a_1 : RingCat.Colimits.Prequotient F) → RingCat.Colimits.Relation F a a_1 → Prop}
(x x' y : RingCat.Colimits.Prequotient F) (x_1 : RingCat.Colimits.Relation F x x'),
RingCat.Colimits.Relation.below x_1 → mot... | null | true |
WithBot.addRightReflectLT | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] [inst_1 : LT α] [AddRightReflectLT α], AddRightReflectLT (WithBot α) | null | true |
AddGroupTopology.mk.inj | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u} {inst : AddGroup α} {toTopologicalSpace : TopologicalSpace α}
{toIsTopologicalAddGroup : IsTopologicalAddGroup α} {toTopologicalSpace_1 : TopologicalSpace α}
{toIsTopologicalAddGroup_1 : IsTopologicalAddGroup α},
{ toTopologicalSpace := toTopologicalSpace, toIsTopologicalAddGroup := toIsTopological... | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.shortComplex._proof_1 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ (n₀ n₁ : ℤ), n₀ + 1 = n₁ → n₀ + 1 = n₁ | null | false |
Sylow.mulEquivIteratedWreathProduct._proof_1 | Mathlib.GroupTheory.RegularWreathProduct | ∀ (p n : ℕ) (G : Type u_1), Nat.card G = p → Nat.card (Fin n → G) = p ^ n | null | false |
ImportGraph.Lake.getWorkspaceSummary | ImportGraph.WorkspaceModel.Summary.Get | optParam (Option System.FilePath) none → optParam Bool true → IO ImportGraph.Lake.WorkspaceSummary | Get the workspace summary by calling out to `lake exe import-graph-workspace-summary`, which emits
json that this function parses. (This is a workaround for the fact that loading the language server
in the language server causes a crash.)
Before calling out to the executable, this function checks a cache file in the `... | true |
Matrix.permanent_transpose | Mathlib.LinearAlgebra.Matrix.Permanent | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_2} [inst_2 : CommSemiring R]
(M : Matrix n n R), M.transpose.permanent = M.permanent | Transposing a matrix preserves the permanent. | true |
Std.Http.Header.Name.mk._flat_ctor | Std.Http.Data.Headers.Name | (value : String) →
autoParam (Std.Http.Header.IsValidHeaderName value) Std.Http.Header.Name.isValidHeaderValue._autoParam →
autoParam (Std.Http.Internal.IsLowerCase value) Std.Http.Header.Name.isLowerCase._autoParam → Std.Http.Header.Name | null | false |
Mathlib.Meta.FunProp.Result.mk.noConfusion | Mathlib.Tactic.FunProp.Types | {P : Sort u} → {proof proof' : Lean.Expr} → { proof := proof } = { proof := proof' } → (proof = proof' → P) → P | null | false |
ContinuousMultilinearMap.currySumEquiv._proof_9 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G']
[inst_2 : NormedSpace 𝕜 G'], ContinuousConstSMul 𝕜 G' | null | false |
CategoryTheory.IsCofiltered.inf_objs_exists | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C] (O : Finset C),
∃ S, ∀ {X : C}, X ∈ O → Nonempty (S ⟶ X) | Any finite collection of objects in a cofiltered category has an object "to the left".
| true |
AddEquiv.symm_comp_eq | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] {α : Type u_9} (e : M ≃+ N) (f : α → M) (g : α → N),
⇑e.symm ∘ g = f ↔ g = ⇑e ∘ f | null | true |
Lean.Parser.topLevelCommandParserFn | Lean.Parser.Module | Lean.Parser.ParserFn | null | true |
Std.TreeMap.getKeyD_modify_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Inhabited α]
{k fallback : α} {f : β → β}, (t.modify k f).getKeyD k fallback = if k ∈ t then k else fallback | null | true |
Lean.Meta.Grind.EMatchTheoremKind.default.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (gen gen_1 : Bool),
(Lean.Meta.Grind.EMatchTheoremKind.default gen = Lean.Meta.Grind.EMatchTheoremKind.default gen_1) = (gen = gen_1) | null | true |
AlgebraicGeometry.LocallyRingedSpace.restrict.congr_simp | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f f_1 : U ⟶ X.toTopCat} (e_f : f = f_1)
(h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)), X.restrict h = X.restrict ⋯ | null | true |
Commute.inv_add_inv | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionSemiring K] {a b : K}, Commute a b → a ≠ 0 → b ≠ 0 → a⁻¹ + b⁻¹ = (a + b) / (a * b) | null | true |
Circle.coe_ne_zero | Mathlib.Analysis.Complex.Circle | ∀ (z : Circle), ↑z ≠ 0 | null | true |
Mathlib.Tactic.ClickSuggestions.RwKind.hasBVars.sizeOf_spec | Mathlib.Tactic.ClickSuggestions.Util | sizeOf Mathlib.Tactic.ClickSuggestions.RwKind.hasBVars = 1 | null | true |
AlgebraicTopology.DoldKan.Γ₀_obj_termwise_mapMono_comp_PInfty | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C) {Δ Δ' : SimplexCategory} (i : Δ ⟶ Δ') [inst_2 : CategoryTheory.Mono i],
CategoryTheory.CategoryStruct.comp
(AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono (Algebrai... | null | true |
Subsemigroup.instCompleteLattice.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M],
Subsemigroup.instCompleteLattice =
{ le := fun x1 x2 => x1 ≤ x2, lt := fun x1 x2 => x1 < x2, le_refl := ⋯, le_trans := ⋯, lt_iff_le_not_ge := ⋯,
le_antisymm := ⋯, sup := SemilatticeSup.sup, le_sup_left := ⋯, le_sup_right := ⋯, sup_le := ⋯,
inf := fun x1 x2 => x1 ⊓ x2, ... | null | true |
WeierstrassCurve.Projective.dblXYZ_of_Y_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P Q : Fin 3 → F},
W.Equation P →
P 2 ≠ 0 →
Q 2 ≠ 0 →
P 0 * Q 2 = Q 0 * P 2 → P 1 * Q 2 = Q 1 * P 2 → P 1 * Q 2 = W.negY Q * P 2 → W.dblXYZ P = W.dblU P • ![0, 1, 0] | null | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.Legacy.foldl.match_1.splitter | Batteries.Data.String.Lemmas | (motive : Substring.Raw → Sort u_1) →
(s : Substring.Raw) →
((s : String) → (b e : String.Pos.Raw) → motive { str := s, startPos := b, stopPos := e }) → motive s | null | true |
Lean.Server.FileWorker.handleDocumentHighlight | Lean.Server.FileWorker.RequestHandling | Lean.Lsp.DocumentHighlightParams → Lean.Server.RequestM (Lean.Server.RequestTask (Array Lean.Lsp.DocumentHighlight)) | null | true |
Real.contDiffAt_sqrt | Mathlib.Analysis.SpecialFunctions.Sqrt | ∀ {x : ℝ} {n : WithTop ℕ∞}, x ≠ 0 → ContDiffAt ℝ n (fun x => √x) x | null | true |
LieIdeal.comap._proof_6 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u_2} {L : Type u_1} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L') (J : LieIdeal R L') {x y : L},
y ∈ (Submodule.comap (↑f) (↑R L' J).toSubmodule).carrier →
⁅x, y⁆ ∈ (Submodule.comap (↑f) (↑R L' J).... | null | false |
GromovHausdorff.instMetricSpaceOptimalGHCoupling._proof_19 | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ (X : Type u_1) (Y : Type u_2) [inst : MetricSpace X] [inst_1 : CompactSpace X] [inst_2 : Nonempty X]
[inst_3 : MetricSpace Y] [inst_4 : CompactSpace Y] [inst_5 : Nonempty Y],
autoParam
(uniformity (GromovHausdorff.OptimalGHCoupling X Y) = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε})
Pseudo... | null | false |
List.length_unattach | Init.Data.List.Attach | ∀ {α : Type u_1} {p : α → Prop} {l : List { x // p x }}, l.unattach.length = l.length | null | true |
_private.Mathlib.NumberTheory.LSeries.Linearity.0.LSeriesSummable.sub._simp_1_1 | Mathlib.NumberTheory.LSeries.Linearity | ∀ (f g : ℕ → ℂ) (s : ℂ) (n : ℕ), LSeries.term f s n - LSeries.term g s n = LSeries.term (f - g) s n | null | false |
Fin.encodeSubtype_succ_neg._proof_1 | Batteries.Data.Fin.Coding | ∀ {n : ℕ} {P : Fin (n + 1) → Prop} [inst : DecidablePred P],
¬P 0 → (Fin.countP fun x => decide (P x.succ)) = Fin.countP fun x => decide (P x) | null | false |
DifferentiableOn.fst | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} {f₂ : E → F × G},
Diffe... | null | true |
HahnSeries.SummableFamily.powerSeriesFamily_of_not_orderTop_pos | Mathlib.RingTheory.HahnSeries.HEval | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ]
[inst_2 : IsOrderedCancelAddMonoid Γ] [inst_3 : CommRing R] [inst_4 : CommRing V] [inst_5 : Algebra R V]
{x : HahnSeries Γ V},
¬0 < x.orderTop →
∀ (f : PowerSeries R),
HahnSeries.SummableFamily.powerSeriesFa... | null | true |
UpperHalfPlane.exists | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ {P : UpperHalfPlane → Prop}, (∃ z, P z) ↔ ∃ z, ∃ (hz : 0 < z.im), P { coe := z, coe_im_pos := hz } | null | true |
_private.Mathlib.RingTheory.DividedPowers.Padic.0.PadicInt.dpow'_norm_le_of_ne_zero._simp_1_2 | Mathlib.RingTheory.DividedPowers.Padic | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True | null | false |
Aesop.CtorNames._sizeOf_inst | Aesop.Script.CtorNames | SizeOf Aesop.CtorNames | null | false |
Mathlib.Tactic.Echelon.Model | Mathlib.Tactic.Echelon.Core | {u : Lean.Level} → Q(Type u) → Type → Type | A computation model of the ring `α` on the carrier `V`. | true |
_private.Mathlib.Data.Fin.VecNotation.0.PSigma.casesOn._arg_pusher | Mathlib.Data.Fin.VecNotation | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
Real.wrapped._@.Mathlib.Basic.Real.Basic.3335671075._hygCtx._hyg.2 | Mathlib.Basic.Real.Basic | Subtype (Eq Real.definition✝) | null | false |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.two_mul_sub_one | Init.Data.Nat.Bitwise.Lemmas | ∀ {n : ℕ}, n > 0 → (2 * n - 1) % 2 = 1 | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Free.Coherence.0.CategoryTheory.FreeMonoidalCategory._aux_Mathlib_CategoryTheory_Monoidal_Free_Coherence___macroRules__private_Mathlib_CategoryTheory_Monoidal_Free_Coherence_0_CategoryTheory_FreeMonoidalCategory_termN_1 | Mathlib.CategoryTheory.Monoidal.Free.Coherence | Lean.Macro | null | false |
Option.get | Init.Data.Option.Basic | {α : Type u} → (o : Option α) → o.isSome = true → α | Extracts the value from an option that can be proven to be `some`.
| true |
Std.DHashMap.Internal.Raw₀.Const.foldRev_eq_foldr_toArray | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {δ : Type w} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β) {f : δ → α → β → δ} {init : δ},
Std.DHashMap.Raw.Internal.foldRev f init ↑m =
Array.foldr (fun a b => f b a.1 a.2) init (Std.DHashMap.Raw.Const.toArray ↑m) | null | true |
MeasureTheory.measureReal_biUnion_finset₀ | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {ι : Type u_3} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Finset ι} {f : ι → Set α},
(↑s).Pairwise (Function.onFun (MeasureTheory.AEDisjoint μ) f) →
(∀ b ∈ s, MeasureTheory.NullMeasurableSet (f b) μ) →
autoParam (∀ b ∈ s, μ (f b) ≠ ⊤) MeasureTheory.measureReal_biUnion_finset... | null | true |
IsCyclotomicExtension.Rat.inertiaDeg_span_zeta_sub_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p k : ℕ) [hp : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] {ζ : K} (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))),
(Ideal.span {hζ.toInteger - 1}).inertiaDeg ℤ = 1 | null | true |
HasProdUniformly.hasProdUniformlyOn | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α], HasProdUniformly f g → HasProdUniformlyOn f g s | null | true |
Lean.Elab.Tactic.Grind.DSimpCacheKey.casesOn | Lean.Elab.Tactic.Grind.Basic | {motive : Lean.Elab.Tactic.Grind.DSimpCacheKey → Sort u} →
(t : Lean.Elab.Tactic.Grind.DSimpCacheKey) →
((variant : Lean.Name) → (args : Lean.Elab.Tactic.Grind.DSimpArgs) → motive { variant := variant, args := args }) →
motive t | null | false |
_private.Lean.Language.Lean.Util.0.Lean.Language.Lean.findCmdParsedSnap.isAfterHoverPos.match_1 | Lean.Language.Lean.Util | (motive : Option String.Pos.Raw → Sort u_1) →
(x : Option String.Pos.Raw) →
((startPos : String.Pos.Raw) → motive (some startPos)) → ((x : Option String.Pos.Raw) → motive x) → motive x | null | false |
Mathlib.Tactic.ClickSuggestions.GrwKey.mk | Mathlib.Tactic.ClickSuggestions.GRewrite | ℕ → ℕ → ℕ → String → Lean.Meta.AbstractMVarsResult → Mathlib.Tactic.ClickSuggestions.GrwKey | null | true |
Batteries.PairingHeapImp.Heap.WF.node | Batteries.Data.PairingHeap | ∀ {α : Type u_1} {le : α → α → Bool} {a : α} {c : Batteries.PairingHeapImp.Heap α},
Batteries.PairingHeapImp.Heap.NodeWF le a c →
Batteries.PairingHeapImp.Heap.WF le (Batteries.PairingHeapImp.Heap.node a c Batteries.PairingHeapImp.Heap.nil) | There is exactly one tree and it is a `le`-min-heap. | true |
Lean.Meta.Grind.Arith.Linear.Struct.type | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.Struct → Lean.Expr | null | true |
Lean.Parser.Term.inferInstanceAs.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
Submodule.baseChangeOrderEmbedding_apply | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u_1) (M : Type u_2) (A : Type u_3) [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A]
[inst_3 : Module.FaithfullyFlat R A] [inst_4 : AddCommGroup M] [inst_5 : Module R M] (p : Submodule R M),
(Submodule.baseChangeOrderEmbedding R M A) p = Submodule.baseChange A p | null | true |
instSliceableSubarrayNat_6 | Init.Data.Slice.Array.Basic | {α : Type u} → Std.Ric.Sliceable (Subarray α) ℕ (Subarray α) | null | true |
AdicCompletion.evalₐ_mkₐ | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (n : ℕ) (x : AdicCompletion.AdicCauchySequence I R),
(AdicCompletion.evalₐ I n) ((AdicCompletion.mkₐ I) x) = (Ideal.Quotient.mk (I ^ n)) (↑x n) | null | true |
Height.mulHeight₁_ne_zero | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] (x : K), Height.mulHeight₁ x ≠ 0 | null | true |
Lean.NameGenerator.mkChild | Init.Meta.Defs | Lean.NameGenerator → Lean.NameGenerator × Lean.NameGenerator | null | true |
TopologicalSpace.Compacts.discreteUniformity_iff._simp_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], DiscreteUniformity (TopologicalSpace.Compacts α) = DiscreteUniformity α | null | false |
Nat.instTrichotomousLt | Init.Data.Nat.Basic | Std.Trichotomous fun x1 x2 => x1 < x2 | null | true |
CategoryTheory.Limits.IsLimit.liftConeMorphism.eq_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F} (h : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.Cone F), h.liftConeMorphism s = { hom := h.lift s, w := ⋯ } | null | true |
Vector.scanlM.loop._unary._proof_1 | Batteries.Data.Vector.Basic | ∀ {β : Type u_1} {n : ℕ} (cur : β) (i : ℕ) (hi : i ≤ n) (acc : Vector β i) (h_lt : i < n) (next : β),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun cur i => PSigma.casesOn i fun i hi => PSigma.casesOn hi fun hi acc => n - i)
⟨next, ⟨i + 1, ⟨⋯, acc.push cur⟩⟩⟩ ⟨cur, ⟨i, ⟨hi, acc⟩⟩⟩ | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.neg_self_le_ediv_of_nonneg_of_nonpos._proof_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ (xn yn : ℕ), ¬xn ≤ xn → False | null | false |
Nat.Partrec.Code.primrec₂_comp | Mathlib.Computability.PartrecCode | Primrec₂ Nat.Partrec.Code.comp | null | true |
Std.Do.SVal.curry_nil | Std.Do.SPred.SVal | ∀ {α : Type u_1} {f : Std.Do.SVal.StateTuple [] → α}, Std.Do.SVal.curry f = f PUnit.unit | null | true |
AlgebraicGeometry.IsZariskiLocalAtTarget.of_range_subset_iSup | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsZariskiLocalAtTarget P]
{X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [P.RespectsRight AlgebraicGeometry.IsOpenImmersion] {ι : Type u_1}
(U : ι → Y.Opens), Set.range ⇑f ⊆ ↑(⨆ i, U i) → (∀ (i : ι), P (f ∣_ U i)) → P f | null | true |
Std.Internal.instLawfulMonadLiftBindFunctionIdRunOfLawfulMonad | Init.Data.Iterators.Internal.LawfulMonadLiftFunction | ∀ {n : Type u → Type w} [inst : Monad n] [LawfulMonad n],
Std.Internal.LawfulMonadLiftBindFunction fun γ δ f x => f x.run | null | true |
PSet.Subset.congr_right | Mathlib.SetTheory.ZFC.PSet | ∀ {x y z : PSet.{u_1}}, x.Equiv y → (z ⊆ x ↔ z ⊆ y) | null | true |
_private.Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups.0.Subgroup.hasDetPlusMinusOne_adjoinNegOne_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = b) = (a = -b) | null | false |
IsConformalMap.injective | Mathlib.Analysis.Normed.Operator.Conformal | ∀ {R : Type u_1} {N : Type u_3} {M' : Type u_5} [inst : NormedField R] [inst_1 : SeminormedAddCommGroup N]
[inst_2 : NormedSpace R N] [inst_3 : NormedAddCommGroup M'] [inst_4 : NormedSpace R M'] {f : M' →L[R] N},
IsConformalMap f → Function.Injective ⇑f | null | true |
OpenPartialHomeomorph.toStructomorph._proof_2 | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u_2} {M : Type u_1} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
{G : StructureGroupoid H} {e : OpenPartialHomeomorph M H},
e ∈ atlas H M →
∀ [HasGroupoid M G] [ClosedUnderRestriction G],
Nonempty ↑e.source →
∀ (c : OpenPartialHomeomorph (↥{ car... | null | false |
Batteries.HashMap.empty | Batteries.Data.HashMap.Basic | {α : Type u_1} → {β : Type u_2} → [inst : BEq α] → [inst_1 : Hashable α] → Batteries.HashMap α β | Make a new empty hash map.
```
(empty : Batteries.HashMap Int Int).toList = []
```
| true |
LinearIsometry.extend._proof_3 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {V : Type u_2} [inst_1 : NormedAddCommGroup V] [inst_2 : InnerProductSpace 𝕜 V]
[FiniteDimensional 𝕜 V] {S : Submodule 𝕜 V}, Module.finrank 𝕜 V - Module.finrank 𝕜 ↥S = Module.finrank 𝕜 ↥Sᗮ | null | false |
PointwiseConvergenceCLM.piEquivL._proof_9 | Mathlib.Topology.Algebra.Module.Spaces.PointwiseConvergenceCLM | ∀ (𝕜 : Type u_4) [inst : NormedField 𝕜] (E : Type u_1) [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] {ι : Type u_2} (F : ι → Type u_3) [inst_4 : (i : ι) → AddCommGroup (F i)]
[inst_5 : (i : ι) → Module 𝕜 (F i)] [inst_6 : (i : ι) → TopologicalSpace (F i)]
[inst_7 : ∀ (i : ι), Is... | null | false |
ENNReal.add_biSup' | Mathlib.Basic.ENNReal.Operations | ∀ {ι : Sort u_1} {a : ENNReal} {p : ι → Prop},
(∃ i, p i) → ∀ (f : ι → ENNReal), a + ⨆ i, ⨆ (_ : p i), f i = ⨆ i, ⨆ (_ : p i), a + f i | null | true |
CategoryTheory.ChosenPullbacksAlong.Over.associator_hom_left_fst | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
(R S T : CategoryTheory.Over X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left (CategoryTheory.MonoidalCategoryStruct.associator R S T).hom)
(CategoryTheory.ChosenPullbacksA... | null | true |
Lean.Meta.Grind.AC.MonadGetStruct.mk._flat_ctor | Lean.Meta.Tactic.Grind.AC.Util | {m : Type → Type} → m Lean.Meta.Grind.AC.Struct → Lean.Meta.Grind.AC.MonadGetStruct m | null | false |
Real.cos_add_int_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℤ), Real.cos (x + ↑n * (2 * Real.pi)) = Real.cos x | null | true |
Matrix.instFintypeOfDecidableEq._aux_1 | Mathlib.Data.Matrix.Basic | {n : Type u_2} →
{m : Type u_1} →
[Fintype m] → [DecidableEq m] → [Fintype n] → [DecidableEq n] → (α : Type u_3) → [Fintype α] → Finset (Matrix m n α) | null | false |
Subalgebra.map_comap_eq_self | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] {f : A →ₐ[R] B} {S : Subalgebra R B},
S ≤ f.range → Subalgebra.map f (Subalgebra.comap f S) = S | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.support_map._proof_1_3 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_2} {γ : Type u_1} (L : SummationFilter β) (f : β ↪ γ),
∀ c ∉ Set.range ⇑f, c ∈ ⇑f '' L.support → c ∈ (L.map f).support | null | false |
Finsupp.mapDomain_comapDomain | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (f : α → β) (hf : Function.Injective f)
(l : β →₀ M), ↑l.support ⊆ Set.range f → Finsupp.mapDomain f (Finsupp.comapDomain f l ⋯) = l | null | true |
Diffeology.DSmooth.eq_1 | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : DiffeologicalSpace X] [inst_1 : DiffeologicalSpace Y] (f : X → Y),
Diffeology.DSmooth f = ∀ (n : ℕ) (p : EuclideanSpace ℝ (Fin n) → X), Diffeology.IsPlot p → Diffeology.IsPlot (f ∘ p) | null | true |
Std.Http.Body.Length.fixed.sizeOf_spec | Std.Http.Data.Body.Length | ∀ (n : ℕ), sizeOf (Std.Http.Body.Length.fixed n) = 1 + sizeOf n | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.Zip.0.Std.Iterators.Types.Zip.instIterator.match_5.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Monadic.Zip | ∀ {m : Type u_1 → Type u_2} {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ m β₁]
(motive : Option { out // ∃ it, it.IsPlausibleOutput out } → Sort u_3)
(out₁ : { out // ∃ it, it.IsPlausibleOutput out }) (h_1 : some out₁ = none → motive none)
(h_2 : (out₁_1 : { out // ∃ it, it.IsPlausibleOutput out }) → some out₁ = so... | null | true |
AddAction.not_addCommute_of_disjoint_movedBy_preimage | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] [FaithfulVAdd G α] {g h : G},
g ≠ 0 → Disjoint (AddAction.fixedBy α g)ᶜ (h +ᵥ (AddAction.fixedBy α g)ᶜ) → ¬AddCommute g h | If the image of the `(fixedBy α g)ᶜ` set by the pointwise action of `h: G`
is disjoint from `(fixedBy α g)ᶜ`, then `g` and `h` cannot commute. | true |
Lean.Linter.UnusedVariables.FVarDefinition.rec | Lean.Linter.UnusedVariables | {motive : Lean.Linter.UnusedVariables.FVarDefinition → Sort u} →
((userName : Lean.Name) →
(stx : Lean.Syntax) →
(opts : Lean.Options) →
(aliases : Array Lean.FVarId) →
motive { userName := userName, stx := stx, opts := opts, aliases := aliases }) →
(t : Lean.Linter.UnusedVaria... | null | false |
_private.Mathlib.Tactic.Linter.OverlappingInstances.0.Mathlib.Linter.OverlappingInstances.getAbstractProjections.go._sparseCasesOn_4 | Mathlib.Tactic.Linter.OverlappingInstances | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Lean.Parser.Term.let.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
Submodule.ker_liftQ_eq_bot' | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{R₂ : Type u_3} {M₂ : Type u_4} [inst_3 : Ring R₂] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
(f : M →ₛₗ[τ₁₂] M₂) (h : p = f.ker), (p.liftQ f ⋯).ker = ⊥ | null | true |
BitVec.zero_or | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, 0#w ||| x = x | null | true |
Complex.ofReal_mem_slitPlane | Mathlib.Analysis.Complex.Basic | ∀ {x : ℝ}, ↑x ∈ Complex.slitPlane ↔ 0 < x | null | true |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.getMsb_ofFnLE._proof_1_2 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : Fin n), (BitVec.ofFnLE f).getMsb i = f i.rev | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.