name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
trdeg_add_eq | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ (R : Type u_1) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [Nontrivial R]
{A : Type v} [inst_4 : CommRing A] [NoZeroDivisors A] [inst_6 : Algebra R A] [inst_7 : Algebra S A] [FaithfulSMul R S]
[FaithfulSMul S A] [IsScalarTower R S A], Algebra.trdeg R S + Algebra.trdeg S A = Algebra.trdeg R A | true |
Std.Internal.List.containsKey_filter_not_contains_iff | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α}
{hl₁ : Std.Internal.List.DistinctKeys l₁} {k : α},
Std.Internal.List.containsKey k (List.filter (fun p => !l₂.contains p.fst) l₁) = true ↔
Std.Internal.List.containsKey k l₁ = true ∧ ¬l₂.contains k = true | true |
Lean.Core.CoreM.asTask' | Lean.Elab.Task | {α : Type} → Lean.CoreM α → Lean.CoreM (Task (Lean.CoreM α)) | true |
Std.Time.Format.parse | Std.Time.Format.Basic | {f : Type} →
{typ : Type → f → Type} →
[self : Std.Time.Format f typ] → {α : Type} → (fmt : f) → typ (Option α) fmt → String → Except String α | true |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.sigma_eq_iff_eq_comp_cast.match_1_1 | Mathlib.Data.Fin.Tuple.Basic | ∀ {α : Type u_1} {a b : (ii : ℕ) × (Fin ii → α)} (motive : (∃ (h : a.fst = b.fst), a.snd = b.snd ∘ Fin.cast h) → Prop)
(x : ∃ (h : a.fst = b.fst), a.snd = b.snd ∘ Fin.cast h),
(∀ (w : a.fst = b.fst) (h' : a.snd = b.snd ∘ Fin.cast w), motive ⋯) → motive x | false |
Lean.Meta.mkImpCongr | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | true |
Polynomial.instNatCast | Mathlib.Algebra.Polynomial.Basic | {R : Type u} → [inst : Semiring R] → NatCast (Polynomial R) | true |
Equiv.symm_bijective | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v}, Function.Bijective Equiv.symm | true |
CategoryTheory.Limits.MonoCoprod.isColimitBinaryCofanSum._proof_2 | Mathlib.CategoryTheory.Limits.MonoCoprod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I₁ : Type u_3} {I₂ : Type u_4} {X : I₁ ⊕ I₂ → C}
(c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ Sum.inl))
(c₂ : CategoryTheory.Limits.Cofan (X ∘ Sum.inr)) (hc : CategoryTheory.Limits.IsColimit c)
(hc₁ : CategoryTheory.Limits.IsColimit c₁) (hc₂ : CategoryTheory.Limits.IsColimit c₂) {T : C} (f₁ : c₁.pt ⟶ T)
(f₂ : c₂.pt ⟶ T),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.MonoCoprod.binaryCofanSum c c₁ c₂ hc₁ hc₂).inr
(CategoryTheory.Limits.Cofan.IsColimit.desc hc fun i =>
match i with
| Sum.inl i₁ => CategoryTheory.CategoryStruct.comp (c₁.inj i₁) f₁
| Sum.inr i₂ => CategoryTheory.CategoryStruct.comp (c₂.inj i₂) f₂) =
f₂ | false |
Nat.toList_roc_eq_if | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...=n).toList = if m + 1 ≤ n then (m + 1) :: ((m + 1)<...=n).toList else [] | true |
PadicInt.instCommRing._aux_37 | Mathlib.NumberTheory.Padics.PadicIntegers | {p : ℕ} → [hp : Fact (Nat.Prime p)] → ℤ → ℤ_[p] → ℤ_[p] | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Counting.0.SimpleGraph.finsetWalkLength.match_1.eq_2 | Mathlib.Combinatorics.SimpleGraph.Walks.Counting | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | true |
AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal.mk._flat_ctor | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : AlgebraicGeometry.AffineTargetMorphismProperty},
P.toProperty.RespectsIso →
(∀ {X Y : AlgebraicGeometry.Scheme} [inst : AlgebraicGeometry.IsAffine Y] (f : X ⟶ Y)
(r : ↑(Y.presheaf.obj (Opposite.op ⊤))), P f → P (f ∣_ Y.basicOpen r)) →
(∀ {X Y : AlgebraicGeometry.Scheme} [inst : AlgebraicGeometry.IsAffine Y] (f : X ⟶ Y)
(s : Finset ↑(Y.presheaf.obj (Opposite.op ⊤))),
Ideal.span ↑s = ⊤ → (∀ (r : ↥s), P (f ∣_ Y.basicOpen ↑r)) → P f) →
P.IsLocal | false |
FirstOrder.Language.LHom.casesOn | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} →
{L' : FirstOrder.Language} →
{motive : (L →ᴸ L') → Sort u_1} →
(t : L →ᴸ L') →
((onFunction : ⦃n : ℕ⦄ → L.Functions n → L'.Functions n) →
(onRelation : ⦃n : ℕ⦄ → L.Relations n → L'.Relations n) →
motive { onFunction := onFunction, onRelation := onRelation }) →
motive t | false |
hasFPowerSeriesOnBall_pi_iff | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_9} [inst_3 : Fintype ι] {e : E} {Fm : ι → Type u_10}
[inst_4 : (i : ι) → NormedAddCommGroup (Fm i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (Fm i)] {f : (i : ι) → E → Fm i}
{r : ENNReal} {p : (i : ι) → FormalMultilinearSeries 𝕜 E (Fm i)},
0 < r →
(HasFPowerSeriesOnBall (fun x x_1 => f x_1 x) (FormalMultilinearSeries.pi p) e r ↔
∀ (i : ι), HasFPowerSeriesOnBall (f i) (p i) e r) | true |
Module.comap_annihilator | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {R₀ : Type u_4}
[inst_3 : CommSemiring R₀] [inst_4 : Module R₀ M] [inst_5 : Algebra R₀ R] [IsScalarTower R₀ R M],
Ideal.comap (algebraMap R₀ R) (Module.annihilator R M) = Module.annihilator R₀ M | true |
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.Visibility.mk | Lean.Compiler.IR.LLVMBindings | UInt64 → LLVM.Visibility | true |
Lean.Elab.Tactic.Doc.TacticDoc.docString | Lean.Elab.Tactic.Doc | Lean.Elab.Tactic.Doc.TacticDoc → Option String | true |
Set.mul_sInter_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} [inst : Mul α] (s : Set α) (T : Set (Set α)), s * ⋂₀ T ⊆ ⋂ t ∈ T, s * t | true |
Lean.ConstantKind.ctor.elim | Lean.Environment | {motive : Lean.ConstantKind → Sort u} →
(t : Lean.ConstantKind) → t.ctorIdx = 6 → motive Lean.ConstantKind.ctor → motive t | false |
Subgroup.IsSubnormal.brecOn | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {motive : (a : Subgroup G) → a.IsSubnormal → Prop} {a : Subgroup G}
(t : a.IsSubnormal), (∀ (a : Subgroup G) (t : a.IsSubnormal), Subgroup.IsSubnormal.below t → motive a t) → motive a t | true |
IsDedekindDomain.HeightOneSpectrum.intValuation_le_pow_iff_dvd | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R)
(n : ℕ), v.intValuation r ≤ WithZero.exp (-↑n) ↔ v.asIdeal ^ n ∣ Ideal.span {r} | true |
Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [inst : BEq α] [Std.LawfulBEqOrd α]
[Std.TransOrd α] [inst_3 : Inhabited α] (h : t.WF) {l : List α} {k : α},
k ∉ t → l.contains k = false → (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)).getKey! k = default | true |
MulOpposite.unop_inj | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} {x y : αᵐᵒᵖ}, MulOpposite.unop x = MulOpposite.unop y ↔ x = y | true |
SimpleGraph.Walk.IsPath.transfer | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {H : SimpleGraph V} {p : G.Walk u v} (hp : ∀ e ∈ p.edges, e ∈ H.edgeSet),
p.IsPath → (p.transfer H hp).IsPath | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic.0.Mathlib.Meta.Positivity.evalRealPi.match_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) → Sort u_1) →
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
((α : Q(Type)) →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
motive Lean.Level.zero _zα _pα e __alt __alt_2) →
((x : Lean.Level) →
(α : Q(Type x)) →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
motive x _zα _pα e __alt __alt_2) →
motive u _zα _pα e __alt __alt_1 | false |
HahnSeries.instNonUnitalCommSemiring | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : PartialOrder Γ] →
[IsOrderedCancelAddMonoid Γ] → [inst : NonUnitalCommSemiring R] → NonUnitalCommSemiring (HahnSeries Γ R) | true |
CategoryTheory.leftAdjointMate | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : C} →
[inst_2 : CategoryTheory.HasLeftDual X] → [inst_3 : CategoryTheory.HasLeftDual Y] → (X ⟶ Y) → (ᘁY ⟶ ᘁX) | true |
Lean.Elab.Term.elabValueOf._regBuiltin.Lean.Elab.Term.elabValueOf_1 | Lean.Elab.BuiltinTerm | IO Unit | false |
BitVec.reduceNe | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc | true |
LightCondensed.locallyConstantIsoFinYoneda | Mathlib.Condensed.Discrete.Colimit | (F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)) →
FintypeCat.toLightProfinite.op.comp
(LightCondensed.locallyConstantPresheaf
(F.obj (FintypeCat.toLightProfinite.op.obj (Opposite.op (FintypeCat.of PUnit.{u + 1}))))) ≅
LightCondensed.finYoneda F | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasSum_sum_support_of_ne_finset_zero._proof_1_4 | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_2} {β : Type u_1} {L : SummationFilter β} {f : β → α} {s : Finset β}
[inst : DecidablePred fun x => x ∈ L.support] (t : Finset β), ∀ a ∈ t, a ∈ (↑s ∩ L.support).toFinset → f a = f a | false |
QuotientGroup.quotientQuotientIsometryEquivQuotient.eq_1 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedCommGroup M] {S T : Subgroup M} (h : S ≤ T),
QuotientGroup.quotientQuotientIsometryEquivQuotient h =
{ toEquiv := (QuotientGroup.quotientQuotientEquivQuotient S T h).toEquiv, isometry_toFun := ⋯ } | true |
finAddFlip.eq_1 | Mathlib.Logic.Equiv.Fin.Basic | ∀ {m n : ℕ}, finAddFlip = (finSumFinEquiv.symm.trans (Equiv.sumComm (Fin m) (Fin n))).trans finSumFinEquiv | true |
Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (lhs n lhs_1 n_1 : ℕ),
(Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt lhs n = Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt lhs_1 n_1) =
(lhs = lhs_1 ∧ n = n_1) | true |
LinearEquiv.conj_exact_iff_exact | Mathlib.Algebra.Exact | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {N' : Type u_5} {P : Type u_6} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid N'] [inst_4 : AddCommMonoid P]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R N'] [inst_8 : Module R P] (f : M →ₗ[R] N)
(g : N →ₗ[R] P) (e : N ≃ₗ[R] N'), Function.Exact ⇑(↑e ∘ₗ f) ⇑(g ∘ₗ ↑e.symm) ↔ Function.Exact ⇑f ⇑g | true |
ValuativeRel.srel_iff | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x y : R}, x <ᵥ y ↔ ¬y ≤ᵥ x | true |
AffineMap.lineMap_eq_right_iff | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
[inst_3 : AddTorsor V1 P1] [IsDomain k] [Module.IsTorsionFree k V1] {p₀ p₁ : P1} {c : k},
(AffineMap.lineMap p₀ p₁) c = p₁ ↔ p₀ = p₁ ∨ c = 1 | true |
_private.Mathlib.Data.List.Basic.0.List.getLast_append_of_right_ne_nil._proof_1_12 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (l₂ : List α) (head : α) (tail : List α),
(head :: tail ++ l₂).length - 1 + 1 ≤ (head :: tail).length → (head :: tail ++ l₂).length - 1 < (head :: tail).length | false |
NumberField.FinitePlace.mk._proof_1 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(v : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)),
∃ v_1,
NumberField.place (NumberField.FinitePlace.embedding v_1) = NumberField.place (NumberField.FinitePlace.embedding v) | false |
Std.ExtDTreeMap.getKeyD_maxKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km fallback : α}, t.maxKey? = some km → t.getKeyD km fallback = km | true |
interior_inter | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, interior (s ∩ t) = interior s ∩ interior t | true |
NumberField.IsCMField.of_forall_isConj | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_2) [inst : Field K] [inst_1 : CharZero K] [Algebra.IsIntegral ℚ K] [NumberField.IsTotallyComplex K]
[IsGalois ℚ K] {σ : Gal(K/ℚ)}, (∀ (φ : K →+* ℂ), NumberField.ComplexEmbedding.IsConj φ σ) → NumberField.IsCMField K | true |
SymmetricPower.Rel.recOn | Mathlib.LinearAlgebra.TensorPower.Symmetric | ∀ {R ι : Type u} [inst : CommSemiring R] {M : Type v} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{motive : (a a_1 : PiTensorProduct R fun x => M) → SymmetricPower.Rel R ι M a a_1 → Prop}
{a a_1 : PiTensorProduct R fun x => M} (t : SymmetricPower.Rel R ι M a a_1),
(∀ (e : Equiv.Perm ι) (f : ι → M),
motive ((PiTensorProduct.tprod R) fun i => f i) ((PiTensorProduct.tprod R) fun i => f (e i)) ⋯) →
motive a a_1 t | false |
_private.Lean.Parser.Extension.0.Lean.Parser.isParserAlias.match_1 | Lean.Parser.Extension | (motive : Option (Lean.Parser.AliasValue Lean.Parser.Parser) → Sort u_1) →
(__do_lift : Option (Lean.Parser.AliasValue Lean.Parser.Parser)) →
((val : Lean.Parser.AliasValue Lean.Parser.Parser) → motive (some val)) →
((x : Option (Lean.Parser.AliasValue Lean.Parser.Parser)) → motive x) → motive __do_lift | false |
CategoryTheory.Bicategory.InducedBicategory.Hom₂.rec | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {B : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Bicategory C] →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → Sort u} →
((hom : f.hom ⟶ g.hom) → motive { hom := hom }) →
(t : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g) → motive t | false |
Std.Packages.LinearOrderOfOrdArgs.max_eq._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax | false |
IsLocallyConstant.apply_eq_of_preconnectedSpace | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [PreconnectedSpace X] {f : X → Y},
IsLocallyConstant f → ∀ (x y : X), f x = f y | true |
_private.Mathlib.Data.ENat.Basic.0.ENat.top_ne_one.match_1_1 | Mathlib.Data.ENat.Basic | ∀ (motive : ⊤ = 1 → Prop) (a : ⊤ = 1), motive a | false |
Set.powersetCard.compl.congr_simp | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] [inst_1 : Fintype α] {m : ℕ} (hm : m + n = Fintype.card α),
Set.powersetCard.compl hm = Set.powersetCard.compl hm | true |
Module.Relations.Solution.ofπ'._proof_1 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u_2} [inst : Ring A] {relations : Module.Relations A} {M : Type u_1} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (π : (relations.G →₀ A) →ₗ[A] M),
π ∘ₗ relations.map = 0 → ∀ (r : relations.R), π (relations.relation r) = 0 | false |
_private.Mathlib.GroupTheory.RegularWreathProduct.0.RegularWreathProduct.instFaithfulSMulProdOfNonempty._simp_5 | Mathlib.GroupTheory.RegularWreathProduct | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | false |
_private.Mathlib.Algebra.BigOperators.Expect.0.Finset.expect_ite_mem._simp_1_2 | Mathlib.Algebra.BigOperators.Expect | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b / a = a⁻¹ * b | false |
CategoryTheory.hoFunctor.isIso_prodComparison | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ (X Y : SSet), CategoryTheory.IsIso (CategoryTheory.Limits.prodComparison SSet.hoFunctor X Y) | true |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.posFittingComp_map_incl_sup_of_codisjoint._simp_1_2 | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [IsNoetherian R M] [IsArtinian R M],
LieModule.posFittingComp R L M = ⨅ k, LieModule.lowerCentralSeries R L M k | false |
ValuationSubring.integer_valuation | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K), A.valuation.integer = A.toSubring | true |
ContinuousLinearMap.precompCompactConvergenceCLM._proof_1 | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_3} {𝕜₂ : Type u_4} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_1}
{F : Type u_2} [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜₂ F]
[inst_6 : TopologicalSpace E] [inst_7 : TopologicalSpace F] (L : E →SL[σ] F),
∀ x ∈ {S | IsCompact S}, IsCompact (⇑L '' x) | false |
CategoryTheory.SimplicialObject.Homotopy.h_comp_σ_succ_of_lt_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject C} {f g : X ⟶ Y}
(self : CategoryTheory.SimplicialObject.Homotopy f g) {n : ℕ} (i j : Fin (n + 1)),
j ≤ i →
∀ {Z : C} (h : Y.obj (Opposite.op (SimplexCategory.mk (n + 1 + 1))) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.h j) (CategoryTheory.CategoryStruct.comp (Y.σ i.succ) h) =
CategoryTheory.CategoryStruct.comp (X.σ i) (CategoryTheory.CategoryStruct.comp (self.h j.castSucc) h) | true |
CircleDeg1Lift.lt_map_of_int_lt_translationNumber | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) {n : ℤ}, ↑n < f.translationNumber → ∀ (x : ℝ), x + ↑n < f x | true |
Lean.Order.PartialOrder.noConfusion | Init.Internal.Order.Basic | {P : Sort u_1} →
{α : Sort u} →
{t : Lean.Order.PartialOrder α} →
{α' : Sort u} →
{t' : Lean.Order.PartialOrder α'} → α = α' → t ≍ t' → Lean.Order.PartialOrder.noConfusionType P t t' | false |
_private.Mathlib.Algebra.Homology.ShortComplex.Preadditive.0.CategoryTheory.ShortComplex.Homotopy.ext.match_1 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} {inst : CategoryTheory.Category.{u_1, u_2} C} {inst_1 : CategoryTheory.Preadditive C}
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (motive : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ → Prop)
(h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
(∀ (h₀ : S₁.X₁ ⟶ S₂.X₁)
(h₀_f :
autoParam (CategoryTheory.CategoryStruct.comp h₀ S₂.f = 0) CategoryTheory.ShortComplex.Homotopy.h₀_f._autoParam)
(h₁ : S₁.X₂ ⟶ S₂.X₁) (h₂ : S₁.X₃ ⟶ S₂.X₂) (h₃ : S₁.X₃ ⟶ S₂.X₃)
(g_h₃ :
autoParam (CategoryTheory.CategoryStruct.comp S₁.g h₃ = 0) CategoryTheory.ShortComplex.Homotopy.g_h₃._autoParam)
(comm₁ :
autoParam (φ₁.τ₁ = CategoryTheory.CategoryStruct.comp S₁.f h₁ + h₀ + φ₂.τ₁)
CategoryTheory.ShortComplex.Homotopy.comm₁._autoParam)
(comm₂ :
autoParam
(φ₁.τ₂ = CategoryTheory.CategoryStruct.comp S₁.g h₂ + CategoryTheory.CategoryStruct.comp h₁ S₂.f + φ₂.τ₂)
CategoryTheory.ShortComplex.Homotopy.comm₂._autoParam)
(comm₃ :
autoParam (φ₁.τ₃ = h₃ + CategoryTheory.CategoryStruct.comp h₂ S₂.g + φ₂.τ₃)
CategoryTheory.ShortComplex.Homotopy.comm₃._autoParam),
motive
{ h₀ := h₀, h₀_f := h₀_f, h₁ := h₁, h₂ := h₂, h₃ := h₃, g_h₃ := g_h₃, comm₁ := comm₁, comm₂ := comm₂,
comm₃ := comm₃ }) →
motive h | false |
measurable_from_top | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace β] {f : α → β}, Measurable f | true |
_private.Mathlib.Lean.MessageData.ForExprs.0.Lean.MessageData.forExprsIn.goFmt | Mathlib.Lean.MessageData.ForExprs | {m : Type → Type u} →
[Monad m] →
{σ : Type} →
(Lean.PPContext × Lean.Expr → σ → m (ForInStep σ)) →
Lean.PPContext → Lean.PrettyPrinter.InfoPerPos → σ → Std.Format → m (ForInStep σ) | true |
Denumerable.lower.eq_2 | Mathlib.Logic.Equiv.Multiset | ∀ (x m : ℕ) (l : List ℕ), Denumerable.lower (m :: l) x = (m - x) :: Denumerable.lower l m | true |
compl_sSup' | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [inst : CompleteBooleanAlgebra α] {s : Set α}, (sSup s)ᶜ = sInf (compl '' s) | true |
UniformEquiv.prodPUnit._proof_1 | Mathlib.Topology.UniformSpace.Equiv | ∀ (α : Type u_1) [inst : UniformSpace α], UniformContinuous fun a => (id a, PUnit.unit) | false |
LightCondMod.instReflectsEpimorphismsLightCondSetForget | Mathlib.Condensed.Light.Epi | ∀ (R : Type u) [inst : Ring R], (LightCondensed.forget R).ReflectsEpimorphisms | true |
groupCohomology.dArrowIso₀₁._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | IsRightCancelAdd ℕ | false |
HomologicalComplex₂.ofGradedObject_d_f | Mathlib.Algebra.Homology.HomologicalBicomplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{I₁ : Type u_2} {I₂ : Type u_3} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(X : CategoryTheory.GradedObject (I₁ × I₂) C) (d₁ : (i₁ i₁' : I₁) → (i₂ : I₂) → X (i₁, i₂) ⟶ X (i₁', i₂))
(d₂ : (i₁ : I₁) → (i₂ i₂' : I₂) → X (i₁, i₂) ⟶ X (i₁, i₂'))
(shape₁ : ∀ (i₁ i₁' : I₁), ¬c₁.Rel i₁ i₁' → ∀ (i₂ : I₂), d₁ i₁ i₁' i₂ = 0)
(shape₂ : ∀ (i₁ : I₁) (i₂ i₂' : I₂), ¬c₂.Rel i₂ i₂' → d₂ i₁ i₂ i₂' = 0)
(d₁_comp_d₁ : ∀ (i₁ i₁' i₁'' : I₁) (i₂ : I₂), CategoryTheory.CategoryStruct.comp (d₁ i₁ i₁' i₂) (d₁ i₁' i₁'' i₂) = 0)
(d₂_comp_d₂ : ∀ (i₁ : I₁) (i₂ i₂' i₂'' : I₂), CategoryTheory.CategoryStruct.comp (d₂ i₁ i₂ i₂') (d₂ i₁ i₂' i₂'') = 0)
(comm :
∀ (i₁ i₁' : I₁) (i₂ i₂' : I₂),
CategoryTheory.CategoryStruct.comp (d₁ i₁ i₁' i₂) (d₂ i₁' i₂ i₂') =
CategoryTheory.CategoryStruct.comp (d₂ i₁ i₂ i₂') (d₁ i₁ i₁' i₂'))
(i₁ i₁' : I₁) (i₂ : I₂),
((HomologicalComplex₂.ofGradedObject c₁ c₂ X d₁ d₂ shape₁ shape₂ d₁_comp_d₁ d₂_comp_d₂ comm).d i₁ i₁').f i₂ =
d₁ i₁ i₁' i₂ | true |
ContinuousAddEquiv.mk.inj | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {G : Type u} {inst : TopologicalSpace G} {H : Type v} {inst_1 : TopologicalSpace H} {inst_2 : Add G} {inst_3 : Add H}
{toAddEquiv : G ≃+ H}
{continuous_toFun : autoParam (Continuous toAddEquiv.toFun) Homeomorph.continuous_toFun._autoParam}
{continuous_invFun : autoParam (Continuous toAddEquiv.invFun) Homeomorph.continuous_invFun._autoParam}
{toAddEquiv_1 : G ≃+ H}
{continuous_toFun_1 : autoParam (Continuous toAddEquiv_1.toFun) Homeomorph.continuous_toFun._autoParam}
{continuous_invFun_1 : autoParam (Continuous toAddEquiv_1.invFun) Homeomorph.continuous_invFun._autoParam},
{ toAddEquiv := toAddEquiv, continuous_toFun := continuous_toFun, continuous_invFun := continuous_invFun } =
{ toAddEquiv := toAddEquiv_1, continuous_toFun := continuous_toFun_1, continuous_invFun := continuous_invFun_1 } →
toAddEquiv = toAddEquiv_1 | true |
CategoryTheory.Limits.FormalCoproduct.category._proof_6 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {W X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ f := h.f ∘ { f := g.f ∘ f.f, φ := fun x => CategoryTheory.CategoryStruct.comp (f.φ x) (g.φ (f.f x)) }.f,
φ := fun x =>
CategoryTheory.CategoryStruct.comp
({ f := g.f ∘ f.f, φ := fun x => CategoryTheory.CategoryStruct.comp (f.φ x) (g.φ (f.f x)) }.φ x)
(h.φ ({ f := g.f ∘ f.f, φ := fun x => CategoryTheory.CategoryStruct.comp (f.φ x) (g.φ (f.f x)) }.f x)) } =
{ f := { f := h.f ∘ g.f, φ := fun x => CategoryTheory.CategoryStruct.comp (g.φ x) (h.φ (g.f x)) }.f ∘ f.f,
φ := fun x =>
CategoryTheory.CategoryStruct.comp (f.φ x)
({ f := h.f ∘ g.f, φ := fun x => CategoryTheory.CategoryStruct.comp (g.φ x) (h.φ (g.f x)) }.φ (f.f x)) } | false |
Lean.Meta.Sym.getLevel | Lean.Meta.Sym.InferType | Lean.Expr → Lean.Meta.Sym.SymM Lean.Level | true |
SheafOfModules.pushforwardNatIso | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : CategoryTheory.GrothendieckTopology C} →
{K : CategoryTheory.GrothendieckTopology D} →
{F G : CategoryTheory.Functor C D} →
{T : CategoryTheory.Sheaf J RingCat} →
{S : CategoryTheory.Sheaf K RingCat} →
[inst_2 : F.IsContinuous J K] →
[inst_3 : G.IsContinuous J K] →
(φ : T ⟶ (G.sheafPushforwardContinuous RingCat J K).obj S) →
(α : F ≅ G) →
SheafOfModules.pushforward φ ≅
SheafOfModules.pushforward
(CategoryTheory.CategoryStruct.comp φ
((CategoryTheory.Functor.sheafPushforwardContinuousNatTrans α.hom RingCat J K).app S)) | true |
Int8.shiftRight_and | Init.Data.SInt.Bitwise | ∀ {a b c : Int8}, (a &&& b) >>> c = a >>> c &&& b >>> c | true |
BoxIntegral.unitPartition.mem_box_iff_index | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} {n : ℕ} [inst : NeZero n] {x : ι → ℝ} {ν : ι → ℤ},
x ∈ BoxIntegral.unitPartition.box n ν ↔ BoxIntegral.unitPartition.index n x = ν | true |
CategoryTheory.Limits.preservesColimitsOfSize_shrink | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D)
[CategoryTheory.Limits.PreservesColimitsOfSize.{max w w₂, max w' w₂', v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.instCompleteSpace._simp_2 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | false |
Std.TreeSet.Raw.max?_eq_some_maxD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback : α}, t.max? = some (t.maxD fallback) | true |
HomologicalComplex.opFunctor._proof_2 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {X Y : (HomologicalComplex V c)ᵒᵖ} (f : X ⟶ Y) (i j : ι),
CategoryTheory.CategoryStruct.comp (f.unop.f i).op ((Opposite.unop Y).op.d i j) =
CategoryTheory.CategoryStruct.comp ((Opposite.unop X).op.d i j) (f.unop.f j).op | false |
ValuativeRel.IsNontrivial.condition | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} {inst : CommRing R} {inst_1 : ValuativeRel R} [self : ValuativeRel.IsNontrivial R], ∃ γ, γ ≠ 0 ∧ γ ≠ 1 | true |
_private.Lean.Compiler.LCNF.FixedParams.0.Lean.Compiler.LCNF.FixedParams.isEquivalentFunDecl?.match_3 | Lean.Compiler.LCNF.FixedParams | (motive : Option Lean.Compiler.LCNF.FixedParams.AbsValue → Sort u_1) →
(x : Option Lean.Compiler.LCNF.FixedParams.AbsValue) →
((funIdx : ℕ) → motive (some (Lean.Compiler.LCNF.FixedParams.AbsValue.val funIdx))) →
((x : Option Lean.Compiler.LCNF.FixedParams.AbsValue) → motive x) → motive x | false |
LinearMap.IsOrthoᵢ.nondegenerate_of_not_isOrtho_basis_self | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {n : Type u_19} {R : Type u_20} {M : Type u_21} {M₁ : Type u_22} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module R M] [inst_4 : Module R M₁] [IsDomain R] [Module.IsTorsionFree R M₁]
{B : M →ₗ[R] M →ₗ[R] M₁} (v : Module.Basis n R M),
B.IsOrthoᵢ ⇑v → (∀ (i : n), ¬B.IsOrtho (v i) (v i)) → B.Nondegenerate | true |
MonoidHom.transfer._proof_2 | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_2} [inst : Group G] {H : Subgroup G} {A : Type u_1} [inst_1 : CommGroup A] (ϕ : ↥H →* A)
[inst_2 : H.FiniteIndex] (g h : G),
Subgroup.leftTransversals.diff ϕ default ((g * h) • default) =
Subgroup.leftTransversals.diff ϕ default (g • default) * Subgroup.leftTransversals.diff ϕ default (h • default) | false |
_private.Mathlib.Order.Monotone.Basic.0.StrictMono.isMin_of_apply.match_1_1 | Mathlib.Order.Monotone.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α} (motive : (∃ b, b < a) → Prop) (x : ∃ b, b < a),
(∀ (w : α) (hb : w < a), motive ⋯) → motive x | false |
_private.Std.Sat.AIG.RefVecOperator.Map.0.Std.Sat.AIG.RefVec.map.go_get_aux._proof_1_1 | Std.Sat.AIG.RefVecOperator.Map | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig : Std.Sat.AIG α} (curr : ℕ)
(s : aig.RefVec curr) (input : aig.RefVec len) (f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] [Std.Sat.AIG.RefVec.LawfulMapOperator α f],
∀ idx < curr, curr < len → ¬idx < curr + 1 → False | false |
MeasureTheory.AEEqFun.coeFn_smul | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
{𝕜 : Type u_5} [inst_2 : SMul 𝕜 γ] [inst_3 : ContinuousConstSMul 𝕜 γ] (c : 𝕜) (f : α →ₘ[μ] γ), ↑(c • f) =ᵐ[μ] c • ↑f | true |
UpperHalfPlane.smulFDeriv | Mathlib.Analysis.Complex.UpperHalfPlane.Manifold | GL (Fin 2) ℝ → ℂ → ℂ →L[ℝ] ℂ | true |
Orientation.oangle.eq_1 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), o.oangle x y = ↑((o.kahler x) y).arg | true |
nonempty_commRing_iff | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u), Nonempty (CommRing α) ↔ Nonempty α | true |
Polynomial.eval₂RingHom'._proof_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S),
(∀ (a : R), Commute (f a) x) →
∀ (_p q : Polynomial R), Polynomial.eval₂ f x (_p * q) = Polynomial.eval₂ f x _p * Polynomial.eval₂ f x q | false |
Dynamics.netMaxcard_zero | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} {F : Set X} (T : X → X), F.Nonempty → ∀ (U : SetRel X X), Dynamics.netMaxcard T F U 0 = 1 | true |
DistLat.casesOn | Mathlib.Order.Category.DistLat | {motive : DistLat → Sort u} →
(t : DistLat) →
((carrier : Type u_1) → [str : DistribLattice carrier] → motive { carrier := carrier, str := str }) → motive t | false |
MeasureTheory.innerRegularWRT_isCompact_isClosed | Mathlib.MeasureTheory.Measure.RegularityCompacts | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
[TopologicalSpace.IsCompletelyPseudoMetrizableSpace α] [OpensMeasurableSpace α] (P : MeasureTheory.Measure α)
[MeasureTheory.IsFiniteMeasure P], P.InnerRegularWRT (fun s => IsCompact s ∧ IsClosed s) IsClosed | true |
Int8.casesOn | Init.Data.SInt.Basic | {motive : Int8 → Sort u} → (t : Int8) → ((toUInt8 : UInt8) → motive { toUInt8 := toUInt8 }) → motive t | false |
AffineSubspace.card_pos_of_affineSpan_eq_top | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] {ι : Type u_5} [inst_3 : Fintype ι] {p : ι → P},
affineSpan k (Set.range p) = ⊤ → 0 < Fintype.card ι | true |
CategoryTheory.Functor.Monoidal.whiskerLeft_δ_μ | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X Y : C) (T : D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft T (CategoryTheory.Functor.OplaxMonoidal.δ F X Y))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft T (CategoryTheory.Functor.LaxMonoidal.μ F X Y)) =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj T (F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))) | true |
LightDiagram.instCategory | Mathlib.Topology.Category.LightProfinite.Basic | CategoryTheory.Category.{u_1, u_1 + 1} LightDiagram | true |
Lean.IR.ExpandResetReuse.ProjMap | Lean.Compiler.IR.ExpandResetReuse | Type | true |
Lean.Meta.Grind.Order.Cnstr.rec | Lean.Meta.Tactic.Grind.Order.Types | {α : Type} →
{motive : Lean.Meta.Grind.Order.Cnstr α → Sort u} →
((kind : Lean.Meta.Grind.Order.CnstrKind) →
(u v : α) →
(k : ℤ) →
(e : Lean.Expr) →
(h? : Option Lean.Expr) → motive { kind := kind, u := u, v := v, k := k, e := e, h? := h? }) →
(t : Lean.Meta.Grind.Order.Cnstr α) → motive t | false |
GroupTopology.instSemilatticeInf._proof_1 | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u_1} [inst : Group α] {x y : GroupTopology α},
y.toTopologicalSpace ≤ x.toTopologicalSpace ↔ y.toTopologicalSpace ≤ x.toTopologicalSpace | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.