name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.MonoidalCategory.DayConvolution.unit_uniqueUpToIso_hom_assoc | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
{F G : CategoryTheory.Functor C V} (h h' : CategoryTheory.MonoidalCategory.DayConvolution F G)
{Z : Cate... | null | true |
Asymptotics.isLittleOTVS_fun_neg_right | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} {g : α → F} [ContinuousNeg F],
... | null | true |
aemeasurable_inv_iff._simp_2 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {G : Type u_4} [inst : InvolutiveInv G]
[inst_1 : MeasurableSpace G] [MeasurableInv G] {f : α → G}, AEMeasurable (fun x => (f x)⁻¹) μ = AEMeasurable f μ | null | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Combination.0.Set.powersetCard.stabilizer_coe._simp_1_3 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
MDifferentiableWithinAt.neg | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
IO.Process.Output.stderr | Init.System.IO | IO.Process.Output → String | Everything that was written to the process's standard error. | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getLitAux.match_1 | Lean.Compiler.LCNF.Simp.ConstantFold | (motive : Option ℕ → Sort u_1) →
(__x : Option ℕ) → ((natLit : ℕ) → motive (some natLit)) → ((x : Option ℕ) → motive x) → motive __x | null | false |
Equiv.subRight.eq_1 | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddGroup G] (a : G),
Equiv.subRight a = { toFun := fun b => b - a, invFun := fun b => b + a, left_inv := ⋯, right_inv := ⋯ } | null | true |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.HandlerTrie.below_2 | Lean.Elab.ConfigEval.DeriveEvalConfigItem | {motive_1 : Lean.Elab.ConfigEval.HandlerTrie✝ → Sort u} →
{motive_2 : Array (String × Lean.Elab.ConfigEval.HandlerTrie✝) → Sort u} →
{motive_3 : List (String × Lean.Elab.ConfigEval.HandlerTrie✝) → Sort u} →
{motive_4 : String × Lean.Elab.ConfigEval.HandlerTrie✝ → Sort u} →
List (String × Lean.Elab.C... | null | false |
_private.Batteries.Tactic.Lint.Misc.0.Batteries.Tactic.Lint.unusedArguments.match_11 | Batteries.Tactic.Lint.Misc | (motive : String × String → Sort u_1) →
(x : String × String) → ((lBracket rBracket : String) → motive (lBracket, rBracket)) → motive x | null | false |
Lean.Elab.Attribute.kind | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.AttributeKind | null | true |
RingPreordering.support.congr_simp | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] (P P_1 : RingPreordering R) (e_P : P = P_1) [inst_1 : P.HasIdealSupport],
P.support = P_1.support | null | true |
MeasurableEmbedding.measurable | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β},
MeasurableEmbedding f → Measurable f | A measurable embedding is a measurable function. | true |
CategoryTheory.HasProjectiveResolution | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroObject C] → [CategoryTheory.Limits.HasZeroMorphisms C] → C → Prop | An object admits a projective resolution.
| true |
TrivialLieModule.instLieRingModule._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M] (x y : L) (m : TrivialLieModule R L M), 0 = 0 + 0 | null | false |
CategoryTheory.IsSplitEpi.mk | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y},
Nonempty (CategoryTheory.SplitEpi f) → CategoryTheory.IsSplitEpi f | null | true |
instContMDiffVectorBundleOfNatWithTopENat_1 | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {𝕜 : Type u_1} {B : Type u_2} (F : Type u_3) (E : B → Type u_5) [inst : NontriviallyNormedField 𝕜] {EB : Type u_6}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_7} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB... | null | true |
Finset.bipartiteAbove_swap | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Finset α) (b : β) [inst : (a : α) → Decidable (r a b)],
Finset.bipartiteAbove (Function.swap r) s b = Finset.bipartiteBelow r s b | null | true |
PSet.Equiv._unsafe_rec | Mathlib.SetTheory.ZFC.PSet | PSet.{u_1} → PSet.{u_2} → Prop | null | false |
AddCommute.add_left._simp_1 | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : AddSemigroup S] {a b c : S}, AddCommute a c → AddCommute b c → AddCommute (a + b) c = True | null | false |
_private.Mathlib.NumberTheory.Height.NumberField.0.Mathlib.Meta.Positivity.evalHeightTotalWeight._proof_1 | Mathlib.NumberTheory.Height.NumberField | ∀ (α : Q(Type)) (x : Q(Zero «$α»)) (__defeqres : PLift («$x» =Q Nat.instMulZeroClass.toZero)),
«$x» =Q Nat.instMulZeroClass.toZero | null | false |
Lean.Meta.FVarSubst.mk.injEq | Lean.Meta.Tactic.FVarSubst | ∀ (map map_1 : Lean.AssocList Lean.FVarId Lean.Expr), ({ map := map } = { map := map_1 }) = (map = map_1) | null | true |
Fin.range_castLE | Mathlib.Data.Fin.SuccPred | ∀ {n k : ℕ} (h : n ≤ k), Set.range (Fin.castLE h) = {i | ↑i < n} | null | true |
ContinuousLinearMap.FredholmPackage.eventually_nhds_isInvertible | Mathlib.Analysis.Normed.Operator.Fredholm.Open | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace E]
{T₀ : E →L[𝕜] F} (pkg : T₀.FredholmPackage),
∀ᶠ (T : E →L[𝕜] F) in nhds T₀, (pkg.decCodom.... | Let `T₀ : E → F` be a Fredholm operator between two Banach spaces, and choose a
`FredholmPackage` for `T₀`; that is, fix topological decompositions `E = E₁ ⊕ E₀` and `F = F₁ ⊕ F₀`,
where `E₀` and `F₀` are finite dimensional, and such that in these decompositions we have
$T₀ = \begin{pmatrix} α₀ & 0 \cr 0 & 0 \end{pmatr... | true |
_private.Lean.Meta.Match.SolveOverlap.0.Lean.Meta.Match.injectionAny.match_1 | Lean.Meta.Match.SolveOverlap | (motive : Lean.Meta.InjectionResult → Sort u_1) →
(__do_lift : Lean.Meta.InjectionResult) →
(Unit → motive Lean.Meta.InjectionResult.solved) →
((mvarId : Lean.MVarId) →
(newEqs : Array Lean.FVarId) →
(remainingNames : List Lean.Name) →
motive (Lean.Meta.InjectionResult.su... | null | false |
DistribSMul.compFun | Mathlib.Algebra.GroupWithZero.Action.Defs | {M : Type u_1} →
{N : Type u_6} → (A : Type u_7) → [inst : AddZeroClass A] → [DistribSMul M A] → (N → M) → DistribSMul N A | Compose a `DistribSMul` with a function, with scalar multiplication `f r' • m`.
See note [reducible non-instances]. | true |
Polynomial.reverse_add_C | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (t : R),
(p + Polynomial.C t).reverse = p.reverse + Polynomial.C t * Polynomial.X ^ p.natDegree | null | true |
RingNorm.eq_zero_of_map_eq_zero' | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_2} [inst : NonUnitalNonAssocRing R] (self : RingNorm R) (x : R), self.toFun x = 0 → x = 0 | If the image under the seminorm is zero, then the argument is zero. | true |
Lean.Parser.Tactic.pushCast | Init.Tactics | Lean.ParserDescr | `push_cast` rewrites the goal to move certain coercions (*casts*) inward, toward the leaf nodes.
This uses `norm_cast` lemmas in the forward direction.
For example, `↑(a + b)` will be written to `↑a + ↑b`.
- `push_cast` moves casts inward in the goal.
- `push_cast at h` moves casts inward in the hypothesis `h`.
It can ... | true |
NonUnitalRingHom.codRestrict | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
{F : Type u_1} →
[inst_1 : FunLike F R S] →
[inst_2 : NonUnitalNonAssocSemiring S] →
[NonUnitalRingHomClass F R S] →
{S' : Type u_2} →
[inst_4 : SetLike S' S] →
... | Restriction of a non-unital ring homomorphism to a non-unital subsemiring of the codomain. | true |
String.instDecidableIsValidForSlice | Init.Data.String.Basic | {s : String.Slice} → {p : String.Pos.Raw} → Decidable (String.Pos.Raw.IsValidForSlice s p) | null | true |
Matrix.transpose_replicateCol | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {α : Type v} {ι : Type u_6} (v : m → α), (Matrix.replicateCol ι v).transpose = Matrix.replicateRow ι v | null | true |
Prod.swap_eq_iff_eq_swap | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α × β} {y : β × α}, x.swap = y ↔ x = y.swap | null | true |
Matrix.equiv_GL_linearindependent | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card | {𝔽 : Type u_1} → [inst : Field 𝔽] → [Fintype 𝔽] → (n : ℕ) → GL (Fin n) 𝔽 ≃ { s // LinearIndependent 𝔽 s } | Equivalence between `GL n F` and `n` vectors of length `n` that are linearly independent. Given
by sending a matrix to its columns. | true |
dvd_sub_comm | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ b - c ↔ a ∣ c - b | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.carry_succ._proof_1_4 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (i : ℕ) (x y : BitVec w) (c : Bool),
¬(2 * 2 ^ i ≤ x.toNat % 2 ^ i + (2 ^ i + y.toNat % 2 ^ i) + c.toNat ↔
2 ^ i ≤ x.toNat % 2 ^ i + y.toNat % 2 ^ i + c.toNat) →
False | null | false |
_private.Mathlib.Combinatorics.SetFamily.Shatter.0.Finset.card_le_card_shatterer._simp_1_9 | Mathlib.Combinatorics.SetFamily.Shatter | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
WithOne.recOneCoe.eq_1 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} {motive : WithOne α → Sort u_1} (one : motive 1) (coe : (a : α) → motive ↑a),
WithOne.recOneCoe one coe none = one | null | true |
HomotopicalAlgebra.CofibrantObject.HoCat.localizerMorphismResolution_functor | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.CofibrantObject.HoCat.localizerMorphismResolution C).functor =
HomotopicalAlgebra.CofibrantObject.HoCat.resolution | null | true |
CategoryTheory.LocalizerMorphism.LeftResolution.op | 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₂} →
... | The canonical map `Φ.LeftResolution X₂ → Φ.op.RightResolution (Opposite.op X₂)`. | true |
ContMDiffOn.of_succ | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
BoxIntegral.Prepartition.splitMany_insert | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) (s : Finset (ι × ℝ)) (p : ι × ℝ),
BoxIntegral.Prepartition.splitMany I (insert p s) =
BoxIntegral.Prepartition.splitMany I s ⊓ BoxIntegral.Prepartition.split I p.1 p.2 | null | true |
DilationEquiv.smulTorsor._proof_1 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
{P : Type u_3} [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor E P] (c : P) {k : 𝕜},
k ≠ 0 → ∀ (x : E), (k⁻¹ • fun x => x -ᵥ c) ((fun x => k • x +ᵥ c) x) = x | null | false |
Finset.Nontrivial.pow._f | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : CancelMonoid α] {s : Finset α},
s.Nontrivial → ∀ (x : ℕ) (f : Nat.below (motive := fun x => x ≠ 0 → (s ^ x).Nontrivial) x), x ≠ 0 → (s ^ x).Nontrivial | null | false |
continuousAt_pi | Mathlib.Topology.Constructions | ∀ {X : Type u} {ι : Type u_2} {A : ι → Type u_3} [inst : TopologicalSpace X] [T : (i : ι) → TopologicalSpace (A i)]
{f : X → (i : ι) → A i} {x : X}, ContinuousAt f x ↔ ∀ (i : ι), ContinuousAt (fun y => f y i) x | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.denote_detectIte._simp_1_5 | Std.Sat.AIG.CNF | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
Filter.Tendsto.inf_nhds | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] {α : Type u_3} {l : Filter α} {f g : α → L} {x y : L} [inst_1 : Min L]
[ContinuousInf L],
Filter.Tendsto f l (nhds x) → Filter.Tendsto g l (nhds y) → Filter.Tendsto (fun i => f i ⊓ g i) l (nhds (x ⊓ y)) | null | true |
Lean.Parser.Tactic.tacticSeq1Indented | Lean.Parser.Term.Basic | Lean.Parser.Parser | null | true |
List.IsChain.rel_getLast_head_of_append | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.IsChain R (l₁ ++ l₂) → ∀ (h₁ : l₁ ≠ []) (h₂ : l₂ ≠ []), R (l₁.getLast h₁) (l₂.head h₂) | null | true |
Order.PFilter.sInf_gc | Mathlib.Order.PFilter | ∀ {P : Type u_1} [inst : CompleteSemilatticeInf P],
GaloisConnection (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F) | null | true |
Lean.Elab.Tactic.Grind.saveTacticInfoForToken | Lean.Elab.Tactic.Grind.Basic | Lean.Syntax → Lean.Elab.Tactic.Grind.GrindTacticM Unit | Save the current tactic state for a token `stx`.
This method is a no-op if `stx` has no position information.
We use this method to save the tactic state at punctuation such as `;`
| true |
TestFunction.coe_sub | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_2} {α : Type u_4} {β : Type u_5} [inst : FunLike F α β] [inst_1 : Sub F] [inst_2 : Sub β]
[IsSubApply F α β] (f g : F), ⇑(f - g) = ⇑f - ⇑g | **Alias** of `FunLike.coe_sub`. | true |
Rack.instDivInvMonoidEnvelGroup._proof_2 | Mathlib.Algebra.Quandle | ∀ (R : Type u_1) [inst : Rack R] (a b c : Rack.EnvelGroup R), a * b * c = a * (b * c) | null | false |
ContinuousLinearMap.prodₗᵢ | Mathlib.Analysis.Normed.Operator.Prod | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
{G : Type u_4} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : SeminormedAddCommGroup F] →
[inst_3 : SeminormedAddCommGroup G] →
[inst_4 : NormedSpace 𝕜 E]... | `ContinuousLinearMap.prod` as a `LinearIsometryEquiv`. | true |
Std.Http.Internal.Mock.Server.noConfusion | Std.Http.Transport | {P : Sort u} → {t t' : Std.Http.Internal.Mock.Server} → t = t' → Std.Http.Internal.Mock.Server.noConfusionType P t t' | null | false |
instSubInt16 | Init.Data.SInt.Basic | Sub Int16 | null | true |
ContinuousLinearEquiv.comp_differentiableAt_iff | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (iso : E ≃L[𝕜] F) {f : G → E} {x : G... | null | true |
mul_self_sub_one | Mathlib.Algebra.Ring.Commute | ∀ {R : Type u} [inst : NonAssocRing R] (a : R), a * a - 1 = (a + 1) * (a - 1) | null | true |
CategoryTheory.SymmetricCategory.recOn | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{motive : CategoryTheory.SymmetricCategory C → Sort u_1} →
(t : CategoryTheory.SymmetricCategory C) →
([toBraidedCategory : CategoryTheory.BraidedCategory C] →
(symmetry ... | null | false |
ContDiffOn.inv | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : WithTop ℕ∞} {𝕜' : Type u_4} [inst_3 : NormedField 𝕜']
[inst_4 : NormedAlgebra 𝕜 𝕜'] {f : E → 𝕜'}, ContDiffOn 𝕜 n f s → (∀ x ∈ s, f x ≠ 0) → ContDiffOn 𝕜 n f⁻¹ s | null | true |
TensorPower.multilinearMapToDual._proof_4 | Mathlib.LinearAlgebra.TensorPower.Pairing | ∀ (R : Type u_1) [inst : CommSemiring R], SMulCommClass R R R | null | false |
CategoryTheory.Limits.filteredColimitsModule._proof_1 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.IsFiltered C]
(R : CategoryTheory.Functor C RingCat) (M : CategoryTheory.Functor C Ab)
[inst_2 : (i : C) → Module ↑(R.obj i) ↑(M.obj i)]
(H :
∀ {i j : C} (f : i ⟶ j) (r : ↑(R.obj i)) (m : ↑(M.obj i)),
(CategoryTheory.Concr... | null | false |
HeytAlg.ofHom_id | Mathlib.Order.Category.HeytAlg | ∀ {X : Type u} [inst : HeytingAlgebra X], HeytAlg.ofHom (HeytingHom.id X) = CategoryTheory.CategoryStruct.id ↧X | null | true |
CategoryTheory.Reflective.casesOn | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Reflective R → Sort u} →
(t : CategoryTheory.Reflective R) →
([toFull : R.Full... | null | false |
AddMonCat.of | Mathlib.Algebra.Category.MonCat.Basic | (M : Type u) → [AddMonoid M] → AddMonCat | Construct a bundled `AddMonCat` from the underlying type and typeclass. | true |
Module.subsingleton_of_rank_zero | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M]
[StrongRankCondition R], Module.rank R M = 0 → Subsingleton M | A free module of rank zero is trivial. | true |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.crown._proof_1_2 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {k₁ k₂ : C} {ι : Type u_3} (j : Option ι → C)
(f : (i : Option ι) → j i ⟶ k₁) (g : (i : Option ι) → j i ⟶ k₂) (s₁ : C) (α₁ : k₁ ⟶ s₁) (β₁ : k₂ ⟶ s₁),
(∀ (i : ι), CategoryTheory.CategoryStruct.comp (f (some i)) α₁ = CategoryTheory.CategoryStruct.comp (g ... | null | false |
_private.Mathlib.Algebra.Lie.Weights.Killing.0.LieAlgebra.IsKilling.corootSpace_eq_bot_iff._simp_1_1 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M), (N = ⊥) = (↑N = ⊥) | null | false |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_12 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊥) = (x = 0) | null | false |
isZGroup_of_coprime | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} {G' : Type u_2} {G'' : Type u_3} [inst : Group G] [inst_1 : Group G'] [inst_2 : Group G'']
{f : G →* G'} {f' : G' →* G''} [Finite G] [IsZGroup G] [IsZGroup G''],
f'.ker ≤ f.range → (Nat.card G).Coprime (Nat.card G'') → IsZGroup G' | An extension of coprime Z-groups is a Z-group. | true |
Lean.instToExprListOfToLevel | Lean.ToExpr | {α : Type u} → [Lean.ToLevel] → [Lean.ToExpr α] → Lean.ToExpr (List α) | null | true |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_obj_left_right_as | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor T D) (Y : D) (X : T)
(Y_1 : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X),
((CategoryTheory.CostructuredArrow.ofCostructuredArrowPro... | null | true |
Order.krullDim_eq_zero | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α] [Subsingleton α], Order.krullDim α = 0 | null | true |
AlgebraicGeometry.Scheme.AffineCover.noConfusionType | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | Sort u_1 →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S : AlgebraicGeometry.Scheme} →
AlgebraicGeometry.Scheme.AffineCover P S →
{P' : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S' : AlgebraicGeometry.Scheme} → AlgebraicGeometry.Scheme.AffineCover P... | null | false |
MvPowerSeries.coeff_index_single_self_X | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (s : σ), (MvPowerSeries.coeff fun₀ | s => 1) (MvPowerSeries.X s) = 1 | null | true |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.splitStr | Lean.Server.FileWorker.SemanticHighlighting | Lean.FileMap → Lean.Syntax → Array Lean.Syntax | Split the token at newline boundaries to support LSP clients such as VS Code that can't deal with
newline-spanning tokens.
| true |
Computation.think.eq_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u} (c : Computation α), c.think = ⟨Stream'.cons none ↑c, ⋯⟩ | null | true |
HeytingHom.mk | Mathlib.Order.Heyting.Hom | {α : Type u_6} →
{β : Type u_7} →
[inst : HeytingAlgebra α] →
[inst_1 : HeytingAlgebra β] →
(toLatticeHom : LatticeHom α β) →
toLatticeHom.toFun ⊥ = ⊥ →
(∀ (a b : α), toLatticeHom.toFun (a ⇨ b) = toLatticeHom.toFun a ⇨ toLatticeHom.toFun b) → HeytingHom α β | null | true |
Matrix.eq_zero_of_vecMul_eq_zero | Mathlib.LinearAlgebra.Matrix.Nondegenerate | ∀ {m : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : Fintype m] [inst_2 : DecidableEq m] {M : Matrix m m R}
[NoZeroDivisors R], M.det ≠ 0 → ∀ {v : m → R}, Matrix.vecMul v M = 0 → v = 0 | null | true |
CategoryTheory.Functor.WellOrderInductionData.Extension.mk.injEq | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type v)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} {j : J}
(val : F.obj (Opposite.op j))
(map_zero : (CategoryTheory.ConcreteCategory.hom (F.map (CategoryTheory.homOfLE ⋯).op)) v... | null | true |
Std.TreeMap.Raw.Equiv.insertManyIfNewUnit_list | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {t₁ t₂ : Std.TreeMap.Raw α Unit cmp},
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (l : List α), (t₁.insertManyIfNewUnit l).Equiv (t₂.insertManyIfNewUnit l) | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs.0.IsLinearSet.closure._simp_1_4 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | null | false |
Std.Net.SocketAddressV6.mk | Std.Net.Addr | Std.Net.IPv6Addr → UInt16 → Std.Net.SocketAddressV6 | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit.0.CochainComplex.mappingConeHomOfDegreewiseSplitIso._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | ∀ (p : ℤ), p + 1 + 1 + -1 = p + 1 | null | false |
Nat.gcd_sub_mul_right_right | Init.Data.Nat.Gcd | ∀ {m n k : ℕ}, k * m ≤ n → m.gcd (n - k * m) = m.gcd n | null | true |
SimpleGraph.pathGraph3ComplEmbeddingOf._proof_1 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u_1} {G : SimpleGraph α} (h : ¬G.IsCompleteMultipartite), ∃ w₁ w₂, G.IsPathGraph3Compl ⋯.choose w₁ w₂ | null | false |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_3.splitter | Std.Data.Iterators.Lemmas.Producers.Monadic.List | {m : Type u_1 → Type u_2} →
{α : Type u_1} →
(motive : Std.IterM m α → Sort u_3) →
(it : Std.IterM m α) →
(Unit → motive { internalState := { list := [] } }) →
((x : α) → (xs : List α) → motive { internalState := { list := x :: xs } }) → motive it | null | true |
Int64.toInt_sub | Init.Data.SInt.Lemmas | ∀ (a b : Int64), (a - b).toInt = (a.toInt - b.toInt).bmod (2 ^ 64) | null | true |
CategoryTheory.is_coprod_iff_isPushout | Mathlib.CategoryTheory.Adhesive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X E Y YE : C} (c : CategoryTheory.Limits.BinaryCofan X E)
(hc : CategoryTheory.Limits.IsColimit c) {f : X ⟶ Y} {iY : Y ⟶ YE} {fE : c.pt ⟶ YE},
CategoryTheory.CommSq f c.inl iY fE →
(Nonempty
(CategoryTheory.Limits.IsColimit
(CategoryThe... | null | true |
Algebra.TensorProduct.algHomOfLinearMapTensorProduct._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A], SMulCommClass R S A | null | false |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_6 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x | null | false |
Matroid.contract_inter_ground_eq | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} (M : Matroid α) (C : Set α), M.contract (C ∩ M.E) = M.contract C | null | true |
Pell.Solution₁.instCommGroup._proof_5 | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a b c : Pell.Solution₁ d), a * b * c = a * (b * c) | null | false |
Commute.isNilpotent_mul_left_iff | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_1} {x y : R} [inst : Semiring R],
Commute x y → x ∈ nonZeroDivisorsLeft R → (IsNilpotent (x * y) ↔ IsNilpotent y) | null | true |
_private.Mathlib.Data.Set.Image.0.Set.preimage_eq_empty_iff._simp_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
AddCircle.gcd_mul_addOrderOf_div_eq | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (p : 𝕜) [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [hp : Fact (0 < p)] {n : ℕ}
(m : ℕ), 0 < n → m.gcd n * addOrderOf ↑(↑m / ↑n * p) = n | null | true |
Std.Internal.Parsec.ParseResult.success.noConfusion | Std.Internal.Parsec.Basic | {α ι : Type} →
{P : Sort u} →
{pos : ι} →
{res : α} →
{pos' : ι} →
{res' : α} →
Std.Internal.Parsec.ParseResult.success pos res = Std.Internal.Parsec.ParseResult.success pos' res' →
(pos ≍ pos' → res ≍ res' → P) → P | null | false |
Std.DHashMap.Raw.toList_insert_perm | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k : α} {v : β k},
(m.insert k v).toList.Perm (⟨k, v⟩ :: List.filter (fun x => decide ¬(k == x.fst) = true) m.toList) | null | true |
CategoryTheory.Functor.CoconeTypes.IsColimit.equiv.congr_simp | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimit), hc.equiv = hc.equiv | null | true |
Lean.Parser.TokenCacheEntry.startPos._default | Lean.Parser.Types | String.Pos.Raw | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.