name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IsAddUnit.add_neg_cancel_left | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : SubtractionMonoid α] {a : α}, IsAddUnit a → ∀ (b : α), a + (-a + b) = b | null | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.expansion_pos._simp_1 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {K : ℝ} {A S : Finset G},
K < 1 → S.Nonempty → A.Nonempty → (0 < Finset.expansion✝ K S A) = True | null | false |
AEMeasurable.oneLePart | Mathlib.MeasureTheory.Order.Group.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Group α] [inst_2 : MeasurableSpace α]
[inst_3 : MeasurableSpace β] {f : β → α} {μ : MeasureTheory.Measure β} [MeasurableSup α],
AEMeasurable f μ → AEMeasurable (fun x => (f x)⁺ᵐ) μ | null | true |
_private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.mkExtIffType | Lean.Elab.Tactic.Ext | Lean.Name → Lean.MetaM Lean.Expr | Derives the type of the `iff` form of an ext theorem.
| true |
OrderMonoidHom.instMulOfIsOrderedMonoid._proof_2 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : CommMonoid β]
[inst_3 : Preorder β] [IsOrderedMonoid β] (f g : α →*o β), Monotone fun x => (↑f.toMonoidHom).toFun x * ↑g x | null | false |
IO.instReprTaskState.repr | Init.System.IO | IO.TaskState → ℕ → Std.Format | null | true |
Real.Angle.cos_eq_iff_eq_or_eq_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ ψ : Real.Angle}, θ.cos = ψ.cos ↔ θ = ψ ∨ θ = -ψ | null | true |
_private.Lean.Elab.Tactic.Do.VCGen.0.Lean.Elab.Tactic.Do.VCGen.genVCs.assignMVars | Lean.Elab.Tactic.Do.VCGen | List Lean.MVarId → Lean.Elab.Tactic.Do.VCGenM PUnit.{1} | null | true |
continuousMultilinearCurryFin0_symm_apply | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ {𝕜 : Type u} {G : Type wG} {G' : Type wG'} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : NormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G'] (x : G'),
(continuousMultilinearCurryFin0 𝕜 G G').symm x = ContinuousMultilinearMap.uncurry0 𝕜 G x | null | true |
BitVec.reverse_append._proof_2 | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ}, v + w = w + v | null | false |
LightCondSet.instFaithfulTopCatTopCatToLightCondSet | Mathlib.Condensed.Light.TopCatAdjunction | topCatToLightCondSet.Faithful | null | true |
Std.ExtDHashMap.mem_insert | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k}, a ∈ m.insert k v ↔ (k == a) = true ∨ a ∈ m | null | true |
AddValuation.comap_comp | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{S₁ : Type u_6} {S₂ : Type u_7} [inst_2 : Ring S₁] [inst_3 : Ring S₂] (f : S₁ →+* S₂) (g : S₂ →+* R),
AddValuation.comap (g.comp f) v = AddValuation.comap f (AddValuation.comap g v) | null | true |
Algebra.Generators.H1Cotangent.δ_eq_δ | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {R : Type u₁} {S : Type u₂} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {T : Type u₃}
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {ι : Type w₁}
{σ : Type w₂} {σ' : Type w₄} (Q : Algebra.Generators S T ι) (P : Algebra.Generators R S σ)
(... | null | true |
Int.card_box | Mathlib.Order.Interval.Finset.Box | ∀ {n : ℕ}, n ≠ 0 → (Finset.box n).card = 8 * n | null | true |
KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk._proof_9 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} (hI : I.IsMaximal), IsPrincipalIdealRing (Polynomial (R ⧸ I)) | null | false |
Projectivization.Subspace.submodule._proof_8 | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{a b : Projectivization.Subspace K V},
{
toFun := fun s =>
{ carrier := {x | ∀ (h : x ≠ 0), Projectivization.mk K x h ∈ s.carrier}, add_mem' := ⋯, zero_mem' := ⋯,
smul_mem' := ... | null | false |
ProbabilityTheory.Kernel.instIsCondKernel_zero | Mathlib.Probability.Kernel.Disintegration.Basic | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mΩ : MeasurableSpace Ω} (κCond : ProbabilityTheory.Kernel (α × β) Ω), ProbabilityTheory.Kernel.IsCondKernel 0 κCond | null | true |
Lean.Meta.CasesSubgoal.mk.inj | Lean.Meta.Tactic.Cases | ∀ {toInductionSubgoal : Lean.Meta.InductionSubgoal} {ctorName : Option Lean.Name}
{toInductionSubgoal_1 : Lean.Meta.InductionSubgoal} {ctorName_1 : Option Lean.Name},
{ toInductionSubgoal := toInductionSubgoal, ctorName := ctorName } =
{ toInductionSubgoal := toInductionSubgoal_1, ctorName := ctorName_1 } →
... | null | true |
QuadraticAlgebra.imₗ._proof_2 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} (a b : R) [inst : Semiring R] (x : R) (x_1 : QuadraticAlgebra R a b), (x • x_1).im = (x • x_1).im | null | false |
Lean.Meta.SavedState._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.SavedState → ℕ | null | false |
_private.Init.Data.Range.Polymorphic.PRange.0.Std.instDecidableEqRoi.decEq._proof_2 | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u_1} (a b : α), ¬a = b → a<...* = b<...* → False | null | false |
WellFoundedGT.toOrderTop.eq_1 | Mathlib.Order.WellFounded | ∀ (α : Type u_4) [inst : LinearOrder α] [inst_1 : Nonempty α] [h : WellFoundedGT α],
WellFoundedGT.toOrderTop α = { top := ⋯.min Set.univ ⋯, le_top := ⋯ } | null | true |
Submodule.toLocalizedQuotient._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | null | false |
_private.Mathlib.LinearAlgebra.UnitaryGroup.0.Matrix.kroneckerTMul_mem_unitary._simp_1_1 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, (U ∈ unitary R) = (star U * U = 1 ∧ U * star U = 1) | null | false |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.shouldPreprocess._sparseCasesOn_1 | Lean.Meta.Tactic.Simp.SimpTheorems | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
symmDiff_self | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a : α), symmDiff a a = ⊥ | null | true |
BitVec.instOrOp | Init.Data.BitVec.Basic | {w : ℕ} → OrOp (BitVec w) | null | true |
Representation.IntertwiningMap.instSMulInt | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
{V : Type u_6} →
{W : Type u_7} →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommGroup W] →
[inst_4 : Module A V] →
[inst_5 : Module A W] →
... | null | true |
AddMonoidHom.ker_id | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G], (AddMonoidHom.id G).ker = ⊥ | null | true |
Lean.Grind.AC.Seq.beq'_eq | Init.Grind.AC | ∀ (s₁ s₂ : Lean.Grind.AC.Seq), (s₁.beq' s₂ = true) = (s₁ = s₂) | null | true |
UniqueMul.of_mulHom_image | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Mul G] [inst_1 : Mul H] {A B : Finset G} {a0 b0 : G} [inst_2 : DecidableEq H]
(f : G →ₙ* H),
(∀ ⦃a b c d : G⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d) →
UniqueMul (Finset.image (⇑f) A) (Finset.image (⇑f) B) (f a0) (f b0) → UniqueMul A B a0 b0 | null | true |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.add_left_inj | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (a b c : BitVec w), (a + c == b + c) = (a == b) | null | true |
Std.DHashMap.Const.getKeyD_insertMany_list_of_mem | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {l : List (α × β)} {k k' fallback : α},
(k == k') = true →
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
k ∈ List.map Prod.fst l → (Std.DHashMap.Const.insertMany m l).getKeyD k'... | null | true |
List.toList_mkSlice_roi | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {lo : ℕ}, Std.Slice.toList (Std.Roi.Sliceable.mkSlice xs lo<...*) = List.drop (lo + 1) xs | null | true |
_private.Mathlib.Control.Monad.Cont.0.ExceptT.run_bind.match_1.splitter | Mathlib.Control.Monad.Cont | {ε α : Type u_1} →
(motive : Except ε α → Sort u_2) →
(x : Except ε α) → ((x : α) → motive (Except.ok x)) → ((e : ε) → motive (Except.error e)) → motive x | null | true |
Subgroup.widthInfty | Mathlib.NumberTheory.ModularForms.Cusps | Subgroup (GL (Fin 2) ℝ) → ℝ | The width of the cusp `∞`, i.e. the `x` such that `𝒢.periods = zmultiples x`, or 0 if no such
`x` exists. | true |
IsLocalization.moduleLid._proof_5 | Mathlib.RingTheory.Localization.BaseChange | ∀ (A : Type u_1) [inst : CommSemiring A], RingHomInvPair (RingHom.id A) (RingHom.id A) | null | false |
Lean.Elab.WF.mkWfParam | Lean.Elab.PreDefinition.WF.Preprocess | Lean.Expr → Lean.MetaM Lean.Expr | null | true |
AddChar.rec | Mathlib.Algebra.Group.AddChar | {A : Type u_1} →
[inst : AddMonoid A] →
{M : Type u_2} →
[inst_1 : Monoid M] →
{motive : AddChar A M → Sort u} →
((toFun : A → M) →
(map_zero_eq_one' : toFun 0 = 1) →
(map_add_eq_mul' : ∀ (a b : A), toFun (a + b) = toFun a * toFun b) →
motive... | null | false |
Std.DTreeMap.Raw.size_modify | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} {f : β k → β k}, (t.modify k f).size = t.size | null | true |
Char.minSurrogate | Batteries.Data.Char.Basic | ℕ | Minimum surrogate code point.
(See [unicode scalar value](https://www.unicode.org/glossary/#unicode_scalar_value).)
| true |
monovaryOn_iff_forall_smul_nonneg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β]
[IsStrictOrderedModule α β] {f : ι → α} {g : ι → β} {s : Set ι},
MonovaryOn f g s ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃... | null | true |
Lean.Meta.Sym.DSimp.SymDSimpVariantEntry.mk.inj | Lean.Meta.Sym.DSimp.Variant | ∀ {name : Lean.Name} {variant : Lean.Meta.Sym.DSimp.SymDSimpVariant} {name_1 : Lean.Name}
{variant_1 : Lean.Meta.Sym.DSimp.SymDSimpVariant},
{ name := name, variant := variant } = { name := name_1, variant := variant_1 } → name = name_1 ∧ variant = variant_1 | null | true |
Height.mulHeight_pos | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [Finite ι] (x : ι → K),
0 < Height.mulHeight x | null | true |
BitVec._sizeOf_1.eq._@.Mathlib.Util.CompileInductive.3197476844._hygCtx._hyg.364 | Mathlib.Util.CompileInductive | @BitVec._sizeOf_1 = @BitVec._sizeOf_1✝ | null | false |
FGAlgCat.uliftFunctor._proof_3 | Mathlib.Algebra.Category.CommAlgCat.FiniteType | ∀ (R : Type u_1) [inst : CommRing R] (A : FGAlgCat R), Algebra.FiniteType R ↑(CommAlgCat.of R (ULift.{u_3, u_2} ↑A.obj)) | null | false |
CentroidHom.isScalarTowerRight | Mathlib.Algebra.Ring.CentroidHom | ∀ {M : Type u_2} {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Monoid M] [inst_2 : DistribMulAction M α]
[inst_3 : SMulCommClass M α α] [inst_4 : IsScalarTower M α α], IsScalarTower M (CentroidHom α) (CentroidHom α) | null | true |
AddSubmonoid.LocalizationMap.map_comp_map | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : ↥S), g ↑y ∈ T)
{Q : Type u_4} [inst_3 : AddCommMonoid Q] {k : T.LocalizationMap Q} {A : Type u_5... | If `AddCommMonoid` homs `g : M →+ P, l : P →+ A` induce maps of localizations, the composition
of the induced maps equals the map of localizations induced by `l ∘ g`. | true |
Bool.toNat.eq_1 | Batteries.Data.Fin.Lemmas | ∀ (b : Bool), b.toNat = bif b then 1 else 0 | null | true |
BitVec.and_append | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ} {x₁ x₂ : BitVec w} {y₁ y₂ : BitVec v}, x₁ ++ y₁ &&& x₂ ++ y₂ = (x₁ &&& x₂) ++ (y₁ &&& y₂) | null | true |
CategoryTheory.shiftFunctorZero_hom_app_shift | Mathlib.CategoryTheory.Shift.Basic | ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddCommMonoid A]
[inst_2 : CategoryTheory.HasShift C A] {X : C} (n : A),
(CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C n).obj X) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorCom... | null | true |
Lean.Lsp.LeanDidOpenTextDocumentParams.toDidOpenTextDocumentParams | Lean.Data.Lsp.Extra | Lean.Lsp.LeanDidOpenTextDocumentParams → Lean.Lsp.DidOpenTextDocumentParams | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.toInt_eq_neg_toNat_neg_of_msb_true._simp_1_2 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ} {x y : BitVec n}, (x = y) = (x.toNat = y.toNat) | null | false |
QPF.Fix.mk | Mathlib.Data.QPF.Univariate.Basic | {F : Type u → Type u} → [q : QPF F] → F (QPF.Fix F) → QPF.Fix F | constructor of a type defined by a qpf | true |
Finset.inl_mem_sumLift₂ | Mathlib.Data.Sum.Interval | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6}
{f : α₁ → β₁ → Finset γ₁} {g : α₂ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂} {c₁ : γ₁},
Sum.inl c₁ ∈ Finset.sumLift₂ f g a b ↔ ∃ a₁ b₁, a = Sum.inl a₁ ∧ b = Sum.inl b₁ ∧ c₁ ∈ f a₁ b₁ | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.StructId.0.Lean.Meta.Grind.Arith.Linear.mkNatModuleInst? | Lean.Meta.Tactic.Grind.Arith.Linear.StructId | Lean.Level → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) | null | true |
AntitoneOn.Ioo | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f g : α → β} {s : Set α},
AntitoneOn f s → MonotoneOn g s → MonotoneOn (fun x => Set.Ioo (f x) (g x)) s | null | true |
Set.subset_compl_iff_disjoint_right | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ tᶜ ↔ Disjoint s t | null | true |
DedekindCut.principalIso._proof_2 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : CompleteLattice α] {a b : α},
DedekindCut.principalEmbedding.toEmbedding a ≤ DedekindCut.principalEmbedding.toEmbedding b ↔ a ≤ b | null | false |
GroupWithZero.div_eq_mul_inv | Mathlib.Algebra.GroupWithZero.Defs | ∀ {G₀ : Type u} [self : GroupWithZero G₀] (a b : G₀), a / b = a * b⁻¹ | `a / b := a * b⁻¹` | true |
Nat.ModEq.instTrans | Mathlib.Data.Nat.ModEq | {n : ℕ} → Trans n.ModEq n.ModEq n.ModEq | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.neg_two_pow_le_toInt_ediv._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w},
x.toInt < 2 ^ (w - 1) → -x.toInt ≤ x.toInt / y.toInt → ¬-2 ^ (w - 1) ≤ x.toInt / y.toInt → False | null | false |
AlgebraicGeometry.Scheme.IsLocallyDirected.tAux._proof_2 | Mathlib.AlgebraicGeometry.Gluing | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AlgebraicGeometry.Scheme)
[inst_1 : ∀ {i j : J} (f : i ⟶ j), AlgebraicGeometry.IsOpenImmersion (F.map f)] (i j : J)
(k :
(AlgebraicGeometry.Scheme.Opens.iSupOpenCover fun k => AlgebraicGeometry.Scheme.Hom.opensRange (F.... | null | false |
_private.Std.Http.Data.Extensions.0.Std.Http.Extensions.mk.noConfusion | Std.Http.Data.Extensions | {P : Sort u} →
{data data' : Std.TreeMap Lean.Name Dynamic Std.Http.Extensions.compareName} →
{ data := data } = { data := data' } → (data = data' → P) → P | null | false |
Mathlib.Tactic.Order.AtomicFact.ne.elim | Mathlib.Tactic.Order.CollectFacts | {motive : Mathlib.Tactic.Order.AtomicFact → Sort u} →
(t : Mathlib.Tactic.Order.AtomicFact) →
t.ctorIdx = 1 →
((lhs rhs : ℕ) → (proof : Lean.Expr) → motive (Mathlib.Tactic.Order.AtomicFact.ne lhs rhs proof)) → motive t | null | false |
Path.Homotopy.subpathTransSubpath | Mathlib.Topology.Subpath | {X : Type u_1} →
[inst : TopologicalSpace X] →
{a b : X} →
(γ : Path a b) →
(t₀ t₁ t₂ : ↑unitInterval) → ((γ.subpath t₀ t₁).trans (γ.subpath t₁ t₂)).Homotopy (γ.subpath t₀ t₂) | Following the subpath of `γ` from `t₀` to `t₁`, and then that from `t₁` to `t₂`,
is in natural homotopy with following the subpath of `γ` from `t₀` to `t₂`. | true |
_private.Init.Data.Vector.Algebra.0.Vector.neg_zero._proof_1_1 | Init.Data.Vector.Algebra | ∀ {n : ℕ} (i : ℕ), i + 1 ≤ n → i < n | null | false |
LocallyConnectedSpace.mk._flat_ctor | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u_3} [inst : TopologicalSpace α],
(∀ (x : α), (nhds x).HasBasis (fun s => IsOpen s ∧ x ∈ s ∧ IsConnected s) id) → LocallyConnectedSpace α | null | false |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_36 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | null | false |
_private.Mathlib.NumberTheory.Divisors.0.Int.mem_divisors._simp_1_1 | Mathlib.NumberTheory.Divisors | ∀ {x z : ℤ}, (x ∈ z.divisors) = (x.natAbs ∈ z.natAbs.divisors) | null | false |
ContinuousMultilinearMap.ofSubsingleton_symm_apply_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ (R : Type u) {ι : Type v} (M₂ : Type w₂) (M₃ : Type w₃) [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] [inst_5 : TopologicalSpace M₂]
[inst_6 : TopologicalSpace M₃] [inst_7 : Subsingleton ι] (i : ι) (f : ContinuousMultilinearMap R (fun x =... | null | true |
_private.Lean.Meta.Sym.Apply.0.Lean.Meta.Sym.BackwardRule.apply'.match_1 | Lean.Meta.Sym.Apply | (motive : Lean.Meta.Sym.ApplyResult → Sort u_1) →
(__x : Lean.Meta.Sym.ApplyResult) →
((mvarIds : List Lean.MVarId) → motive (Lean.Meta.Sym.ApplyResult.goals mvarIds)) →
((x : Lean.Meta.Sym.ApplyResult) → motive x) → motive __x | null | false |
Filter.eventuallyEq_iff_all_subsets | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} {f g : α → β} {l : Filter α}, f =ᶠ[l] g ↔ ∀ (s : Set α), ∀ᶠ (x : α) in l, x ∈ s → f x = g x | null | true |
_private.Lean.Meta.FunInfo.0.Lean.Meta.FunInfoEnvCacheKey._sizeOf_inst | Lean.Meta.FunInfo | SizeOf Lean.Meta.FunInfoEnvCacheKey✝ | null | false |
complEDS.eq_1 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R) (k n : ℤ), complEDS b c d k n = ↑n.sign * complEDS' b c d k n.natAbs | null | true |
FrameHom.copy_eq | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : FrameHom α β) (f' : α → β)
(h : f' = ⇑f), f.copy f' h = f | null | true |
ONote.zero | Mathlib.SetTheory.Ordinal.Notation | ONote | null | true |
_private.Mathlib.Topology.UniformSpace.AbstractCompletion.0.AbstractCompletion.termι'_2 | Mathlib.Topology.UniformSpace.AbstractCompletion | Lean.ParserDescr | null | true |
Set.unbounded_le_inter_lt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Unbounded (fun x1 x2 => x1 ≤ x2) (s ∩ {b | a < b}) ↔ Set.Unbounded (fun x1 x2 => x1 ≤ x2) s | null | true |
Convert.ExpensiveConfig.postTransparency._default | Mathlib.Tactic.Convert | Lean.Meta.TransparencyMode | null | false |
Preorder.noConfusionType | Mathlib.Order.Defs.PartialOrder | Sort u → {α : Type u_2} → Preorder α → {α' : Type u_2} → Preorder α' → Sort u | null | false |
Substring.Raw.ValidFor.startPos | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw}, Substring.Raw.ValidFor l m r s → s.startPos = { byteIdx := String.utf8Len l } | null | true |
CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_hom_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{H H' : CategoryTheory.Functor C D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F),
(CategoryTheor... | null | true |
Topology.IsInducing.sumElim | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : X → Z} {g : Y → Z},
Topology.IsInducing f →
Topology.IsInducing g →
Disjoint (closure (Set.range f)) (Set.range g) →
Disjoint (Set.range f) (closure (Set.range g)... | If `f` and `g` are inducing maps whose ranges are separated, then `Sum.elim f g` is inducing. | true |
CategoryTheory.Endofunctor.Coalgebra.isoMk_hom_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{V₀ V₁ : CategoryTheory.Endofunctor.Coalgebra F} (h : V₀.V ≅ V₁.V)
(w :
autoParam
(CategoryTheory.CategoryStruct.comp V₀.str (F.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom V₁.str)
CategoryTheory.Endof... | null | true |
CategoryTheory.ShortComplex.HomologyData.exact_iff_i_p_zero | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.HomologyData),
S.Exact ↔ CategoryTheory.CategoryStruct.comp h.left.i h.right.p = 0 | null | true |
Std.Http.URI.scheme | Std.Http.Data.URI.Basic | Std.Http.URI → Std.Http.URI.Scheme | The URI scheme (e.g., "http", "https", "ftp").
| true |
Std.Sat.AIG.instDecidableEqDecl.decEq._proof_3 | Std.Sat.AIG.Basic | ∀ {α : Type} (idx : α), ¬Std.Sat.AIG.Decl.false = Std.Sat.AIG.Decl.atom idx | null | false |
List.Ico.filter_le | Mathlib.Data.List.Intervals | ∀ (n m l : ℕ), List.filter (fun x => decide (l ≤ x)) (List.Ico n m) = List.Ico (max n l) m | null | true |
ModelWithCorners.continuous_symm | 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] (I : ModelWithCorners 𝕜 E H),
Continuous ↑I.symm | null | true |
CategoryTheory.ChosenPullbacksAlong.mk | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y X : C} →
{f : Y ⟶ X} →
(pullback : CategoryTheory.Functor (CategoryTheory.Over X) (CategoryTheory.Over Y)) →
(CategoryTheory.Over.map f ⊣ pullback) → CategoryTheory.ChosenPullbacksAlong f | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.offset_lt_rawEndPos_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
_private.Init.Data.Array.Lemmas.0.Array.foldlM.loop.match_1.splitter | Init.Data.Array.Lemmas | (motive : ℕ → Sort u_1) → (i : ℕ) → (Unit → motive 0) → ((i' : ℕ) → motive i'.succ) → motive i | null | true |
AddGroupWithOne.casesOn | Mathlib.Data.Int.Cast.Defs | {R : Type u} →
{motive : AddGroupWithOne R → Sort u_1} →
(t : AddGroupWithOne R) →
([toIntCast : IntCast R] →
[toAddMonoidWithOne : AddMonoidWithOne R] →
[toNeg : Neg R] →
[toSub : Sub R] →
(sub_eq_add_neg : ∀ (a b : R), a - b = a + -b) →
... | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.initFn._@.Lean.Elab.MutualDef.2791506682._hygCtx._hyg.2 | Lean.Elab.MutualDef | IO Unit | Makes the bodies of definitions available to importing modules.
This only has an effect if both the module the definition is defined in and the importing module
have the module system enabled.
| false |
Equiv.Perm.Basis.ofPermHom._proof_7 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis)
(σ τ : ↥(Equiv.Perm.OnCycleFactors.range_toPermHom' g)) (x : α),
a.ofPermHomFun (σ * τ)⁻¹ (a.ofPermHomFun (σ * τ) x) = x | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter.0.CategoryTheory.SimplicialObject.δ₀Iter_succ._proof_3 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ}, autoParam (n + i = m) CategoryTheory.SimplicialObject.δ₀Iter_succ._auto_1 → n + (i + 1) = m + 1 | null | false |
TopCat.Presheaf.algebra_section_stalk | Mathlib.Topology.Sheaves.CommRingCat | {X : TopCat} →
(F : TopCat.Presheaf CommRingCat X) →
{U : TopologicalSpace.Opens ↑X} → (x : ↥U) → Algebra ↑(F.obj (Opposite.op U)) ↑(F.stalk ↑x) | null | true |
Representation.IntertwiningMap.instAddCommMonoid | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid W] →
[inst_4 : Module A V] →
[inst_5 : Module A W] →
... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.