name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.AEDisjoint.iUnion_right_iff | Mathlib.MeasureTheory.Measure.AEDisjoint | ∀ {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {ι : Sort u_3} [Countable ι]
{t : ι → Set α}, MeasureTheory.AEDisjoint μ s (⋃ i, t i) ↔ ∀ (i : ι), MeasureTheory.AEDisjoint μ s (t i) | null | true |
Matrix.fromRows_mulVec | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} [inst : Semiring R] [inst_1 : Fintype n]
(A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R) (v : n → R),
(A₁.fromRows A₂).mulVec v = Sum.elim (A₁.mulVec v) (A₂.mulVec v) | null | true |
_private.Aesop.Search.RuleSelection.0.Aesop.selectUnsafeRules.match_1 | Aesop.Search.RuleSelection | (motive : Option Aesop.UnsafeQueue → Sort u_1) →
(x : Option Aesop.UnsafeQueue) → ((rules : Aesop.UnsafeQueue) → motive (some rules)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.pair_injective._simp_1_5 | Mathlib.SetTheory.ZFC.Basic | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
le_of_mul_le_of_one_le | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ZeroLEOneClass R] [NeZero 1] [MulPosStrictMono R]
[PosMulMono R] {a b c : R}, a * c ≤ b → 0 ≤ b → 1 ≤ c → a ≤ b | null | true |
Subring.instField._proof_5 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] (q : ℚ), ↑q = ↑q.num / ↑q.den | null | false |
_private.Mathlib.Algebra.Group.Monoid.0.npowRec.match_1.eq_1 | Mathlib.Algebra.Group.Monoid | ∀ {M : Type u_2} (motive : ℕ → M → Sort u_1) (x : M) (h_1 : (x : M) → motive 0 x)
(h_2 : (n : ℕ) → (a : M) → motive n.succ a),
(match 0, x with
| 0, x => h_1 x
| n.succ, a => h_2 n a) =
h_1 x | null | true |
Std.Time.Month.instToStringOffset | Std.Time.Date.Unit.Month | ToString Std.Time.Month.Offset | null | true |
UpperSet.instCompleteLinearOrder._proof_9 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : UpperSet α), compare a b = compareOfLessAndEq a b | null | false |
Lean.Compiler.LCNF.Arg._sizeOf_inst | Lean.Compiler.LCNF.Basic | (pu : Lean.Compiler.LCNF.Purity) → SizeOf (Lean.Compiler.LCNF.Arg pu) | null | false |
_private.Lean.DocString.Syntax.0.Lean.Doc.Syntax.para._regBuiltin.Lean.Doc.Syntax.para.docString_1 | Lean.DocString.Syntax | IO Unit | null | false |
CategoryTheory.cokernelOpUnop._proof_6 | Mathlib.CategoryTheory.Abelian.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C}
(f : X ⟶ Y), CategoryTheory.Limits.HasKernel f | null | false |
Std.ExtHashMap.getKeyD_inter_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k fallback : α}, k ∉ m₁ → (m₁ ∩ m₂).getKeyD k fallback = fallback | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Mon.0.CategoryTheory.Functor.FullyFaithful.monObj._simp_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {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) [self : F.OplaxMonoidal] {X Y : C} (X' : C) (f : X ⟶ Y) {Z : D}
(h : Ca... | null | false |
IsScalarTower.Invertible.algebraTower._proof_1 | Mathlib.RingTheory.AlgebraTower | ∀ (S : Type u_1) (A : Type u_2) [inst : CommSemiring S] [inst_1 : Semiring A], MonoidHomClass (S →+* A) S A | null | false |
groupHomology.δ₀_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)}
(hX : X.ShortExact) (z : ↥(groupHomology.cycles₁ X.X₃)) (y : G →₀ ↑X.X₂),
(Finsupp.mapRange.linearMap (Rep.Hom.hom X.g).toLinearMap) y = ↑z →
∀ (x : ↑X.X₁),
(Rep.Hom.hom X.f) x = (CategoryTheory.C... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.CycleGraph.0.SimpleGraph.cycleGraph_degree_three_le._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.CycleGraph | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) | null | false |
InformationTheory.not_differentiableAt_klFun_zero | Mathlib.InformationTheory.KullbackLeibler.KLFun | ¬DifferentiableAt ℝ InformationTheory.klFun 0 | null | true |
Set.Ioc.orderTop._proof_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} [Fact (b < a)], IsGreatest (Set.Ioc b a) a | null | false |
String.Slice.Pattern.ForwardSliceSearcher.startsWith_of_isEmpty | Init.Data.String.Lemmas.Pattern.String.ForwardPattern | ∀ {pat s : String.Slice}, pat.isEmpty = true → String.Slice.Pattern.ForwardPattern.startsWith pat s = true | null | true |
eVariationOn.comp_eq_of_antitoneOn | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : TopologicalSpace E] [inst_2 : WeakPseudoEMetricSpace E]
{β : Type u_4} [inst_3 : LinearOrder β] (f : α → E) {t : Set β} (φ : β → α),
AntitoneOn φ t → eVariationOn (f ∘ φ) t = eVariationOn f (φ '' t) | null | true |
Multiset.countP_cons_of_neg | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} (s : Multiset α),
¬p a → Multiset.countP p (a ::ₘ s) = Multiset.countP p s | null | true |
Inclusion.HypothesisM.Context.mk.sizeOf_spec | Mathlib.Tactic.Inclusion.Core.Types | ∀ (toContext : Inclusion.InclusionM.Context) (iVarsMap : Lean.ExprMap Inclusion.IVar) (iVars : Array Inclusion.IVar),
sizeOf { toContext := toContext, iVarsMap := iVarsMap, iVars := iVars } =
1 + sizeOf toContext + sizeOf iVarsMap + sizeOf iVars | null | true |
Std.ExtHashMap.erase_eq_empty_iff._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (m.erase k = ∅) = (m = ∅ ∨ m.size = 1 ∧ k ∈ m) | null | false |
Function.funext_iff_of_subsingleton | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} [Subsingleton α] {g : α → β} (x y : α), f x = g y ↔ f = g | null | true |
Filter.tendsto_snd | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, Filter.Tendsto Prod.snd (f ×ˢ g) g | null | true |
Std.DTreeMap.Raw.inter | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} → Std.DTreeMap.Raw α β cmp → Std.DTreeMap.Raw α β cmp → Std.DTreeMap.Raw α β cmp | Computes the intersection of the given tree maps. The result will only contain entries from the first map.
This function always merges the smaller map into the larger map.
| true |
instCircularOrderZMod._proof_6 | Mathlib.Order.Circular.ZMod | ∀ {a b c : ZMod 0}, btw a b c → btw b c a | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.maxKey?_modify_eq_maxKey?._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Lean.Server.References.casesOn | Lean.Server.References | {motive : Lean.Server.References → Sort u} →
(t : Lean.Server.References) →
((ileans : Lean.Server.ILeanMap) →
(workers : Lean.Server.WorkerRefMap) → motive { ileans := ileans, workers := workers }) →
motive t | null | false |
OnePoint.isOpen_range_coe | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], IsOpen (Set.range OnePoint.some) | null | true |
Aesop.elabGlobalRuleIdent | Aesop.Builder.Basic | Aesop.BuilderName → Lean.Term → Lean.Elab.TermElabM Lean.Name | null | true |
Ordinal.partialOrder.match_15 | Mathlib.SetTheory.Ordinal.Basic | ∀ (x x_1 : WellOrder)
(motive :
⟦x⟧.liftOn₂ ⟦x_1⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯ ∧
¬⟦x_1⟧.liftOn₂ ⟦x⟧
(fun x x_2... | null | false |
pow_lt_pow_iff_right_of_lt_one₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀],
0 < a → a < 1 → (a ^ m < a ^ n ↔ n < m) | null | true |
CategoryTheory.Limits.Multicofork.IsColimit.isPushout.multicofork | Mathlib.CategoryTheory.Limits.Shapes.MultiequalizerPullback | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : CategoryTheory.Limits.MultispanShape} →
[inst_1 : Unique J.L] →
{I : CategoryTheory.Limits.MultispanIndex J C} →
{J.fst default, J.snd default} = Set.univ →
J.fst default ≠ J.snd default →
Categ... | Given a multispan shape `J` which is essentially `.ofLinearOrder ι`
(where `ι` has exactly two elements), this is the multicofork
deduced from a pushout cocone. | true |
ByteArray.beq | Init.Data.ByteArray.Basic | ByteArray → ByteArray → Bool | null | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkChainResult.go | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic →
Array (Array (Lean.TSyntax `tactic)) →
ℕ →
List (Lean.TSyntax `tactic) →
Option Lean.SyntaxNodeKind → StateT (Array (Lean.TSyntax `tactic)) Lean.Elab.Tactic.Try.TryTacticM Unit | null | true |
CochainComplex.mappingCone.shiftTrianglehIso | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
{K L : CochainComplex C ℤ} →
(φ : K ⟶ L) →
(n : ℤ) →
(CategoryTheory.Pretriangulated.Triangle.shiftF... | The canonical isomorphism `(triangleh φ)⟦n⟧ ≅ triangleh (φ⟦n⟧')`. | true |
_private.Batteries.Data.Fin.Coding.0.Fin.encodeProd.match_1.splitter | Batteries.Data.Fin.Coding | {m n : ℕ} →
(motive : Fin m × Fin n → Sort u_1) → (x : Fin m × Fin n) → ((i : Fin m) → (j : Fin n) → motive (i, j)) → motive x | null | true |
CategoryTheory.Arrow.mapCechConerve._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.Arrow C}
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout g.left (fun x => g.right) fun x => g.hom] (F : f ⟶ g)
(n : SimplexCategory) (i : Fin (n.len + 1)),
CategoryTheory.CategoryStruct.comp f.hom
(CategoryTheory.... | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.prod_Iic_div._proof_1_8 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} (a_1 : ℕ), a_1 + 1 ≤ n → a_1 < n.succ | null | false |
NonUnitalNonAssocSemiring.directSumGNonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.DirectSum.Ring | ∀ (ι : Type u_2) {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {i j : ι} (a b c : R), (a + b) * c = a * c + b * c | null | false |
Aesop.Index.mk.injEq | Aesop.Index | ∀ {α : Type} (byTarget byHyp : Lean.Meta.DiscrTree (Aesop.Rule α)) (unindexed : Lean.PHashSet (Aesop.Rule α))
(byTarget_1 byHyp_1 : Lean.Meta.DiscrTree (Aesop.Rule α)) (unindexed_1 : Lean.PHashSet (Aesop.Rule α)),
({ byTarget := byTarget, byHyp := byHyp, unindexed := unindexed } =
{ byTarget := byTarget_1, by... | null | true |
Lean.Meta.Grind.GoalState.newRawFacts | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalState → Std.Queue Lean.Meta.Grind.NewRawFact | new facts to be preprocessed and then asserted. | true |
HomotopicalAlgebra.Cylinder.instCofibrationI₁ | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.Cylinder A)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct A A] [inst_3 : HomotopicalAlgebra.CategoryWithCofibrations C]
[inst_4 : CategoryTheory.Limits.HasInit... | null | true |
BoxIntegral.Box.lower_lt_upper._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_2} (self : BoxIntegral.Box ι) (i : ι), (self.lower i < self.upper i) = True | null | false |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_10 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
_private.Mathlib.CategoryTheory.Galois.Prorepresentability.0.CategoryTheory.PreGaloisCategory.PointedGaloisObject.instIsCofilteredOrEmpty.match_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (motive : CategoryTheory.PreGaloisCategory.PointedGaloisObject F → Prop)
(x : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(∀ (B : C) (b : (F.obj B).obj) ... | null | false |
Lean.Elab.Do.DoOps.toDoOpsRefImpl | Lean.Elab.Do.Basic | Lean.Elab.Do.DoOps → Lean.Elab.Do.DoOpsRef | null | true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.ae_withDensity_iff_ae_restrict'._simp_1_2 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {a b : Prop}, (a = b) = (a ↔ b) | null | false |
_private.Mathlib.Data.List.Cycle.0.Cycle.next_reverse_eq_prev._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Cycle α) (hs : s.Nodup) (x : α) (hx : x ∈ s),
s.next hs x hx = s.reverse.prev ⋯ x ⋯ | null | false |
CategoryTheory.monoidalUnopUnop._proof_14 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᵒᵖᵒᵖ} (X' : Cᵒᵖᵒᵖ) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X' ... | null | false |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.wrapped._proof_1._@.Mathlib.Analysis.InnerProductSpace.TwoDim.1773570744._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | @Orientation.definition✝ = @Orientation.definition✝ | null | false |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort.match_1.eq_2 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a : α) (x : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match [a], x with
| [], x => h_1 x
| [... | null | true |
CommSemiRingCat.forget₂SemiRing_preservesLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | ∀ [UnivLE.{v, u}],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1}
(CategoryTheory.forget₂ CommSemiRingCat SemiRingCat) | The forgetful functor from rings to semirings preserves all limits.
| true |
Topology.CWComplex.OfDiscreteClosed_map | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {D : Set X} (hD : IsDiscrete D) (Dc : IsClosed D) (n : ℕ)
(i :
match n with
| 0 => ↑D
| n.succ => PEmpty.{u_1 + 1}),
Topology.CWComplex.map n i =
match n, i with
| 0, i => PartialEquiv.single ![] ↑i
| n.succ, i => PEmpty.elim i | null | true |
TrivSqZeroExt.instL1NormedRing._proof_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : NormedRing R] [inst_1 : NormedAddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [inst_4 : IsBoundedSMul R M] [inst_5 : IsBoundedSMul Rᵐᵒᵖ M]
[inst_6 : SMulCommClass R Rᵐᵒᵖ M] {x y : TrivSqZeroExt R M}, dist x y = 0 → x = y | null | false |
_private.Init.Data.Array.Range.0.Array.mem_zipIdx._proof_1 | Init.Data.Array.Range | ∀ {α : Type u_1} {x : α} {i : ℕ} {xs : Array α} {k : ℕ},
k ≤ (x, i).2 → (x, i).2 < k + xs.size → ¬i - k < xs.size → False | null | false |
HomogeneousIdeal.instMax._proof_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), Ideal.IsHomogeneous 𝒜 (I.toIdeal ⊔ J.toIdeal) | null | false |
SimpleGraph.induceHomOfLE | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → (G : SimpleGraph V) → {s s' : Set V} → s ⊆ s' → SimpleGraph.induce s G ↪g SimpleGraph.induce s' G | Given an inclusion of vertex subsets, the induced embedding on induced graphs.
This is not an abbreviation for `induceHom` since we get an embedding in this case. | true |
Monoid.CoprodI.Word.rcons_eq_smul | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] {i : ι} (p : Monoid.CoprodI.Word.Pair M i),
Monoid.CoprodI.Word.rcons p = Monoid.CoprodI.of p.head • p.tail | null | true |
AlgEquiv.isTranscendenceBasis | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {A' : Type v'} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : CommRing A'] [inst_3 : Algebra R A] [inst_4 : Algebra R A'] (e : A ≃ₐ[R] A'),
IsTranscendenceBasis R x → IsTranscendenceBasis R (⇑e ∘ x) | Also see `IsTranscendenceBasis.algebraMap_comp`
for the composition with an algebraic extension. | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.instIsIsoInvApp | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Y)
[H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (U : TopologicalSpace.Opens ↑↑X),
CategoryTheory.IsIso (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp f U) | null | true |
Std.TreeMap.getKeyD_eq_fallback | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α},
a ∉ t → t.getKeyD a fallback = fallback | null | true |
BoxIntegral.Box.coe_subset_coe._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, (↑I ⊆ ↑J) = (I ≤ J) | null | false |
OrderTopology.t5Space | Mathlib.Topology.Order.T5 | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X], T5Space X | null | true |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
(X Y Z : P.FullSubcategory),
P
(CategoryTheory.MonoidalCategoryStru... | null | false |
Std.DHashMap.Internal.Raw₀.contains_insertMany_list | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF →
∀ {l : List ((a : α) × β a)} {k : α},
(↑(m.insertMany l)).contains k = (m.contains k || (List.map Sigma.fst l).contains k) | null | true |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.lowerResultType.resultTypeForArity._sparseCasesOn_2 | Lean.Compiler.LCNF.ToImpure | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
ImportGraph.WorkspaceModel.pkgIdxOfLibIdx! | ImportGraph.WorkspaceModel.Model | ImportGraph.WorkspaceModel → ImportGraph.LibIdx → ImportGraph.PkgIdx | null | true |
_private.Lean.Server.Rpc.RequestHandling.0.Lean.Server.wrapRpcProcedure.match_1 | Lean.Server.Rpc.RequestHandling | (respType : Type) →
(motive : Except Lean.Server.RequestError respType → Sort u_1) →
(x : Except Lean.Server.RequestError respType) →
((e : Lean.Server.RequestError) → motive (Except.error e)) →
((ret : respType) → motive (Except.ok ret)) → motive x | null | false |
convexHullAddMonoidHom | Mathlib.Analysis.Convex.Combination | (R : Type u_1) →
(E : Type u_3) →
[inst : Field R] →
[inst_1 : AddCommGroup E] → [Module R E] → [inst_3 : LinearOrder R] → [IsStrictOrderedRing R] → Set E →+ Set E | `convexHull` is an additive monoid morphism under pointwise addition. | true |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.instMulActionLeftTransversal._simp_1 | Mathlib.GroupTheory.Complement | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
instRingUniversalEnvelopingAlgebra._aux_8 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → ℕ → UniversalEnvelopingAlgebra R L → UniversalEnvelopingAlgebra R L | null | false |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.e | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → Lean.Expr | The underlying expression of the variable. | true |
HomotopicalAlgebra.instIsStableUnderBaseChangeFibrations | Mathlib.AlgebraicTopology.ModelCategory.Instances | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
[(HomotopicalAlgebra.trivialCofibrations C).IsWeakFactorizationSystem (HomotopicalAlge... | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.getElem?_toList_eq.match_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} (motive : Option α → Prop) (x : Option α),
(x = none → motive none) → (∀ (next : α), x = some next → motive (some next)) → motive x | null | false |
CategoryTheory.Idempotents.Karoubi.decompId_p._proof_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp { X := P.X, p := CategoryTheory.CategoryStruct.id P.X, idem := ⋯ }.p
(CategoryTheory.CategoryStruct.comp P.p P.p) =
P.p | null | false |
Std.DTreeMap.Internal.Impl.get!_eq_getValueCast! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [instBEq : BEq α] [inst : Ord α] [inst_1 : Std.LawfulBEqOrd α] [Std.TransOrd α]
[inst_3 : Std.LawfulEqOrd α] {k : α} [inst_4 : Inhabited (β k)] {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get! k = Std.Internal.List.getValueCast! k t.toListModel | null | true |
CantorBendixson.mem_fixedPoints_of_iteratedDerivedSet_succ_eq | Mathlib.Topology.CantorBendixson | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} {a : Ordinal.{u}},
CantorBendixson.iteratedDerivedSet s (a + 1) = CantorBendixson.iteratedDerivedSet s a →
CantorBendixson.iteratedDerivedSet s a ∈ Function.fixedPoints ⇑relDerivedSet | If the iterated derived set stops changing at a successor stage, then `sᵈ[a]` is a fixed
point of `relDerivSet`. | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.sheafedSpace_pullback_fst_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
AlgebraicGeometry.SheafedSpace.IsOpenImmersion (CategoryTheory.Limits.pullback.fst g f) | null | true |
CategoryTheory.FreeBicategory.comp_def | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.FreeBicategory.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g | null | true |
Pi.smulZeroClass | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
(α : Type u_1) → {n : (i : I) → Zero (f i)} → [(i : I) → SMulZeroClass α (f i)] → SMulZeroClass α ((i : I) → f i) | null | true |
Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit_emptyWithCapacity_list_cons | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {hd : α} {tl : List α},
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit Std.DHashMap.Internal.Raw₀.emptyWithCapacity (hd :: tl)) =
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit
(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertIfNew hd ... | null | true |
Fin.partialProd_contractNth | Mathlib.Algebra.BigOperators.Fin | ∀ {G : Type u_3} [inst : Monoid G] {n : ℕ} (g : Fin (n + 1) → G) (a : Fin (n + 1)),
Fin.partialProd (a.contractNth (fun x1 x2 => x1 * x2) g) = Fin.partialProd g ∘ a.succ.succAbove | null | true |
uniqueMDiffWithinAt_iff_uniqueDiffWithinAt | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E}, UniqueMDiffAt[s] x ↔ UniqueDiffWithinAt 𝕜 s x | null | true |
Topology.WithLawson.isOpen_preimage_ofLawson | Mathlib.Topology.Order.LawsonTopology | ∀ {α : Type u_1} [inst : Preorder α] {S : Set α},
IsOpen (⇑Topology.WithLawson.ofLawson ⁻¹' S) ↔ TopologicalSpace.IsOpen S | null | true |
«term{}» | Init.Core | Lean.ParserDescr | `∅` or `{}` is the empty set or empty collection.
It is supported by the `EmptyCollection` typeclass.
Conventions for notations in identifiers:
* The recommended spelling of `{}` in identifiers is `empty`. | true |
_private.Mathlib.Combinatorics.Additive.Corner.Roth.0.corners_theorem_nat._proof_1_13 | Mathlib.Combinatorics.Additive.Corner.Roth | ∀ {n : ℕ} {ε : ℝ}, cornersTheoremBound (ε / 9) ≤ n → cornersTheoremBound (ε / 9) ≤ 2 * n + 1 | null | false |
MvPowerSeries.isEmptyEquiv._proof_1 | Mathlib.RingTheory.MvPowerSeries.Equiv | ∀ (σ : Type u_1) (R : Type u_2) [inst : CommSemiring R] [IsEmpty σ] (x : MvPowerSeries σ R),
MvPowerSeries.C ((↑↑MvPowerSeries.constantCoeff).toFun x) = x | null | false |
_private.Lean.Compiler.LCNF.SplitSCC.0.Lean.Compiler.LCNF.SplitScc.findSccCalls.goCode.match_1 | Lean.Compiler.LCNF.SplitSCC | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.LetValue pu → Sort u_1) →
(x : Lean.Compiler.LCNF.LetValue pu) →
((name : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) → motive ... | null | false |
Polynomial.derivation_ext | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Module (Polynomial R) A] {D₁ D₂ : Derivation R (Polynomial R) A},
D₁ Polynomial.X = D₂ Polynomial.X → D₁ = D₂ | null | true |
CommGroup.mem_primaryComponent_iff_orderOf | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : CommGroup G] {p : ℕ} [Fact (Nat.Prime p)] {g : G},
g ∈ CommGroup.primaryComponent G p ↔ ∃ n, orderOf g = p ^ n | For prime `p`, `g` lies in the `p`-primary component iff its order is a power of `p`. | true |
WType.Listα.nil.elim | Mathlib.Data.W.Constructions | {γ : Type u} →
{motive : WType.Listα γ → Sort u_1} → (t : WType.Listα γ) → t.ctorIdx = 0 → motive WType.Listα.nil → motive t | null | false |
SSet.Truncated.Edge.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {X : SSet.Truncated 2} →
{x₀ x₁ : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge._proof_1 })} →
{motive : SSet.Truncated.Edge x₀ x₁ → Sort u_1} →
((edge : X.obj (Opposite.op { obj := { len := 1 }, property := SSet.Truncated.Edge._proof_2 })) →
(src_eq :
(Ca... | null | false |
AbsoluteValue.LiesOver.casesOn | Mathlib.Analysis.Normed.Ring.WithAbs | {L : Type u_3} →
{K : Type u_4} →
{S : Type u_5} →
[inst : CommSemiring K] →
[inst_1 : Semiring L] →
[inst_2 : Algebra K L] →
[inst_3 : FaithfulSMul K L] →
[inst_4 : PartialOrder S] →
[inst_5 : Semiring S] →
{w : AbsoluteValue L S... | null | false |
differentiableAt_const._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {x : E} (c : F), DifferentiableAt 𝕜 (fun x => c) x = True | null | false |
AddSemigrp.hom_comp | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y T : AddSemigrp} (f : X ⟶ Y) (g : Y ⟶ T),
AddSemigrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (AddSemigrp.Hom.hom g).comp (AddSemigrp.Hom.hom f) | null | true |
Matrix.IsDiag.submatrix | Mathlib.LinearAlgebra.Matrix.IsDiag | ∀ {α : Type u_1} {n : Type u_4} {m : Type u_5} [inst : Zero α] {A : Matrix n n α},
A.IsDiag → ∀ {f : m → n}, Function.Injective f → (A.submatrix f f).IsDiag | null | true |
PMF.toMeasure_inj._simp_1 | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {p q : PMF α},
(p.toMeasure = q.toMeasure) = (p = q) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.