name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.isBigO_image_sub_image_sub_deriv_principal._simp_1_4 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
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 |
NonUnitalStarAlgHom.codRestrict._proof_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {F : Type u_4} {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R]
[inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : Module R B] [inst_6 : Star B] [inst_7 : FunLike F A B] [inst_8 : NonUnitalAlgHomClass F R A B]
[Star... | null | false |
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 |
BitVec.ofNat_sub_ofNat_of_le | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : ℕ), y < 2 ^ w → y ≤ x → BitVec.ofNat w x - BitVec.ofNat w y = BitVec.ofNat w (x - y) | null | true |
Algebra.mem_adjoin_of_map_mul | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {s : Set A} {x : A} {f : A →ₗ[R] B},
(∀ (a₁ a₂ : A), f (a₁ * a₂) = f a₁ * f a₂) → x ∈ Algebra.adjoin R s → f x ∈ Algebra.adjoin R (⇑f '' (s ∪ {1})) | 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 |
Lean.Parser.Term.elabToSyntax.formatter | Lean.Elab.Term.TermElabM | Lean.PrettyPrinter.Formatter | null | true |
_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 |
SaturatedSubmonoid.instSetLike | Mathlib.Algebra.Group.Submonoid.Saturation | (M : Type u_1) → [inst : MulOneClass M] → SetLike (SaturatedSubmonoid M) M | null | true |
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 |
ContinuousMap.HomotopyWith.instFunLike | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} → {P : C(X, Y) → Prop} → FunLike (f₀.HomotopyWith f₁ P) (↑unitInterval × X) Y | null | true |
Std.Time.Month.instToStringOffset | Std.Time.Date.Unit.Month | ToString Std.Time.Month.Offset | null | true |
Matrix.replicateCol_zero | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {α : Type v} {ι : Type u_6} [inst : Zero α], Matrix.replicateCol ι 0 = 0 | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith.disjoint_iff_ne._simp_1_6 | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
FirstOrder.Language.Hom.homClass | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N],
L.HomClass (L.Hom M N) M N | null | true |
MonCat.Colimits.monoidColimitType._proof_1 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat)
(x : MonCat.Colimits.ColimitType F), npowRecAuto 0 x = 1 | null | false |
Thunk.fn | Init.Core | {α : Type u} → Thunk α → Unit → α | Extract the getter function out of a thunk. Use `Thunk.get` instead. | 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 |
_private.Mathlib.Combinatorics.Derangements.Finite.0.card_derangements_fin_eq_numDerangements._proof_1_1 | Mathlib.Combinatorics.Derangements.Finite | ∀ (n : ℕ), n + 1 < n + 1 + 1 | 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 |
InformationTheory.not_differentiableAt_klFun_zero | Mathlib.InformationTheory.KullbackLeibler.KLFun | ¬DifferentiableAt ℝ InformationTheory.klFun 0 | null | true |
PFunctor.W | Mathlib.Data.PFunctor.Univariate.Basic | PFunctor.{uA, uB} → Type (max uA uB) | Re-export existing definition of W-types and adapt it to a packaged definition of polynomial
functor. | true |
Set.Ioc.orderTop._proof_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} [Fact (a < b)], IsGreatest (Set.Ioc a b) b | null | false |
_private.Mathlib.Topology.Filter.0.Filter.sInter_nhds._simp_1_1 | Mathlib.Topology.Filter | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | null | false |
CategoryTheory.LocalizerMorphism.LeftResolution.Hom.ext_iff | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C₁}
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{L L' : Φ.LeftResolution X₂} {x y : L.Hom L'}... | null | true |
BooleanRing.mul_one_add_self | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a : α), a * (1 + a) = 0 | null | true |
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 : PseudoEMetricSpace E] {β : Type u_3}
[inst_2 : 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 |
CategoryTheory.Abelian.SpectralObject.EIsoH_hom_naturality._auto_5 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
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 |
CategoryTheory.ComposableArrows.fourδ₃Toδ₂._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₂₃ : i₁ ⟶ i₃) (f₃₄ : i₂ ⟶ i₄),
CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃ →
CategoryTheory.CategoryStruct.comp f₃ f₄ = f₃₄ →
CategoryTheory.CategoryStruct.c... | null | false |
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 |
SimpleGraph.Walk.head_support._proof_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {a b : V} (p : G.Walk a b), p.support ≠ [] | null | false |
CategoryTheory.SimplicialObject.Splitting.toNondegComplex_fromNondegComplex_assoc | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C] {Z : ChainComplex C ℕ}
(h : AlgebraicTopology.AlternatingFaceMapComplex.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp s.toNondegComplex (CategoryTheory.... | null | true |
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 |
CategoryTheory.Functor.Monoidal.toUnit_ε | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X : C),
CategoryTheory.Categor... | null | true |
Filter.rcomap'_sets | Mathlib.Order.Filter.Partial | ∀ {α : Type u} {β : Type v} (r : SetRel α β) (f : Filter β),
(Filter.rcomap' r f).sets = SetRel.image {(s, t) | r.preimage s ⊆ t} f.sets | 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 |
Set.image2_iInter_subset_right | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_5} (f : α → β → γ) (s : Set α) (t : ι → Set β),
Set.image2 f s (⋂ i, t i) ⊆ ⋂ i, Set.image2 f s (t i) | 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 |
AddMonoidHom.mulRight₃._proof_2 | Mathlib.Algebra.Ring.Associator | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (x y : R),
AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft (x + y)) =
AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft x) + AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft y) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_32 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p₁ : G.Walk u v},
¬p₁.Nil → ∀ (i : ℕ), i = p₁.length → i - 1 < p₁.support.tail.length | null | false |
SimpleGraph.Walk.getVert_comp_val_eq_get_support | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.getVert ∘ Fin.val = p.support.get | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.caching | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | {α : Type u_1} → α → Lean.Meta.Grind.Arith.CommRing.ProofM Lean.Expr → Lean.Meta.Grind.Arith.CommRing.ProofM Lean.Expr | null | true |
UniformSpace.Completion.isDenseInducing_coe | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α], IsDenseInducing UniformSpace.Completion.coe' | null | true |
ByteArray.beq | Init.Data.ByteArray.Basic | ByteArray → ByteArray → Bool | null | true |
CategoryTheory.Functor.instLaxMonoidalMonMapAddMon._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.BraidedCategory C]
[inst_5 : CategoryThe... | null | false |
instFinitePresentationForall | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : Ring R] {ι : Type u_2} [Finite ι], Module.FinitePresentation R (ι → R) | null | true |
AffineIsometry.norm_map | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : Pseudo... | 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 |
IsLocalization.tensorProductEquivOfMapIncludeRight._proof_9 | Mathlib.RingTheory.Localization.BaseChange | ∀ (R : Type u_4) (S : Type u_1) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {A : Type u_2}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] (B : Type u_3) [inst_5 : CommSemiring B] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : IsScalarTower R A B], IsScalarTower S (TensorProdu... | null | false |
Finset.instGradeMinOrder_nat | Mathlib.Data.Finset.Grade | {α : Type u_1} → GradeMinOrder ℕ (Finset α) | null | true |
ZeroAtInftyContinuousMap.instFunLike | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : Zero β] → FunLike (ZeroAtInftyContinuousMap α β) α β | null | 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 |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.dvdTight.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c₁ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) (c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.dvdTight c₁ c₂) = 1 + sizeOf c₁ + sizeOf c₂ | null | true |
ValuationRing.commGroupWithZero._proof_9 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_1) [inst : CommRing A] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra A K]
(a b : ValuationRing.ValueGroup A K), a / b = a * b⁻¹ | null | false |
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 |
HOrElse.ctorIdx | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → HOrElse α β γ → ℕ | null | false |
AddCon.comap_eq | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {c : AddCon M} {f : N →+ M},
AddCon.comap ⇑f ⋯ c = AddCon.ker (c.mk'.comp f) | Given an `AddMonoid` homomorphism `f : N → M` and an additive congruence relation
`c` on `M`, the additive congruence relation induced on `N` by `f` equals the kernel of `c`'s
quotient homomorphism composed with `f`. | true |
Lean.Elab.Structural.RecArgCandidates.noConfusionType | Lean.Elab.PreDefinition.Structural.FindRecArg | Sort u → Lean.Elab.Structural.RecArgCandidates → Lean.Elab.Structural.RecArgCandidates → Sort u | null | false |
Finmap.insert | Mathlib.Data.Finmap | {α : Type u} → {β : α → Type v} → [DecidableEq α] → (a : α) → β a → Finmap β → Finmap β | Insert a key-value pair into a finite map, replacing any existing pair with
the same key. | true |
_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 |
Polynomial.fourierCoeff_toAddCircle | Mathlib.Analysis.Polynomial.Fourier | ∀ (p : Polynomial ℂ) (n : ℤ), fourierCoeff (⇑(Polynomial.toAddCircle p)) n = if 0 ≤ n then p.coeff n.natAbs else 0 | The `n`th Fourier coefficient of a polynomial is the coefficient of `X ^ n`, or
zero if `n < 0`. | true |
Std.Internal.List.Const.getValueD_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {fallback : β} {f : α → β → Bool} {l : List ((_ : α) × β)},
Std.Internal.List.DistinctKeys l →
∀ {k : α},
Std.Internal.List.getValueD k (List.filter (fun p => f p.fst p.snd) l) fallback =
((Std.Internal.List.getValue? k l).pfilter fun v h => f ... | null | true |
Lean.Meta.Sym.Simp.SymSimpVariantEntry.ctorIdx | Lean.Meta.Sym.Simp.Variant | Lean.Meta.Sym.Simp.SymSimpVariantEntry → ℕ | null | false |
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 |
Matrix.nondegenerate_iff_det_ne_zero | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {n : Type u_1} [inst : Fintype n] {A : Type u_4} [inst_1 : DecidableEq n] [inst_2 : CommRing A] [IsDomain A]
{M : Matrix n n A}, M.Nondegenerate ↔ M.det ≠ 0 | null | true |
_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 |
AlgebraicGeometry.StructureSheaf.const_mul | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R A : Type u} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] (f₁ f₂ : A) (g₁ g₂ : R)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (hu₁ : U ≤ PrimeSpectrum.basicOpen g₁)
(hu₂ : U ≤ PrimeSpectrum.basicOpen g₂),
AlgebraicGeometry.StructureSheaf.const f₁ g₁ U hu₁ * Algebr... | null | true |
IsCoercive.continuousLinearEquivOfBilin | Mathlib.Analysis.InnerProductSpace.LaxMilgram | {V : Type u} →
[inst : NormedAddCommGroup V] →
[inst_1 : InnerProductSpace ℝ V] → [CompleteSpace V] → {B : V →L[ℝ] V →L[ℝ] ℝ} → IsCoercive B → V ≃L[ℝ] V | The Lax-Milgram equivalence of a coercive bounded bilinear operator:
for all `v : V`, `continuousLinearEquivOfBilin B v` is the unique element `V`
such that `continuousLinearEquivOfBilin B v, w⟫ = B v w`.
The Lax-Milgram theorem states that this is a continuous equivalence.
| true |
Lean.Meta.Tactic.Cbv.CbvSimprocOLeanEntry.noConfusion | Lean.Meta.Tactic.Cbv.CbvSimproc | {P : Sort u} →
{t t' : Lean.Meta.Tactic.Cbv.CbvSimprocOLeanEntry} →
t = t' → Lean.Meta.Tactic.Cbv.CbvSimprocOLeanEntry.noConfusionType P t t' | null | false |
Bundle.Pretrivialization.linearEquivAt | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_4} →
[inst : Semiring R] →
[inst_1 : TopologicalSpace F] →
[inst_2 : TopologicalSpace B] →
[inst_3 : AddCommMonoid F] →
[inst_4 : Module R F] →
[inst_5 : (x : B) →... | A pretrivialization for a vector bundle defines linear equivalences between the
fibers and the model space. | true |
HasSubset.Subset.trans | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] [IsTrans α fun x1 x2 => x1 ⊆ x2] {a b c : α}, a ⊆ b → b ⊆ c → a ⊆ c | **Alias** of `subset_trans`. | true |
Lean.Elab.Do.DoOps.toDoOpsRefImpl | Lean.Elab.Do.Basic | Lean.Elab.Do.DoOps → Lean.Elab.Do.DoOpsRef | null | true |
Units.mul_right_inj | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) {b c : α}, ↑a * b = ↑a * c ↔ b = c | null | true |
Derivation.liftOfSurjective.congr_simp | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : CommRing M]
[inst_3 : Algebra R A] [inst_4 : Algebra R M] {F : Type u_4} [inst_5 : FunLike F A M] [inst_6 : AlgHomClass F R A M]
{f f_1 : F} (e_f : f = f_1) (hf : Function.Surjective ⇑f) ⦃d d_1 : Derivation R A A⦄... | null | true |
NormedSpace.inclusionInDoubleDualWeak._proof_11 | Mathlib.Analysis.Normed.Module.DoubleDual | ∀ (𝕜 : Type u_2) [inst : NontriviallyNormedField 𝕜] (X : Type u_1) [inst_1 : SeminormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X],
Continuous (((toWeakSpace 𝕜 X).arrowCongr StrongDual.toWeakDual) ↑(NormedSpace.inclusionInDoubleDual 𝕜 X)).toFun | null | false |
RingTheory.LinearMap._aux_Mathlib_Algebra_Algebra_Bilinear___macroRules_RingTheory_LinearMap_termμ_1 | Mathlib.Algebra.Algebra.Bilinear | Lean.Macro | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.