name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.SetTheory.ZFC.Cardinal.0.ZFSet.card_insert._simp_1_1 | Mathlib.SetTheory.ZFC.Cardinal | ∀ {x : ZFSet.{u}}, Cardinal.lift.{u + 1, u} x.card = Cardinal.mk ↥x | false |
_private.Mathlib.Algebra.Order.Group.DenselyOrdered.0.exists_add_right_lt | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LT α] [DenselyOrdered α] [AddLeftStrictMono α] {a b c : α},
a + b < c → ∃ b' > b, a + b' < c | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.toReal_add_of_sign_pos_sign_neg._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ ψ : Real.Angle}, θ.sign = 1 → ψ.sign = -1 → -Real.pi < θ.toReal + ψ.toReal ∧ θ.toReal + ψ.toReal ≤ Real.pi | false |
LightProfinite.instWEqualsLocallyBijectiveCoherentTopology | Mathlib.Condensed.Light.Instances | ∀ (A : Type u') [inst : CategoryTheory.Category.{u, u'} A] [CategoryTheory.Limits.HasLimits A]
[CategoryTheory.Limits.HasColimits A] {FA : A → A → Type v} {CA : A → Type u}
[inst_3 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_4 : CategoryTheory.ConcreteCategory A FA]
[CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget A)]
[CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget A)] [(CategoryTheory.forget A).ReflectsIsomorphisms],
(CategoryTheory.coherentTopology LightProfinite).WEqualsLocallyBijective A | true |
CategoryTheory.Functor.mapConeInv.eq_1 | 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] (H : CategoryTheory.Functor C D)
{F : CategoryTheory.Functor J C} [inst_3 : H.IsEquivalence] (c : CategoryTheory.Limits.Cone (F.comp H)),
H.mapConeInv c = (CategoryTheory.Limits.Cone.functorialityEquivalence F H.asEquivalence).inverse.obj c | true |
ball_add_zero | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (s : Set E), Metric.ball 0 δ + s = Metric.thickening δ s | true |
Manifold.«term_≫_» | Mathlib.Geometry.Manifold.StructureGroupoid | Lean.TrailingParserDescr | true |
AddSubmonoid.coe_finset_sum._simp_1 | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {ι : Type u_4} {M : Type u_5} [inst : AddCommMonoid M] (S : AddSubmonoid M) (f : ι → ↥S) (s : Finset ι),
∑ i ∈ s, ↑(f i) = ↑(∑ i ∈ s, f i) | false |
CategoryTheory.Monoidal.InducingFunctorData._sizeOf_1 | Mathlib.CategoryTheory.Monoidal.Transport | {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.MonoidalCategoryStruct D} →
{F : CategoryTheory.Functor D C} →
[SizeOf C] → [SizeOf D] → CategoryTheory.Monoidal.InducingFunctorData F → ℕ | false |
_private.Mathlib.RingTheory.Idempotents.0.eq_of_isNilpotent_sub_of_isIdempotentElem_of_commute._simp_1_1 | Mathlib.RingTheory.Idempotents | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThree_of_FermatLastTheoremThreeGen | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3) [inst_1 : NumberField K]
[IsCyclotomicExtension {3} ℚ K], FermatLastTheoremForThreeGen✝ hζ → FermatLastTheoremFor 3 | true |
Algebra.TensorProduct.piScalarRight_tmul | Mathlib.RingTheory.TensorProduct.Pi | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] {ι : Type u_4}
[inst_7 : Fintype ι] [inst_8 : DecidableEq ι] (x : A) (y : ι → R),
(Algebra.TensorProduct.piScalarRight R S A ι) (x ⊗ₜ[R] y) = fun i => y i • x | true |
AddSubgroup.nsmul_mem_of_index_ne_zero_of_dvd | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G},
H.index ≠ 0 → ∀ (a : G) {n : ℕ}, (∀ (m : ℕ), 0 < m → m ≤ H.index → m ∣ n) → n • a ∈ H | true |
Finpartition.rec | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{a : α} →
{motive : Finpartition a → Sort u} →
((parts : Finset α) →
(supIndep : parts.SupIndep id) →
(sup_parts : parts.sup id = a) →
(bot_notMem : ⊥ ∉ parts) →
motive { parts := parts, supIndep := supIndep, sup_parts := sup_parts, bot_notMem := bot_notMem }) →
(t : Finpartition a) → motive t | false |
AddGrpCat.limitAddGroup._proof_3 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddGrpCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddGrpCat)).sections]
(a b c : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddGrpCat))).pt),
a + b + c = a + (b + c) | false |
Lean.StructureResolutionState.rec | Lean.Structure | {motive : Lean.StructureResolutionState → Sort u} →
((resolutions : Lean.PHashMap Lean.Name (Array Lean.Name)) → motive { resolutions := resolutions }) →
(t : Lean.StructureResolutionState) → motive t | false |
NFA.toεNFA | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → NFA α σ → εNFA α σ | true |
_private.Mathlib.Order.Filter.Lift.0.Filter.HasBasis.lift._simp_1_1 | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_27 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {s : ℕ}
(h : 1 ≤ (List.idxsOf x (head :: tail) s).length), (List.idxsOf x (head :: tail) s)[0] - s < (head :: tail).length | false |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.measure_limRatioMeas_top._simp_1_3 | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {r : NNReal}, (↑r = 0) = (r = 0) | false |
SetLike.delabSubtypeSetLike | Mathlib.Data.SetLike.Basic | Lean.PrettyPrinter.Delaborator.Delab | true |
_private.Init.Data.Option.Lemmas.0.Option.pfilter_eq_some_iff._simp_1_2 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {p : (a : α) → o = some a → Bool},
((o.pfilter p).isSome = true) = ∃ a, ∃ (ha : o = some a), p a ha = true | false |
Lean.Meta.CongrArgKind.casesOn | Lean.Meta.CongrTheorems | {motive : Lean.Meta.CongrArgKind → Sort u} →
(t : Lean.Meta.CongrArgKind) →
motive Lean.Meta.CongrArgKind.fixed →
motive Lean.Meta.CongrArgKind.fixedNoParam →
motive Lean.Meta.CongrArgKind.eq →
motive Lean.Meta.CongrArgKind.cast →
motive Lean.Meta.CongrArgKind.heq → motive Lean.Meta.CongrArgKind.subsingletonInst → motive t | false |
TestFunction.instAddCommGroup._proof_13 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousConstSMul ℕ F | false |
CategoryTheory.EffectiveEpiFamily.fac | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {B W : C} {α : Type u_2} (X : α → C)
(π : (a : α) → X a ⟶ B) [inst_1 : CategoryTheory.EffectiveEpiFamily X π] (e : (a : α) → X a ⟶ W)
(h :
∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂))
(a : α), CategoryTheory.CategoryStruct.comp (π a) (CategoryTheory.EffectiveEpiFamily.desc X π e ⋯) = e a | true |
Associates.prod_factors | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [Nontrivial α]
(s : Associates.FactorSet α), s.prod.factors = s | true |
Lean.Widget.RpcEncodablePacket.range._@.Lean.Widget.InteractiveGoal.2553565095._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | Lean.Widget.RpcEncodablePacket✝ → Lean.Json | false |
MeasureTheory.L2.inner_indicatorConstLp_one_indicatorConstLp_one | Mathlib.MeasureTheory.Function.L2Space | ∀ {α : Type u_1} {𝕜 : Type u_4} [inst : RCLike 𝕜] [inst_1 : MeasurableSpace α] {μ : MeasureTheory.Measure α}
{s t : Set α} (hs : MeasurableSet s) (ht : MeasurableSet t)
(hμs : autoParam (μ s ≠ ⊤) MeasureTheory.L2.inner_indicatorConstLp_one_indicatorConstLp_one._auto_1)
(hμt : autoParam (μ t ≠ ⊤) MeasureTheory.L2.inner_indicatorConstLp_one_indicatorConstLp_one._auto_3),
inner 𝕜 (MeasureTheory.indicatorConstLp 2 hs hμs 1) (MeasureTheory.indicatorConstLp 2 ht hμt 1) = ↑(μ.real (s ∩ t)) | true |
Valuation.IsEquiv.uniformContinuous_equivWithVal | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_4} {Γ₀ : Type u_5} {Γ₀' : Type u_6} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
[inst_2 : LinearOrderedCommGroupWithZero Γ₀'] {v : Valuation R Γ₀} {w : Valuation R Γ₀'},
v.IsEquiv w → UniformContinuous ⇑(WithVal.congr v w (RingEquiv.refl R)) | true |
Fin.succAboveOrderEmb_toEmbedding | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (p : Fin (n + 1)), p.succAboveOrderEmb.toEmbedding = { toFun := p.succAbove, inj' := ⋯ } | true |
tendsto_nhds_unique_dist | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : β → α} {l : Filter β} {x y : α} [l.NeBot],
Filter.Tendsto f l (nhds x) → Filter.Tendsto f l (nhds y) → dist x y = 0 | true |
Sublattice.instCompleteLattice._proof_7 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (_S : Sublattice α) (_a : α), False → _a ∈ _S | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.toSubgraph_adj_penultimate._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} (w : G.Walk u v), 0 < w.length → w.length - 1 + 1 = w.length | false |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.abstractAtoms.go._unary.eq_def | Lean.Meta.Tactic.AC.Main | ∀ (preContext : Lean.Meta.AC.PreContext) (atoms : Array Lean.Expr)
(k : Array (Lean.Expr × Option Lean.Expr) → Lean.MetaM Lean.Expr) (α : Lean.Expr) (u : Lean.Level)
(_x : (_ : ℕ) ×' (_ : Array (Lean.Expr × Option Lean.Expr)) ×' (_ : Array Lean.Expr) ×' Array Lean.Expr),
Lean.Meta.AC.abstractAtoms.go._unary✝ preContext atoms k α u _x =
PSigma.casesOn _x fun i acc =>
PSigma.casesOn acc fun acc vars =>
PSigma.casesOn vars fun vars args =>
if h : i < atoms.size then
Lean.Meta.withLocalDeclD `x α fun v => do
let __do_lift ← Lean.Meta.AC.getInstance `Std.LawfulIdentity #[preContext.op, atoms[i]]
match __do_lift with
| none =>
Lean.Meta.AC.abstractAtoms.go._unary✝¹ preContext atoms k α u
⟨i + 1, ⟨acc.push (v, none), ⟨vars.push v, args.push atoms[i]⟩⟩⟩
| some inst =>
Lean.Meta.withLocalDeclD `inst (Lean.mkApp3 (Lean.mkConst `Std.LawfulIdentity [u]) α preContext.op v)
fun iv =>
Lean.Meta.AC.abstractAtoms.go._unary✝² preContext atoms k α u
⟨i + 1, ⟨acc.push (v, some iv), ⟨vars ++ #[v, iv], args ++ #[atoms[i], inst]⟩⟩⟩
else do
let proof ← k acc
let proof ← Lean.Meta.mkLambdaFVars vars proof
have proof : Lean.Expr := Lean.mkAppN proof args
pure proof | false |
Vector.swapAt!_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α}, xs.size = n → ∀ {i : ℕ} {x : α}, (xs.swapAt! i x).2.size = n | false |
Subsemiring.coe_set_mk | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] {toSubmonoid : Submonoid R}
(add_mem : ∀ {a b : R}, a ∈ toSubmonoid.carrier → b ∈ toSubmonoid.carrier → a + b ∈ toSubmonoid.carrier)
(zero_mem : 0 ∈ toSubmonoid.carrier),
↑{ toSubmonoid := toSubmonoid, add_mem' := add_mem, zero_mem' := zero_mem } = ↑toSubmonoid | true |
CommSemiring.directSumGCommSemiring | Mathlib.Algebra.DirectSum.Ring | (ι : Type u_1) →
{R : Type u_2} → [inst : AddCommMonoid ι] → [inst_1 : CommSemiring R] → DirectSum.GCommSemiring fun x => R | true |
Lean.Doc.WithSyntax.rec | Lean.Elab.DocString | {α : Type u} →
{motive : Lean.Doc.WithSyntax α → Sort u_1} →
((val : α) → (stx : Lean.Syntax) → motive { val := val, stx := stx }) → (t : Lean.Doc.WithSyntax α) → motive t | false |
FirstOrder.Language.Substructure.mem_top._simp_1 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] (x : M), (x ∈ ⊤) = True | false |
MeasureTheory.IntegrableAtFilter.neg | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {E : Type u_5} {mα : MeasurableSpace α} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
{l : Filter α} {f : α → E}, MeasureTheory.IntegrableAtFilter f l μ → MeasureTheory.IntegrableAtFilter (-f) l μ | true |
Affine.Simplex.median_eq_line_point_centroid | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} [inst_4 : NeZero n] [CharZero k] (s : Affine.Simplex k P n) (i : Fin (n + 1)),
s.median i = affineSpan k {s.points i, s.centroid} | true |
Lean.Meta.TransparencyMode._sizeOf_inst | Init.MetaTypes | SizeOf Lean.Meta.TransparencyMode | false |
CategoryTheory.ObjectProperty.IsClosedUnderFiniteProducts.recOn | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P : CategoryTheory.ObjectProperty C} →
{motive : P.IsClosedUnderFiniteProducts → Sort u} →
(t : P.IsClosedUnderFiniteProducts) →
((isClosedUnderLimitsOfShape :
∀ (J : Type) [Finite J], P.IsClosedUnderLimitsOfShape (CategoryTheory.Discrete J)) →
motive ⋯) →
motive t | false |
PFun.bind_defined | Mathlib.Data.PFun | ∀ {α : Type u_7} {β γ : Type u_8} (p : Set α) {f : α →. β} {g : β → α →. γ},
p ⊆ f.Dom → (∀ (x : β), p ⊆ (g x).Dom) → p ⊆ (f >>= g).Dom | true |
Int.neg_le_iff | Init.Data.Int.Order | ∀ {x y : ℤ}, -x ≤ y ↔ -y ≤ x | true |
Set.instCompleteAtomicBooleanAlgebra._proof_1 | Mathlib.Data.Set.BooleanAlgebra | ∀ {α : Type u_1} (x : Set (Set α)), sSup x ∈ upperBounds x ∧ sSup x ∈ lowerBounds (upperBounds x) | false |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set_gt._proof_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, i < j → ∀ {w : j < xs.size}, ¬i < xs.size → False | false |
Real.Wallis.W._proof_2 | Mathlib.Analysis.Real.Pi.Wallis | (2 + 1).AtLeastTwo | false |
Filter.Eventually.self_of_nhdsWithin | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {p : α → Prop} {s : Set α} {x : α},
(∀ᶠ (y : α) in nhdsWithin x s, p y) → x ∈ s → p x | true |
CategoryTheory.ShortComplex.isLimitOfIsLimitπ._proof_6 | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (c : CategoryTheory.Limits.Cone F)
(h₂ : CategoryTheory.Limits.IsLimit (CategoryTheory.ShortComplex.π₂.mapCone c))
(h₃ : CategoryTheory.Limits.IsLimit (CategoryTheory.ShortComplex.π₃.mapCone c)) (s : CategoryTheory.Limits.Cone F),
CategoryTheory.CategoryStruct.comp (h₂.lift (CategoryTheory.ShortComplex.π₂.mapCone s)) c.pt.g =
CategoryTheory.CategoryStruct.comp s.pt.g (h₃.lift (CategoryTheory.ShortComplex.π₃.mapCone s)) | false |
GaloisConnection.liftOrderTop._proof_1 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] [inst_2 : PartialOrder β] {u : α → β}
{l : β → α}, GaloisConnection l u → ∀ (x : β), x ≤ u ⊤ | false |
Lean.Parser.syntaxParser.parenthesizer | Lean.Parser.Syntax | optParam ℕ 0 → Lean.PrettyPrinter.Parenthesizer | true |
Filter.EventuallyConst.mul | Mathlib.Order.Filter.EventuallyConst | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [inst : Mul β] {g : α → β},
Filter.EventuallyConst f l → Filter.EventuallyConst g l → Filter.EventuallyConst (f * g) l | true |
LieModuleHom.ker_id | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M], LieModuleHom.id.ker = ⊥ | true |
AlgHom.liftNormal | Mathlib.FieldTheory.Normal.Basic | {F : Type u_1} →
[inst : Field F] →
{K₁ : Type u_3} →
{K₂ : Type u_4} →
[inst_1 : Field K₁] →
[inst_2 : Field K₂] →
[inst_3 : Algebra F K₁] →
[inst_4 : Algebra F K₂] →
(K₁ →ₐ[F] K₂) →
(E : Type u_6) →
[inst_5 : Field E] →
[inst_6 : Algebra F E] →
[inst_7 : Algebra K₁ E] →
[inst_8 : Algebra K₂ E] →
[IsScalarTower F K₁ E] → [IsScalarTower F K₂ E] → [h : Normal F E] → E →ₐ[F] E | true |
toDual_intCast | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : IntCast R] (n : ℤ), OrderDual.toDual ↑n = ↑n | true |
Lean.Expr.getForallBodyMaxDepth | Lean.Expr | ℕ → Lean.Expr → Lean.Expr | true |
CoxeterSystem.map | Mathlib.GroupTheory.Coxeter.Basic | {B : Type u_1} →
{W : Type u_3} →
{H : Type u_4} →
[inst : Group W] → [inst_1 : Group H] → {M : CoxeterMatrix B} → CoxeterSystem M W → W ≃* H → CoxeterSystem M H | true |
_private.Mathlib.Topology.Separation.SeparatedNhds.0.SeparatedNhds.union_left._simp_1_2 | Mathlib.Topology.Separation.SeparatedNhds | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] {a b c : α},
Disjoint (a ⊔ b) c = (Disjoint a c ∧ Disjoint b c) | false |
BitVec.eq_of_getElem_eq_iff | Init.Data.BitVec.Bootstrap | ∀ {n : ℕ} {x y : BitVec n}, x = y ↔ ∀ (i : ℕ) (hi : i < n), x[i] = y[i] | true |
IsLinearSet.exists_fg_eq_subtypeVal | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M},
IsLinearSet s → ∃ P s', P.FG ∧ IsLinearSet s' ∧ s = Subtype.val '' s' | true |
sSup_sub | Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | ∀ {M : Type u_1} [inst : CompleteLattice M] [inst_1 : AddGroup M] [AddLeftMono M] [AddRightMono M] (s t : Set M),
sSup (s - t) = sSup s - sInf t | true |
_private.Init.Data.UInt.Bitwise.0.UInt16.and_eq_neg_one_iff._simp_1_2 | Init.Data.UInt.Bitwise | ∀ {w : ℕ} {x y : BitVec w}, (x &&& y = BitVec.allOnes w) = (x = BitVec.allOnes w ∧ y = BitVec.allOnes w) | false |
InfHom.withTop'._proof_1 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] [inst_2 : OrderTop β]
(f : InfHom α β) (a b : WithTop α), Option.elim (a ⊓ b) ⊤ ⇑f = Option.elim a ⊤ ⇑f ⊓ Option.elim b ⊤ ⇑f | false |
CompleteLat.Iso.mk._proof_1 | Mathlib.Order.Category.CompleteLat | ∀ {α β : CompleteLat} (e : ↑α ≃o ↑β),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ConcreteCategory.ofHom { toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ })
(CategoryTheory.ConcreteCategory.ofHom { toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ }) =
CategoryTheory.CategoryStruct.id α | false |
Batteries.ByteSubarray.start_le_stop | Batteries.Data.ByteSlice | ∀ (self : Batteries.ByteSubarray), self.start ≤ self.stop | true |
Lean.ExceptToTraceResult.mk._flat_ctor | Lean.Util.Trace | {ε α : Type} → (Except ε α → Lean.TraceResult) → Lean.ExceptToTraceResult ε α | false |
Matrix.entryAddMonoidHom._proof_2 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_1} {n : Type u_2} (α : Type u_3) [inst : AddZeroClass α] (i : m) (j : n) (x x_1 : Matrix m n α),
(x + x_1) i j = (x + x_1) i j | false |
_private.Mathlib.Tactic.NormNum.NatFactorial.0.Mathlib.Meta.NormNum.evalNatAscFactorial._proof_1 | Mathlib.Tactic.NormNum.NatFactorial | ∀ {u : Lean.Level} {α : Q(Type u)} (e : Q(«$α»)) (x y : Q(ℕ)), «$e» =Q «$x».ascFactorial «$y» | false |
Complex.abs_re_eq_norm._simp_1 | Mathlib.Analysis.Complex.Norm | ∀ {z : ℂ}, (|z.re| = ‖z‖) = (z.im = 0) | false |
Vector.getElem?_setIfInBounds_self | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {xs : Vector α n} {x : α}, (xs.setIfInBounds i x)[i]? = if i < n then some x else none | true |
Mathlib.Tactic.IntervalCases.Methods.noConfusion | Mathlib.Tactic.IntervalCases | {P : Sort u} →
{t t' : Mathlib.Tactic.IntervalCases.Methods} → t = t' → Mathlib.Tactic.IntervalCases.Methods.noConfusionType P t t' | false |
Finset.sum_sq_le_sq_sum_of_nonneg | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] {f : ι → R}
{s : Finset ι}, (∀ i ∈ s, 0 ≤ f i) → ∑ i ∈ s, f i ^ 2 ≤ (∑ i ∈ s, f i) ^ 2 | true |
«_aux_Mathlib_Order_OrderDual___macroRules_term_ᵒᵈ_1» | Mathlib.Order.OrderDual | Lean.Macro | false |
_private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.lTensorKerIncl | Mathlib.RingTheory.AdicCompletion.AsTensorProduct | {R : Type u} →
[inst : CommRing R] →
(I : Ideal R) →
(M : Type u) →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{ι : Type} →
(f : (ι → R) →ₗ[R] M) →
TensorProduct R (AdicCompletion I R) ↥f.ker →ₗ[AdicCompletion I R]
TensorProduct R (AdicCompletion I R) (ι → R) | true |
HomotopicalAlgebra.FibrantObject.toHoCat | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.Functor (HomotopicalAlgebra.FibrantObject C) (HomotopicalAlgebra.FibrantObject.HoCat C) | true |
AddSubmonoid.coe_neg | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (S : AddSubmonoid G), ↑(-S) = -↑S | true |
GradedMonoid.GOne.mk._flat_ctor | Mathlib.Algebra.GradedMonoid | {ι : Type u_1} → {A : ι → Type u_2} → [inst : Zero ι] → A 0 → GradedMonoid.GOne A | false |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.hasCoeS.match_1 | Mathlib.Tactic.FBinop | (motive : Lean.LOption Lean.Expr → Sort u_1) →
(__do_lift : Lean.LOption Lean.Expr) →
((a : Lean.Expr) → motive (Lean.LOption.some a)) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef) → motive __do_lift | false |
Set.mem_sigma_iff | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {x : (i : ι) × α i},
x ∈ s.sigma t ↔ x.fst ∈ s ∧ x.snd ∈ t x.fst | true |
IsTopologicalGroup.leftUniformSpace.congr_simp | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G],
IsTopologicalGroup.leftUniformSpace G = IsTopologicalGroup.leftUniformSpace G | true |
_private.Mathlib.Data.Nat.Totient.0.Nat.totient_pos._simp_1_1 | Mathlib.Data.Nat.Totient | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a : α}, (0 < a) = (a ≠ 0) | false |
HahnSeries.embDomain_notin_image_support | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
{f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'}, b ∉ ⇑f '' x.support → (HahnSeries.embDomain f x).coeff b = 0 | true |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.Word.equivPairAux._proof_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)] (i : ι),
Monoid.CoprodI.Word.rcons { head := 1, tail := Monoid.CoprodI.Word.empty, fstIdx_ne := ⋯ } = Monoid.CoprodI.Word.empty | false |
_private.Lean.Elab.StructInstHint.0.Lean.Elab.Term.StructInst.FieldsHintView.openingPos | Lean.Elab.StructInstHint | Lean.Elab.Term.StructInst.FieldsHintView✝ → String.Pos.Raw | true |
CategoryTheory.Comma.initial_fst | Mathlib.CategoryTheory.Comma.Final | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) [CategoryTheory.IsCofiltered A] [CategoryTheory.IsCofiltered B] [L.Initial],
(CategoryTheory.Comma.fst L R).Initial | true |
QuasiErgodic.eq_const_of_compQuasiMeasurePreserving_eq | Mathlib.Dynamics.Ergodic.Function | ∀ {α : Type u_1} {X : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace X]
[TopologicalSpace.MetrizableSpace X] [Nonempty X] {f : α → α} (h : QuasiErgodic f μ) {g : α →ₘ[μ] X},
g.compQuasiMeasurePreserving f ⋯ = g → ∃ c, g = MeasureTheory.AEEqFun.const α c | true |
instSemilatticeSupSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_6 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (a b : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }),
b ≤ ⟨((↑a).1 + (↑a).2 * (↑b).1, (↑a).2 * (↑b).2), ⋯⟩ | false |
OrderDual.instLocallyFiniteOrderBot | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrderTop α] → LocallyFiniteOrderBot αᵒᵈ | true |
MeasureTheory.prob_compl_eq_zero_iff₀ | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
[MeasureTheory.IsProbabilityMeasure μ], MeasureTheory.NullMeasurableSet s μ → (μ sᶜ = 0 ↔ μ s = 1) | true |
_private.Mathlib.Logic.Function.Iterate.0.Function.iterate_invariant.match_1_1 | Mathlib.Logic.Function.Iterate | ∀ (motive : ℕ → Prop) (n : ℕ), (∀ (a : Unit), motive 0) → (∀ (m : ℕ), motive m.succ) → motive n | false |
CategoryTheory.Limits.coneUnopOfCoconeEquiv_inverse_map | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ} {x x_1 : CategoryTheory.Limits.Cone F.unop} (f : x ⟶ x_1),
CategoryTheory.Limits.coneUnopOfCoconeEquiv.inverse.map f = Opposite.op { hom := f.hom.op, w := ⋯ } | true |
CategoryTheory.Limits.image.lift_mk_factorThruImage | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasImage f],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.image.lift
{ I := CategoryTheory.Limits.image f, m := CategoryTheory.Limits.image.ι f, m_mono := ⋯,
e := CategoryTheory.Limits.factorThruImage f, fac := ⋯ })
(CategoryTheory.Limits.image.ι f) =
CategoryTheory.Limits.image.ι f | true |
IsPrimitiveRoot.one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M], IsPrimitiveRoot 1 1 | true |
sign_eq_sign_or_eq_neg | Mathlib.Data.Sign.Defs | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] {a b : α},
a ≠ 0 → b ≠ 0 → SignType.sign a = SignType.sign b ∨ SignType.sign a = -SignType.sign b | true |
Mathlib.Tactic.LibraryRewrite.rpc | Mathlib.Tactic.Widget.LibraryRewrite | SelectInsertParams → Lean.Server.RequestM (Lean.Server.RequestTask ProofWidgets.Html) | true |
_private.Lean.Meta.CtorIdxHInj.0.Lean.Meta.initFn.match_1._@.Lean.Meta.CtorIdxHInj.1686831688._hygCtx._hyg.2 | Lean.Meta.CtorIdxHInj | (motive : Option Lean.InductiveVal → Sort u_1) →
(x : Option Lean.InductiveVal) →
((indVal : Lean.InductiveVal) → motive (some indVal)) → ((x : Option Lean.InductiveVal) → motive x) → motive x | false |
Module.DirectLimit.exists_of | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] {G : ι → Type u_3}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] [Nonempty ι] [IsDirectedOrder ι] (z : Module.DirectLimit G f),
∃ i x, (Module.DirectLimit.of R ι G f i) x = z | true |
Submodule.liftQSpanSingleton._proof_1 | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module 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₂} (x : M)
(f : M →ₛₗ[τ₁₂] M₂), f x = 0 → R ∙ x ≤ f.ker | false |
Balanced.smul_eq | Mathlib.Analysis.LocallyConvex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedDivisionRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{s : Set E} {a : 𝕜}, Balanced 𝕜 s → ‖a‖ = 1 → a • s = s | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.