name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.HashSet.Raw.get_diff | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_mem : k ∈ m₁ \ m₂},
(m₁ \ m₂).get k h_mem = m₁.get k ⋯ | null | true |
PadicInt.norm_intCast_lt_one_iff | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ}, ‖↑z‖ < 1 ↔ ↑p ∣ z | null | true |
_private.Lean.Widget.UserWidget.0.Lean.Widget.builtinModulesRef | Lean.Widget.UserWidget | IO.Ref (Std.TreeMap UInt64 (Lean.Name × Lean.Widget.Module) compare) | null | true |
LieSubalgebra.span_univ | Mathlib.Algebra.Lie.Subalgebra | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieSubalgebra.lieSpan R L Set.univ = ⊤ | null | true |
CategoryTheory.Lax.OplaxTrans.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C] (app : (a : B) → F.obj a ⟶ G.obj a)
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (F.... | null | true |
List.min_replicate | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] [Std.MinEqOr α] {n : ℕ} {a : α} (h : List.replicate n a ≠ []),
(List.replicate n a).min h = a | null | true |
_private.Aesop.Tree.Tracing.0.Aesop.Goal.traceMetadata.match_1 | Aesop.Tree.Tracing | (motive : Option (Lean.MVarId × Lean.Meta.SavedState) → Sort u_1) →
(x : Option (Lean.MVarId × Lean.Meta.SavedState)) →
(Unit → motive none) →
((goal : Lean.MVarId) → (state : Lean.Meta.SavedState) → motive (some (goal, state))) → motive x | null | false |
CategoryTheory.Limits.Fork.ext._to_dual_3.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : Y ⟶ X}
{s t : CategoryTheory.Limits.Cofork f g} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp t.π i.inv = s.π),
CategoryTheory.Limits.Fork.ext._to_dual_3 i w =
{ hom := CategoryTheory.Limits.Cofork.mkHom i.hom ⋯, inv := Catego... | null | false |
Valuation.IsEquiv.orderRingIso.congr_simp | 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 Γ₀'} (h : v.IsEquiv w),
h.orderRingIso = h.orderRingIso | null | true |
Lean.AsyncList.rec | Lean.Server.AsyncList | {ε : Type u} →
{α : Type v} →
{motive_1 : Lean.AsyncList ε α → Sort u_1} →
{motive_2 : Lean.Server.ServerTask (Except ε (Lean.AsyncList ε α)) → Sort u_1} →
{motive_3 : Task (Except ε (Lean.AsyncList ε α)) → Sort u_1} →
{motive_4 : Except ε (Lean.AsyncList ε α) → Sort u_1} →
((h... | null | false |
_private.Mathlib.Algebra.Group.TypeTags.Basic.0.isRegular_toMul._simp_1_2 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {R : Type u_1} [inst : Mul R] {c : R}, IsRegular c = (IsLeftRegular c ∧ IsRightRegular c) | null | false |
Nat.mul_pos_iff_of_pos_left | Init.Data.Nat.Lemmas | ∀ {a b : ℕ}, 0 < a → (0 < a * b ↔ 0 < b) | null | true |
LinOrd.instConcreteCategoryOrderHomCarrier._proof_4 | Mathlib.Order.Category.LinOrd | ∀ {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X), (CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | null | false |
HomologicalComplex.monoidalCategoryStruct._proof_4 | Mathlib.Algebra.Homology.Monoidal | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] {I : Type u_1} [inst_3 : AddMonoid I] (c : ComplexShape I)
[∀ (X₁ X₂ X₃ : CategoryTheory.GradedObject I C), X₁.HasGoodTensor₁₂Tensor X₂ X₃] (K₁ K₂ K₃ : HomologicalCompl... | null | false |
_private.Mathlib.CategoryTheory.MorphismProperty.OfObjectProperty.0.CategoryTheory.MorphismProperty.ofObjectProperty_map_le.match_1_1 | Mathlib.CategoryTheory.MorphismProperty.OfObjectProperty | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P Q : CategoryTheory.ObjectProperty C) {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) ⦃X Y : D⦄ (f : X ⟶ Y)
(motive : (CategoryTheory.MorphismProperty.ofObjectProperty P Q).map F f → Prop)
(h : (Catego... | null | false |
CategoryTheory.NatIso.ofComponents'_hom_app | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (app : (X : C) → F.obj X ≅ G.obj X)
(naturality :
autoParam
(∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (F.map f) ... | null | true |
lp.normedAddCommGroup._proof_21 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] [hp : Fact (1 ≤ p)],
Filter.comk
(fun x =>
x ∈
{s |
∃ C,
∀ ⦃x : ↥(lp E p)⦄,
x ∈ s →
∀ ⦃y : ↥(lp E p)⦄,
y ∈ s →
... | null | false |
OrderIso.symm_image_image | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set α), ⇑e.symm '' ⇑e '' s = s | null | true |
spinGroup.mul_star_self_of_mem | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} {x : CliffordAlgebra Q}, x ∈ spinGroup Q → x * star x = 1 | null | true |
SimpleGraph.Walk.support_prefix_support_append | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (q : G.Walk v w), p.support <+: (p.append q).support | null | true |
IsMulTorsion.quotient_iff | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] {N : Subgroup G} [inst_1 : Group H] {f : G →* H},
Function.Surjective ⇑f → N = f.ker → IsMulTorsion ↥N → (IsMulTorsion H ↔ IsMulTorsion G) | The image of a quotient is torsion iff the group is torsion. | true |
Lean.Elab.Term.withDeprecationContextFromAttrs | Lean.Elab.DeclModifiers | {m : Type → Type u_1} →
{α : Type} → [MonadWithReaderOf Lean.Elab.Term.Context m] → Array Lean.Elab.Attribute → m α → m α | If `attrs` contains an `@[deprecated]` attribute, runs the action with `Term.Context.checkDeprecated`
disabled, suppressing the `linter.deprecated` warning that would otherwise fire when a deprecated
constant is referenced. Otherwise, runs the action unchanged.
This implements the suppression rule from RFC #8942: depr... | true |
_private.Mathlib.Algebra.GroupWithZero.NonZeroDivisors.0.associatesNonZeroDivisorsEquiv._simp_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {r : M₀},
(r ∈ nonZeroDivisors M₀) = ((∀ (x : M₀), r * x = 0 → x = 0) ∧ ∀ (x : M₀), x * r = 0 → x = 0) | null | false |
Lean.Parser.sepByElemParser.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → String → Lean.PrettyPrinter.Formatter | null | true |
WithBot.toDualTopEquiv._proof_2 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} (a : (WithTop α)ᵒᵈ),
(fun a => OrderDual.toDual (WithBot.recBotCoe ⊤ (fun a => ↑(OrderDual.ofDual a)) a))
((fun a => WithTop.recTopCoe ⊥ (fun a => ↑(OrderDual.toDual a)) (OrderDual.ofDual a)) a) =
a | null | false |
Submodule.finite_iSup | Mathlib.RingTheory.Finiteness.Lattice | ∀ {R : Type u_2} {V : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {ι : Sort u_1}
[Finite ι] (S : ι → Submodule R V) [∀ (i : ι), Module.Finite R ↥(S i)], Module.Finite R ↥(⨆ i, S i) | The submodule generated by a supremum of finite-dimensional submodules, indexed by a finite
sort is finite-dimensional. | true |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.ofComapInteger._simp_1_2 | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {s : Subring S} {f : R →+* S} {x : R},
(x ∈ Subring.comap f s) = (f x ∈ s) | null | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Defs.0.BigOperators.FinsetResult.Ici.noConfusion | Mathlib.Algebra.BigOperators.Group.Finset.Defs | {P : Sort u} →
{n n' : Lean.Term} → BigOperators.FinsetResult.Ici✝ n = BigOperators.FinsetResult.Ici✝ n' → (n = n' → P) → P | null | false |
_private.Init.Data.Int.Order.0.Int.instLawfulOrderLT._simp_2 | Init.Data.Int.Order | ∀ {a b : Prop} [Decidable a], (a → b) = (¬a ∨ b) | null | false |
ContinuousMultilinearMap.zero_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Zero β}
{inst_2 : Zero F} [self : IsZeroApply F α β] (x : α), 0 x = 0 | **Alias** of `zero_apply`. | true |
Order.height_eq_krullDim_Iic | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (x : α), ↑(Order.height x) = Order.krullDim ↑(Set.Iic x) | null | true |
Lean.Elab.WF.GuessLex.RecCallCache.callerName | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Elab.WF.GuessLex.RecCallCache → Lean.Name | null | true |
_private.Mathlib.Order.KrullDimension.0.Order.height_le_of_krullDim_preimage_le._proof_1_4 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {m : ℕ} (p : LTSeries α),
p.length ≤ m + (p.length - (m + 1)) → p.length > m → False | null | false |
_private.Plausible.Gen.0.Plausible.Gen.backtrackFuel.match_1 | Plausible.Gen | (motive : ℕ → Sort u_1) → (fuel : ℕ) → (Unit → motive Nat.zero) → ((fuel' : ℕ) → motive fuel'.succ) → motive fuel | null | false |
HomologicalComplex.HomologySequence.snakeInput._proof_37 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} {ι : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i j : ι),
CategoryTheory.Epi
((HomologicalComplex.HomologySequence.composableArrows₃ S.X₂ i j).map' 2 3
Homolog... | null | false |
CategoryTheory.DifferentialObject.mk._flat_ctor | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddMonoidWithOne S] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
(obj : C) →
(d : obj ⟶ (CategoryTheory.shiftFunctor C 1).obj ... | null | false |
PiTensorProduct.ofFinsuppEquiv'.eq_1 | Mathlib.LinearAlgebra.PiTensorProduct.Finsupp | ∀ {R : Type u_1} {ι : Type u_2} {κ : ι → Type u_3} [inst : CommSemiring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (κ i)] [inst_4 : DecidableEq R],
PiTensorProduct.ofFinsuppEquiv' =
PiTensorProduct.ofFinsuppEquiv.trans
(Finsupp.lcongr (Equiv.refl ((i : ι) → κ i)) ↑(Pi... | null | true |
Turing.TM0.Machine.map_respects | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} [inst : Inhabited Γ] {Γ' : Type u_2} [inst_1 : Inhabited Γ'] {Λ : Type u_3} [inst_2 : Inhabited Λ]
{Λ' : Type u_4} [inst_3 : Inhabited Λ'] (M : Turing.TM0.Machine Γ Λ) (f₁ : Turing.PointedMap Γ Γ')
(f₂ : Turing.PointedMap Γ' Γ) (g₁ : Turing.PointedMap Λ Λ') (g₂ : Λ' → Λ) {S : Set Λ},
Turing.TM0.S... | null | true |
LaurentPolynomial.ext | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] {p q : LaurentPolynomial R}, (∀ (a : ℤ), p.coeff a = q.coeff a) → p = q | null | true |
signedDist_triangle_left | Mathlib.Geometry.Euclidean.SignedDist | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v : V) (p q r : P), ((signedDist v) p) q - ((signedDist v) p) r = ((signedDist v) r) q | null | true |
CategoryTheory.Functor.PreservesLeftKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
{D : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] ... | `G.PreservesLeftKanExtension F L` asserts that `G` preserves all left Kan extensions
of `F` along `L`. See `PreservesLeftKanExtension.mk_of_preserves_isLeftKanExtension` for a
constructor taking a single left Kan extension as input. | true |
ContinuousMap.exists_finite_sum_smul_approximation_of_mem_uniformity | Mathlib.Topology.UniformSpace.ProdApproximation | ∀ {X : Type u_1} {Y : Type u_2} {R : Type u_3} {V : Type u_4} [inst : TopologicalSpace X] [TotallyDisconnectedSpace X]
[T2Space X] [CompactSpace X] [inst_4 : TopologicalSpace Y] [CompactSpace Y] [inst_6 : AddCommGroup V]
[inst_7 : UniformSpace V] [IsUniformAddGroup V] {S : Set (V × V)} [inst_9 : TopologicalSpace R]... | A continuous function on `X × Y`, taking values in an `R`-module with a uniform structure,
can be uniformly approximated by sums of functions of the form `(x, y) ↦ f x • g y`.
Note that no continuity properties are assumed either for multiplication on `R`, or for the scalar
multiplication of `R` on `V`. | true |
Nat.gcd_dvd_gcd_mul_right_left | Init.Data.Nat.Gcd | ∀ (m n k : ℕ), m.gcd n ∣ (m * k).gcd n | null | true |
CategoryTheory.Discrete.ctorIdx | Mathlib.CategoryTheory.Discrete.Basic | {α : Type u₁} → CategoryTheory.Discrete α → ℕ | null | false |
CompleteLattice.mk._flat_ctor | Mathlib.Order.CompleteLattice.Defs | {α : Type u_4} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam →
(∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(∀ (a... | null | false |
Lean.Lsp.Ipc.expandModuleHierarchyImports | Lean.Data.Lsp.Ipc | ℕ → Lean.Lsp.DocumentUri → Lean.Lsp.Ipc.IpcM (Option Lean.Lsp.Ipc.ModuleHierarchy × ℕ) | null | true |
Holor.assocLeft.eq_1 | Mathlib.Data.Holor | ∀ {α : Type} {ds₁ ds₂ ds₃ : List ℕ}, Holor.assocLeft = cast ⋯ | null | true |
AlgebraicGeometry.Scheme.pretopology._proof_3 | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) [P.IsMultiplicative],
(AlgebraicGeometry.Scheme.precoverage P).IsStableUnderComposition | null | false |
_private.Batteries.Data.Array.Match.0.Array.PrefixTable.step.eq_def | Batteries.Data.Array.Match | ∀ {α : Type u_1} [inst : BEq α] (t : Array.PrefixTable α) (x : α) (x_1 : Fin (t.size + 1)),
t.step x x_1 =
match x_1 with
| ⟨k, hk⟩ =>
have cont := fun x_2 =>
match k, hk with
| 0, hk => ⟨0, ⋯⟩
| k.succ, hk =>
have h2 := ⋯;
let k' := t.toArray[k].2;
... | null | true |
WeierstrassCurve.Projective.Point | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → Type r | A nonsingular projective point on a Weierstrass curve `W`. | true |
CategoryTheory.Pretriangulated.invRotateIsoRotateRotateShiftFunctorNegOne | Mathlib.CategoryTheory.Triangulated.TriangleShift | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
CategoryTheory.Pretriangulated.invRotate C ≅
(CategoryTheory.Pretriangulated.r... | The inverse of the rotation of triangles can be expressed using a double
rotation and the shift by `-1`. | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle.0.CochainComplex.HomComplex.Cochain.δ_fromSingleMk._proof_1_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {p q n : ℤ}, p + n = q → ∀ (n' q' : ℤ), p + n' = q' → ¬q + 1 = q' → ¬n + 1 = n' | null | false |
_private.Mathlib.Topology.Instances.AddCircle.DenseSubgroup.0.dense_addSubgroupClosure_pair_iff._simp_1_8 | Mathlib.Topology.Instances.AddCircle.DenseSubgroup | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
ContinuousAlternatingMap.piLinearEquiv._proof_4 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {A : Type u_1} {M : Type u_2} {ι : Type u_4} [inst : Semiring A] [inst_1 : AddCommMonoid M]
[inst_2 : TopologicalSpace M] [inst_3 : Module A M] {ι' : Type u_5} {M' : ι' → Type u_3}
[inst_4 : (i : ι') → AddCommMonoid (M' i)] [inst_5 : (i : ι') → TopologicalSpace (M' i)]
[inst_6 : ∀ (i : ι'), ContinuousAdd (M' i)... | null | false |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip₀₁'._simp_1_6 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
BiheytingHom.comp_apply | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β]
[inst_2 : BiheytingAlgebra γ] (f : BiheytingHom β γ) (g : BiheytingHom α β) (a : α), (f.comp g) a = f (g a) | null | true |
ValuativeRel.IsRankLeOne | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | (R : Type u_1) → [inst : Semiring R] → [ValuativeRel R] → Prop | We say that a ring with a valuative relation is of rank one if
there exists a strictly monotone embedding of the "canonical" value group-with-zero into
the nonnegative reals, and the image of this embedding contains some element different
from `0` and `1`. | true |
QuadraticMap.Isometry.proj_apply | Mathlib.LinearAlgebra.QuadraticForm.Prod | ∀ {ι : Type u_1} {R : Type u_2} {P : Type u_7} {Mᵢ : ι → Type u_8} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (Mᵢ i)] [inst_2 : AddCommMonoid P] [inst_3 : (i : ι) → Module R (Mᵢ i)]
[inst_4 : Module R P] [inst_5 : Fintype ι] [inst_6 : DecidableEq ι] (i : ι) (Q : QuadraticMap R (Mᵢ i) P)
(f : (x : ι... | null | true |
_private.Aesop.Tree.AddRapp.0.Aesop.copyGoals.match_1 | Aesop.Tree.AddRapp | (motive : Aesop.ForwardState × Aesop.ForwardRuleMatches × Aesop.UnorderedArraySet Lean.MVarId → Sort u_1) →
(x : Aesop.ForwardState × Aesop.ForwardRuleMatches × Aesop.UnorderedArraySet Lean.MVarId) →
((forwardState : Aesop.ForwardState) →
(forwardRuleMatches : Aesop.ForwardRuleMatches) →
(mvars ... | null | false |
BitVec.setWidth_eq_append_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {v : ℕ} {x : BitVec v} {w : ℕ}, BitVec.setWidth w x = BitVec.cast ⋯ (0#(w - v) ++ BitVec.extractLsb' 0 (min v w) x) | A `(x : BitVec v)` set to width `w` equals `(v - w)` zeros,
followed by the low `(min v w) bits of `x`
| true |
List.Nodup.product | Mathlib.Data.List.Nodup | ∀ {α : Type u} {β : Type v} {l₁ : List α} {l₂ : List β}, l₁.Nodup → l₂.Nodup → (l₁ ×ˢ l₂).Nodup | null | true |
CategoryTheory.BiconeHom.decidableEq._proof_4 | Mathlib.CategoryTheory.Limits.Bicones | ∀ (J : Type u_1) (j : J),
CategoryTheory.Bicone.left = CategoryTheory.Bicone.diagram j →
Bool.rec False True (CategoryTheory.Bicone.left.ctorIdx.beq (CategoryTheory.Bicone.diagram j).ctorIdx) | null | false |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_or_lt_of_ne._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) | null | false |
ContinuousMultilinearMap.opNorm_neg | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E G), ‖... | null | true |
CategoryTheory.ULiftHom.equiv._proof_1 | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (x : C),
(CategoryTheory.Functor.id C).obj x = (CategoryTheory.Functor.id C).obj x | null | false |
_private.Mathlib.CategoryTheory.Limits.IndYoneda.0.CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π._simp_1_2 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic._aux_Batteries_Tactic_Trans___elabRules_Batteries_Tactic_tacticTrans____1.match_1 | Batteries.Tactic.Trans | (motive : Option (Lean.Expr × List Lean.MVarId) → Sort u_1) →
(t'? : Option (Lean.Expr × List Lean.MVarId)) →
((fst : Lean.Expr) → (gs' : List Lean.MVarId) → motive (some (fst, gs'))) →
((x : Option (Lean.Expr × List Lean.MVarId)) → motive x) → motive t'? | null | false |
Lean.Parser.ModuleParserState.noConfusionType | Lean.Parser.Module | Sort u → Lean.Parser.ModuleParserState → Lean.Parser.ModuleParserState → Sort u | null | false |
Submodule.mem_span_set' | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : M}
{s : Set M}, m ∈ Submodule.span R s ↔ ∃ n f g, ∑ i, f i • ↑(g i) = m | An element `m ∈ M` is contained in the `R`-submodule spanned by a set `s ⊆ M`, if and only if
`m` can be written as a finite `R`-linear combination of elements of `s`.
The implementation uses a sum indexed by `Fin n` for some `n`. | true |
Std.Do.Spec.pure | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps] {α : Type u} {a : α}
{Q : Std.Do.PostCond α ps}, ⦃Q.1 a⦄ pure a ⦃Q⦄ | null | true |
MulOpposite.instNatCast | Mathlib.Algebra.Ring.Opposite | {R : Type u_1} → [NatCast R] → NatCast Rᵐᵒᵖ | null | true |
Lean.Elab.DelabTermInfo.noConfusionType | Lean.Elab.InfoTree.Types | Sort u → Lean.Elab.DelabTermInfo → Lean.Elab.DelabTermInfo → Sort u | null | false |
_private.Mathlib.Topology.Order.MonotoneContinuity.0.continuousWithinAt_left_of_monotoneOn_of_exists_between.match_1_1 | Mathlib.Topology.Order.MonotoneContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder β] {f : α → β} {s : Set α} {a : α} (b : βᵒᵈ)
(motive : (∃ c ∈ s, f c ∈ Set.Ioo b (f a)) → Prop) (x : ∃ c ∈ s, f c ∈ Set.Ioo b (f a)),
(∀ (c : α) (hcs : c ∈ s) (hcb : b < f c) (hca : f c < f a), motive ⋯) → motive x | null | false |
_private.Mathlib.Algebra.Ring.SumsOfSquares.0.Subsemiring.closure_isSquare._simp_1_1 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ {T : Type u_2} [inst : CommSemiring T], Subsemiring.closure {x | IsSquare x} = (Submonoid.square T).subsemiringClosure | null | false |
AffineEquiv.linearHom._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (x x_1 : P₁ ≃ᵃ[k] P₁), (x * x_1).linear = (x * x_1).linear | null | false |
NonemptyFinLinOrd.hasForgetToLinOrd._proof_3 | Mathlib.Order.Category.NonemptyFinLinOrd | autoParam
(NonemptyFinLinOrd.hasForgetToLinOrd._aux_1.comp (CategoryTheory.forget LinOrd) =
CategoryTheory.forget NonemptyFinLinOrd)
CategoryTheory.HasForget₂.forget_comp._autoParam | null | false |
Lean.AddErrorMessageContext.casesOn | Lean.Exception | {m : Type → Type} →
{motive : Lean.AddErrorMessageContext m → Sort u} →
(t : Lean.AddErrorMessageContext m) →
((add : Lean.Syntax → Lean.MessageData → m (Lean.Syntax × Lean.MessageData)) → motive { add := add }) → motive t | null | false |
Pi.constRingHom._proof_4 | Mathlib.Algebra.Ring.Pi | ∀ (α : Type u_1) (β : Type u_2) [inst : NonAssocSemiring β] (x y : β),
(↑↑(RingHom.pi fun x => RingHom.id β)).toFun (x + y) =
(↑↑(RingHom.pi fun x => RingHom.id β)).toFun x + (↑↑(RingHom.pi fun x => RingHom.id β)).toFun y | null | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs.0.vectorSpan_add_self._proof_1_3 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_2) {V : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] (s : Set V) (x : V),
(∃ x_1 ∈ vectorSpan k s, ∃ y ∈ s, x_1 + y = x) ↔ ∃ p₁ ∈ s, ∃ v ∈ vectorSpan k s, x = v + p₁ | null | false |
InfHom.dual._proof_3 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : Min β] (f : SupHom αᵒᵈ βᵒᵈ) (a b : αᵒᵈ),
f.toFun (a ⊔ b) = f.toFun a ⊔ f.toFun b | null | false |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.ne_singleton_iff._simp_1_2 | Mathlib.Data.List.Nodup | ∀ {a b c : Prop}, (a ∧ (b ∨ c)) = (a ∧ b ∨ a ∧ c) | null | false |
CochainComplex.shiftEval_inv_app | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n i i' : ℤ)
(hi : n + i = i') (X : CochainComplex C ℤ),
(CochainComplex.shiftEval C n i i' hi).inv.app X = (HomologicalComplex.XIsoOfEq X ⋯).inv | null | true |
NonUnitalStarAlgHom.codRestrict._proof_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {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]
(f : A →⋆ₙₐ[R] B) (S : NonUnitalStarSubalgebra R B) (hf : ∀ (x : A), f x ∈ S) (a : A),
... | null | false |
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 |
Lean.Parser.Term.elabToSyntax.formatter | Lean.Elab.Term.TermElabM | Lean.PrettyPrinter.Formatter | null | true |
SaturatedSubmonoid.instSetLike | Mathlib.Algebra.Group.Submonoid.Saturation | (M : Type u_1) → [inst : MulOneClass M] → SetLike (SaturatedSubmonoid M) M | null | true |
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 |
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), x ^ 0 = 1 | null | false |
Thunk.fn | Init.Core | {α : Type u} → Thunk α → Unit → α | Extract the getter function out of a thunk. Use `Thunk.get` instead. | true |
_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 |
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 |
_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 |
CategoryTheory.Abelian.SpectralObject.EIsoH_hom_naturality._auto_5 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.