name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
EquivFunctor.mapEquiv_apply | Mathlib.Control.EquivFunctor | ∀ (f : Type u₀ → Type u₁) [inst : EquivFunctor f] {α β : Type u₀} (e : α ≃ β) (x : f α),
(EquivFunctor.mapEquiv f e) x = EquivFunctor.map e x | null | true |
PosNum.testBit.eq_5 | Mathlib.Data.Num.Lemmas | ∀ (a : PosNum), a.bit1.testBit 0 = true | null | true |
_private.Lean.Elab.Import.0.Lean.Elab.parseImports.match_1 | Lean.Elab.Import | (motive : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog → Sort u_1) →
(x : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog) →
((header : Lean.TSyntax `Lean.Parser.Module.header) →
(parserState : Lean.Parser.ModuleParserS... | null | false |
CategoryTheory.Epi.left_cancellation | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.Epi f] {Z : C}
(g h : Y ⟶ Z), CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h → g = h | A morphism `f` is an epimorphism if it can be cancelled when precomposed. | true |
Std.Time.Hour.instLEOffset._aux_1 | Std.Time.Time.Unit.Hour | Std.Time.Hour.Offset → Std.Time.Hour.Offset → Prop | null | false |
Vector.findFinIdx?_subtype | Init.Data.Vector.Find | ∀ {α : Type u_1} {n : ℕ} {p : α → Prop} {xs : Vector { x // p x } n} {f : { x // p x } → Bool} {g : α → Bool},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → Vector.findFinIdx? f xs = Vector.findFinIdx? g xs.unattach | null | true |
AffineIsometryEquiv._sizeOf_1 | 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 : Nor... | null | false |
String.startsWith_toSlice | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.ForwardPattern pat] {s : String},
s.toSlice.startsWith pat = s.startsWith pat | null | true |
MeasureTheory.convolution_zero | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} [inst_3 : NontriviallyNormedField 𝕜]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 F] {L : E →L[... | null | true |
CategoryTheory.Subobject.ofLEMk.eq_1 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
X.ofLEMk f h =
CategoryTheory.CategoryStruct.comp (X.ofLE (CategoryTheory.Subobject.mk f) h)
(CategoryTheory.Subobjec... | null | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.Simp.SimpTheorems.2970893097._hygCtx._hyg.2 | Lean.Meta.Tactic.Simp.SimpTheorems | IO (IO.Ref Lean.Meta.SimpExtensionMap) | null | false |
String.Slice.Pos.ofSlice_le_ofSlice_iff | Init.Data.String.Basic | ∀ {s : String.Slice} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {q r : (s.slice p₀ p₁ h).Pos},
String.Slice.Pos.ofSlice q ≤ String.Slice.Pos.ofSlice r ↔ q ≤ r | null | true |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuseCmd_1 | Mathlib.Tactic.DefEqAbuse | Lean.Elab.Command.CommandElab | null | false |
Lean.Lsp.DocumentFilter.rec | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.DocumentFilter → Sort u} →
((language? scheme? pattern? : Option String) →
motive { language? := language?, scheme? := scheme?, pattern? := pattern? }) →
(t : Lean.Lsp.DocumentFilter) → motive t | null | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_right_ne._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
_private.Mathlib.GroupTheory.Index.0.Subgroup.finiteIndex_iInf'.match_1_1 | Mathlib.GroupTheory.Index | ∀ {ι : Type u_1} {s : Finset ι} (motive : Subtype (Membership.mem s) → Prop) (x : Subtype (Membership.mem s)),
(∀ (i : ι) (hi : i ∈ s), motive ⟨i, hi⟩) → motive x | null | false |
Inner.noConfusionType | Mathlib.Analysis.InnerProductSpace.Defs | Sort u → {𝕜 : Type u_4} → {E : Type u_5} → Inner 𝕜 E → {𝕜' : Type u_4} → {E' : Type u_5} → Inner 𝕜' E' → Sort u | null | false |
PUnit.mulActionWithZero._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : MonoidWithZero R] (a : R), a • 0 = 0 | null | false |
Std.DTreeMap.keys | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → List α | Returns a list of all keys present in the tree map in ascending order. | true |
_private.Mathlib.Algebra.Group.Units.Opposite.0.IsAddUnit.op.match_1_1 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : AddMonoid M] {m : M} (motive : IsAddUnit m → Prop) (h : IsAddUnit m),
(∀ (u : AddUnits M) (hu : ↑u = m), motive ⋯) → motive h | null | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.codeBlock.withIndentColumn._sparseCasesOn_4 | Lean.DocString.Parser | {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 |
ULift.divInvMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : DivInvMonoid α], ULift.divInvMonoid = Function.Injective.divInvMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ | null | true |
RestrictedProduct.mapAlong_continuous | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι₁ : Type u_3} {ι₂ : Type u_4} (R₁ : ι₁ → Type u_5) (R₂ : ι₂ → Type u_6) [inst : (i : ι₁) → TopologicalSpace (R₁ i)]
[inst_1 : (i : ι₂) → TopologicalSpace (R₂ i)] {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} {A₁ : (i : ι₁) → Set (R₁ i)}
{A₂ : (i : ι₂) → Set (R₂ i)} (f : ι₂ → ι₁) (hf : Filter.Tendsto f 𝓕₂ 𝓕₁) (φ : (j : ... | null | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.Ici_nsmul_eq.match_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (x : 1 ≠ 0), motive 1 x) → (∀ (n : ℕ) (x : n + 2 ≠ 0), motive n.succ.succ x) → motive x x_1 | null | false |
Int8.shiftLeft | Init.Data.SInt.Basic | Int8 → Int8 → Int8 | Bitwise left shift for 8-bit signed integers. Usually accessed via the `<<<` operator.
Signed integers are interpreted as bitvectors according to the two's complement representation.
This function is overridden at runtime with an efficient implementation.
| true |
_private.Mathlib.Analysis.Analytic.CPolynomialDef.0.HasFiniteFPowerSeriesOnBall.eq_partialSum._simp_1_1 | Mathlib.Analysis.Analytic.CPolynomialDef | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
Quiver.zigzagSetoid.match_1 | Mathlib.Combinatorics.Quiver.ConnectedComponent | ∀ (V : Type u_1) [inst : Quiver V] {x y : V} (motive : Nonempty (Quiver.Path x y) → Prop)
(x_1 : Nonempty (Quiver.Path x y)), (∀ (p : Quiver.Path x y), motive ⋯) → motive x_1 | null | false |
IsInvariantSubfield.mk._flat_ctor | Mathlib.FieldTheory.Fixed | ∀ {M : Type u} [inst : Monoid M] {F : Type v} [inst_1 : Field F] [inst_2 : MulSemiringAction M F] {S : Subfield F},
(∀ (m : M) {x : F}, x ∈ S → m • x ∈ S) → IsInvariantSubfield M S | null | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.rcases.match_8 | Lean.Elab.Tactic.RCases | (motive : Option Lean.Ident × Lean.Syntax → Sort u_1) →
(x : Option Lean.Ident × Lean.Syntax) →
((hName? : Option Lean.Ident) → (tgt : Lean.Syntax) → motive (hName?, tgt)) → motive x | null | false |
MeasureTheory.withDensityᵥ_add | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] {f g : α → E},
MeasureTheory.Integrable f μ →
MeasureTheory.Integrable g μ → μ.withDensityᵥ (f + g) = μ.withDensityᵥ f + μ.withDensityᵥ g | null | true |
Set.fintypeOfFintypeImage | Mathlib.Data.Set.Finite.Basic | {α : Type u} →
{β : Type v} →
(s : Set α) → {f : α → β} → {g : β → Option α} → Function.IsPartialInv f g → [Fintype ↑(f '' s)] → Fintype ↑s | If a function `f` has a partial inverse `g` and the image of `s` under `f` is a set with
a `Fintype` instance, then `s` has a `Fintype` structure as well. | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mpullbackWithin_mlieBracketWithin_aux | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | null | true |
Aesop.LocalRuleSet.mk.sizeOf_spec | Aesop.RuleSet | ∀ (toBaseRuleSet : Aesop.BaseRuleSet) (simpTheoremsArray : Array (Lean.Name × Lean.Meta.SimpTheorems))
(simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size) (simprocsArray : Array (Lean.Name × Lean.Meta.Simprocs))
(simprocsArrayNonempty : 0 < simprocsArray.size) (localNormSimpRules : Array Aesop.LocalNormSimpRul... | null | true |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence_inverse_map_hom | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat))
(ι : Type u_1) [inst_1 : Unique ι] {X S : C} (f : X ⟶ S)
{X_1 Y : (CategoryTheory.Adjunction.ofCat (F.map f.op.toLoc).adj).t... | null | true |
AlgebraicGeometry.Scheme.range_fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | ∀ {X : AlgebraicGeometry.Scheme} (x : ↥X), Set.range ⇑(X.fromSpecResidueField x) = {x} | null | true |
MonoidAlgebra.mapDomainRingEquiv_apply | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Monoid N] (e : M ≃* N)
(x : MonoidAlgebra R M) (n : N), ((MonoidAlgebra.mapDomainRingEquiv R e) x) n = x (e.symm n) | null | true |
Matroid.cRk_map_image._auto_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | Lean.Syntax | null | false |
VectorAll._unsafe_rec | Mathlib.Data.Vector3 | {α : Type u_1} → (k : ℕ) → (Vector3 α k → Prop) → Prop | null | false |
Std.DTreeMap.Raw.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k fallback : α},
(t.erase k).isEmpty = false →
¬cmp k (t.minKeyD fallback) = Ordering.eq → (t.erase k).minKeyD fallback = t.minKeyD fallback | null | true |
CategoryTheory.MonoOver.mapIso._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : C} (e : A ≅ B) (X : CategoryTheory.MonoOver A),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoOver.map e.hom).map
(((CategoryTheory.MonoOver.mapComp e.hom e.inv).symm ≪≫
CategoryTheory.eqToIso ⋯ ≪≫ Category... | null | false |
pow_nonneg._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} [ZeroLEOneClass M₀] [PosMulMono M₀],
0 ≤ a → ∀ (n : ℕ), (0 ≤ a ^ n) = True | null | false |
Filter.Germ.coeRingHom | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {R : Type u_5} → [inst : Semiring R] → (l : Filter α) → (α → R) →+* l.Germ R | Coercion `(α → R) → Germ l R` as a `RingHom`. | true |
Lean.Data.AC.evalList._sparseCasesOn_1.else_eq | Init.Data.AC | ∀ {α : Type u} {motive : List α → Sort u_1} (t : List α) (nil : motive [])
(«else» : Nat.hasNotBit 1 t.ctorIdx → motive t) (h : Nat.hasNotBit 1 t.ctorIdx),
Lean.Data.AC.evalList._sparseCasesOn_1 t nil «else» = «else» h | null | false |
LSeries.logMul | Mathlib.NumberTheory.LSeries.Deriv | (ℕ → ℂ) → ℕ → ℂ | The (point-wise) product of `log : ℕ → ℂ` with `f`. | true |
Int.le_of_not_le | Init.Data.Int.Order | ∀ {a b : ℤ}, ¬a ≤ b → b ≤ a | null | true |
Finset.card_inter_smul_inv | Mathlib.Combinatorics.Additive.Convolution | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (A B : Finset G) (x : G),
(A ∩ x • B⁻¹).card = A.convolution B x | null | true |
Topology.IsLowerSet.WithLowerSetHomeomorph | Mathlib.Topology.Order.UpperLowerSetTopology | {α : Type u_1} →
[inst : Preorder α] → [inst_1 : TopologicalSpace α] → [Topology.IsLowerSet α] → Topology.WithLowerSet α ≃ₜ α | If `α` is equipped with the lower set topology, then it is homeomorphic to `WithLowerSet α`. | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.eq_zero_of_comapDomain_eq_zero._simp_1_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
intervalIntegral.intervalIntegral_pos_of_pos_on | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f : ℝ → ℝ} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b → (∀ x ∈ Set.Ioo a b, 0 < f x) → a < b → 0 < ∫ (x : ℝ) in a..b, f x | If `f : ℝ → ℝ` is integrable on `(a, b]` for real numbers `a < b`, and positive on the interior
of the interval, then its integral over `a..b` is strictly positive. | true |
Nat.eq_or_lt_of_le._unsafe_rec | Init.Prelude | ∀ {n m : ℕ}, n ≤ m → n = m ∨ n < m | null | false |
Std.instCoeDepAnyAsyncStreamOfAsyncStream | Std.Sync.StreamMap | {t α : Type} → {x : t} → [Std.Async.IO.AsyncStream t α] → CoeDep t x (Std.AnyAsyncStream α) | null | true |
ShareCommon.StateFactoryImpl.setFind? | Init.ShareCommon | (self : ShareCommon.StateFactoryImpl) → self.Set → ShareCommon.Object → Option ShareCommon.Object | null | true |
List.forall₂_nil_left_iff._simp_1 | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l : List β}, List.Forall₂ R [] l = (l = []) | null | false |
AddMonoidAlgebra.nonAssocSemiring.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddZeroClass M],
AddMonoidAlgebra.nonAssocSemiring =
{ toNonUnitalNonAssocSemiring := AddMonoidAlgebra.nonUnitalNonAssocSemiring, toOne := AddMonoidAlgebra.zero,
one_mul := ⋯, mul_one := ⋯, natCast := fun n => AddMonoidAlgebra.single 0 ↑n, natCas... | null | true |
Equiv.Perm.isCycleOn_swap | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {a b : α} [inst : DecidableEq α], a ≠ b → (Equiv.swap a b).IsCycleOn {a, b} | null | true |
_private.Mathlib.Data.List.Lattice.0.List.bagInter_sublist_left._proof_1_4 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l₁ l₂ : List α),
(l₁.bagInter (l₂.erase a)).Sublist l₁ → (a :: l₁.bagInter (l₂.erase a)).Sublist (a :: l₁) | null | false |
CategoryTheory.ShortComplex.SnakeInput.mono_L₀_f | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C) [CategoryTheory.Mono S.L₁.f], CategoryTheory.Mono S.L₀.f | null | true |
Localization.mk_eq_monoidOf_mk' | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M}, Localization.mk = (Localization.monoidOf S).mk' | null | true |
Mathlib.Tactic.ComputeDegree.natDegree_natCast_le | Mathlib.Tactic.ComputeDegree | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (↑n).natDegree ≤ 0 | null | true |
PresheafOfModules.evaluationJointlyReflectsColimits._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
(c : CategoryTheory.Limits.Cocone F)
(hc : (X : Cᵒᵖ) → CategoryTheory.Limits.IsColimit ((Presh... | null | false |
lt_add_iff_pos_left._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α] [AddRightStrictMono α] [AddRightReflectLT α] (a : α) {b : α},
(a < b + a) = (0 < b) | null | false |
Specialization.map_id | Mathlib.Topology.Specialization | ∀ {α : Type u_1} [inst : TopologicalSpace α], Specialization.map (ContinuousMap.id α) = OrderHom.id | null | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.modify_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) | null | false |
CategoryTheory.MorphismProperty.Over.mapPullbackAdj._proof_6 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} [inst_2 : P.IsStableUnderComposition] [inst_3 : Q.IsStableUnderBaseChange]
(f : X ⟶ Y) [inst_4 : P.HasPullbacksAlong f] [inst_5 : P.IsStableUnderBaseChangeAlong f] (hPf : ... | null | false |
Matrix.IsSymm.fromBlocks | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {m : Type u_4} {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
{D : Matrix n n α}, A.IsSymm → B.transpose = C → D.IsSymm → (Matrix.fromBlocks A B C D).IsSymm | A block matrix `A.fromBlocks B C D` is symmetric,
if `A` and `D` are symmetric and `Bᵀ = C`. | true |
ContinuousMapZero.nonUnitalStarAlgHom_postcomp._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ (X : Type u_2) {M : Type u_4} {R : Type u_3} {S : Type u_1} [inst : Zero X] [inst_1 : CommSemiring M]
[inst_2 : TopologicalSpace X] [inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace S] [inst_5 : CommSemiring R]
[inst_6 : StarRing R] [inst_7 : IsTopologicalSemiring R] [inst_8 : CommSemiring S] [inst_9 : Sta... | null | false |
Lean.Server.Reference.ci | Lean.Server.References | Lean.Server.Reference → Lean.Elab.ContextInfo | `ContextInfo` at the point of elaboration of this reference. | true |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.singleton_le_singleton._simp_1_1 | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Finset α} {a : α},
(toColex s ≤ toColex {a}) = ∀ b ∈ s, b ≤ a ∧ (a ∈ s → b = a) | null | false |
Mathlib.pp.mathlib.binderPredicates | Mathlib.Util.PPOptions | Lean.Option Bool | The `pp.mathlib.binderPredicates` option is used to control whether mathlib pretty printers
should use binder predicate notation (such as `∀ x < 2, p x`).
| true |
Set.iUnion_comm | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} (s : ι → ι' → Set α), ⋃ i, ⋃ i', s i i' = ⋃ i', ⋃ i, s i i' | null | true |
CategoryTheory.mono_iff_isIso_fst | Mathlib.CategoryTheory.Limits.EpiMono | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} {f : X ⟶ Y}
{c : CategoryTheory.Limits.PullbackCone f f} (hc : CategoryTheory.Limits.IsLimit c),
CategoryTheory.Mono f ↔ CategoryTheory.IsIso c.fst | null | true |
Mathlib.Tactic.AtomM.Context.mk._flat_ctor | Mathlib.Util.AtomM | Lean.Meta.TransparencyMode → (Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result) → Mathlib.Tactic.AtomM.Context | null | false |
Units.val_eq_neg_one | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] {a : αˣ}, ↑a = -1 ↔ a = -1 | null | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.liftWith_trans._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | null | false |
_private.Mathlib.Data.Finset.Lattice.Basic.0.Finset.instDistribLattice._simp_1 | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
TwoUniqueProds.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_2} (G : ι → Type u_1) [inst : (i : ι) → Mul (G i)] [∀ (i : ι), TwoUniqueProds (G i)],
TwoUniqueProds ((i : ι) → G i) | null | true |
Std.HashMap.Raw.mem_of_mem_filterMap | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → Option γ} {k : α}, m.WF → k ∈ Std.HashMap.Raw.filterMap f m → k ∈ m | null | true |
MulRingNorm.toAddGroupNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → [inst : NonAssocRing R] → MulRingNorm R → AddGroupNorm R | null | true |
nnnorm_apply_le_nnnorm_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
CategoryTheory.InducedWideCategory.congr_simp | Mathlib.CategoryTheory.Widesubcategory | ∀ {C : Type u₁} (D : Type u₂) [inst : CategoryTheory.Category.{v₁, u₂} D] (_F _F_1 : C → D),
_F = _F_1 →
∀ (_P _P_1 : CategoryTheory.MorphismProperty D) (e__P : _P = _P_1) [inst_1 : _P.IsMultiplicative],
CategoryTheory.InducedWideCategory D _F _P = CategoryTheory.InducedWideCategory D _F_1 _P_1 | null | true |
Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite | Mathlib.RingTheory.Invariant.Profinite | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {G : Type u}
[inst_3 : Group G] [inst_4 : MulSemiringAction G B] [SMulCommClass G A B] [inst_6 : TopologicalSpace G]
[CompactSpace G] [TotallyDisconnectedSpace G] [IsTopologicalGroup G] [inst_10 : TopologicalSpace B]
... | `G` acts transitively on the prime ideals of `B` above a given prime ideal of `A`. | true |
Algebra.Extension.Hom.mk.inj | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S} {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} {inst_3 : CommRing R'} {inst_4 : CommRing S'} {inst_5 : Algebra R' S'}
{P' : Algebra.Extension R' S'} {inst_6 : Algebra R R'} {inst_7 : Algebra S S'} {toRingHom : ... | null | true |
Lean.Meta.Grind.Arith.Linear.geAvoiding._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.Search | ℚ → Array (ℚ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → ℚ | null | false |
Std.HashMap.Raw.getElem?_insert | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k a : α} {v : β}, (m.insert k v)[a]? = if (k == a) = true then some v else m[a]? | null | true |
_private.Mathlib.Analysis.Real.Sqrt.0.Real.sq_le._simp_1_1 | Mathlib.Analysis.Real.Sqrt | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b : G},
(|a| ≤ b) = (-b ≤ a ∧ a ≤ b) | null | false |
Perfection.coeff_mk | Mathlib.RingTheory.Perfection | ∀ {R : Type u_1} [inst : CommSemiring R] {p : ℕ} [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p] (f : ℕ → R)
(hf : ∀ (n : ℕ), f (n + 1) ^ p = f n) (n : ℕ), (Perfection.coeff R p n) ⟨f, hf⟩ = f n | null | true |
Function.Semiconj.comp_eq | Mathlib.Logic.Function.Conjugate | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β}, Function.Semiconj f ga gb → f ∘ ga = gb ∘ f | **Alias** of the forward direction of `Function.semiconj_iff_comp_eq`.
---
Definition of `Function.Semiconj` in terms of functional equality. | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.recv.match_1 | Std.Sync.Channel | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → ((val : α) → motive (some val)) → ((x : Option α) → motive x) → motive __do_lift | null | false |
_private.Mathlib.Data.DFinsupp.Multiset.0.DFinsupp.toMultiset_le_toMultiset._simp_1_1 | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, (s ≤ t) = (Multiset.toDFinsupp s ≤ Multiset.toDFinsupp t) | null | false |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit.eq_def | Lean.Elab.DeclNameGen | ∀ (e : Lean.Expr) (omitTopForall : Bool),
Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝ e omitTopForall = do
let __do_lift ← get
if Std.HashSet.contains (Lean.Elab.Command.NameGen.MkNameState.seen✝ __do_lift) e = true then pure ""
else do
let s ← Lean.Elab.Command.NameGen.mkBaseNameCore.visit'... | null | true |
_private.Mathlib.Data.DFinsupp.Lex.0.DFinsupp.lt_trichotomy_rec._proof_2 | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : LinearOrder ι]
[inst_2 : (i : ι) → LinearOrder (α i)] (f g : Π₀ (i : ι), α i), (f.neLocus g).min = ⊤ → toLex f = toLex g | null | false |
Lean.Meta.Simp.Arith.Int.ToLinear.State.varMap._default | Lean.Meta.Tactic.Simp.Arith.Int.Basic | Lean.Meta.KExprMap ℕ | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.checkUnsolvedDocMVars.match_1 | Lean.Elab.DocString | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((v : Lean.Expr) → motive (some v)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
Set.Definable.image_comp_equiv | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {β : Type u_1}
{s : Set (β → M)}, A.Definable L s → ∀ (f : α ≃ β), A.Definable L ((fun g => g ∘ ⇑f) '' s) | null | true |
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_none_iff._proof_1_3 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, ¬(¬xs.size - 1 < xs.size ↔ xs.size = 0) → False | null | false |
Std.ExtDTreeMap.Const.mem_toList_iff_get?_eq_some | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {v : β},
(k, v) ∈ Std.ExtDTreeMap.Const.toList t ↔ Std.ExtDTreeMap.Const.get? t k = some v | null | true |
MeasureTheory.DominatedFinMeasAdditive.of_le | Mathlib.MeasureTheory.Integral.FinMeasAdditive | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_7} [inst : SeminormedAddCommGroup β]
{T : Set α → β} {C C' : ℝ},
MeasureTheory.DominatedFinMeasAdditive μ T C → C ≤ C' → MeasureTheory.DominatedFinMeasAdditive μ T C' | null | true |
prod_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u_3} {β : Type u_4} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [ProperSpace α]
[ProperSpace β], ProperSpace (α × β) | A binary product of proper spaces is proper. | true |
Lean.Meta.SolveByElim.saturateSymm | Lean.Meta.Tactic.SolveByElim | Bool → List Lean.Expr → Lean.MetaM (List Lean.Expr) | If `symm` is `true`, then adds in symmetric versions of each hypothesis.
| true |
Preord.ofHom_id | Mathlib.Order.Category.Preord | ∀ {X : Type u} [inst : Preorder X],
Preord.ofHom OrderHom.id = CategoryTheory.CategoryStruct.id { carrier := X, str := inst } | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.