name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Char.0.String.Slice.endsWith_char_eq_false_iff_forall_append._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ (b : Bool), (b = false) = ¬b = true | 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 |
_private.Mathlib.Probability.Distributions.Exponential.0.ProbabilityTheory.cdf_expMeasure_eq._simp_1_3 | Mathlib.Probability.Distributions.Exponential | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a : α}, (-a ≤ 0) = (0 ≤ a) | null | false |
CategoryTheory.Functor.OplaxMonoidal.instIsIsoη | 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.OplaxMonoidal] [CategoryTheory.Limits.Prese... | null | true |
Fin.range_castLE | Mathlib.Data.Fin.SuccPred | ∀ {n k : ℕ} (h : n ≤ k), Set.range (Fin.castLE h) = {i | ↑i < n} | null | 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 |
WCovBy.eq_or_covBy._to_dual_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ⩿ a → a = b ∨ b ⋖ a | null | false |
CompactExhaustion.mk.inj | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_4} {inst : TopologicalSpace X} {toFun : ℕ → Set X} {isCompact' : ∀ (n : ℕ), IsCompact (toFun n)}
{subset_interior_succ' : ∀ (n : ℕ), toFun n ⊆ interior (toFun (n + 1))} {iUnion_eq' : ⋃ n, toFun n = Set.univ}
{toFun_1 : ℕ → Set X} {isCompact'_1 : ∀ (n : ℕ), IsCompact (toFun_1 n)}
{subset_interior_suc... | null | true |
Fin.shiftLeft | Init.Data.Fin.Basic | {n : ℕ} → Fin n → Fin n → Fin n | Bitwise left shift of bounded numbers, with wraparound on overflow.
Examples:
* `(1 : Fin 10) <<< (1 : Fin 10) = (2 : Fin 10)`
* `(1 : Fin 10) <<< (3 : Fin 10) = (8 : Fin 10)`
* `(1 : Fin 10) <<< (4 : Fin 10) = (6 : Fin 10)`
| true |
Matrix.uniqueEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.Unique | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : Unique m] [inst_1 : Unique n] (a : A),
Matrix.uniqueEquiv.symm a = Matrix.of fun x x_1 => a | null | 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 |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux._simp_1_3 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | null | false |
Mathlib.Tactic.Abel._aux_Mathlib_Tactic_Abel___macroRules_Mathlib_Tactic_Abel_abel1!_1 | Mathlib.Tactic.Abel | Lean.Macro | null | false |
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 |
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_inv_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b) {Z : F.obj a ⟶ F.obj b}
(h : CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.CategoryStruct.id b)) ⟶ Z),
CategoryTheory.Categor... | null | true |
IntermediateField.exists_algHom_of_splits_of_aeval | Mathlib.FieldTheory.Extension | ∀ {F : Type u_1} {E : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K],
(∀ (s : E), IsIntegral F s ∧ (Polynomial.map (algebraMap F K) (minpoly F s)).Splits) →
∀ {x : E} {y : K}, (Polynomial.aeval y) (minpoly F x) = 0 → ∃ φ, φ x = y | 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 |
Finset.nontrivial_iff_ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, a ∈ s → (s.Nontrivial ↔ s ≠ {a}) | 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 |
PartOrdEmb.dual._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ (X : PartOrdEmb),
PartOrdEmb.ofHom (PartOrdEmb.Hom.hom (CategoryTheory.CategoryStruct.id X)).dual =
CategoryTheory.CategoryStruct.id { carrier := (↑X)ᵒᵈ, str := OrderDual.instPartialOrder ↑X } | 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 |
Plausible.InjectiveFunction.sliceSizes.eq_def | Mathlib.Testing.Plausible.Functions | ∀ (x : ℕ),
Plausible.InjectiveFunction.sliceSizes x =
let n := x;
if h : 0 < n then
have this := ⋯;
MLList.cons ⟨n, h⟩ (Plausible.InjectiveFunction.sliceSizes (n / 2))
else MLList.nil | null | true |
pure_le_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X], pure ≤ nhds | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._simp_1_5 | Init.Data.BitVec.Bitblast | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | null | false |
Lean.Elab.Term.MutualClosure.FixPoint.run | Lean.Elab.MutualDef | Array Lean.FVarId → Lean.Elab.Term.MutualClosure.UsedFVarsMap → Lean.Elab.Term.MutualClosure.UsedFVarsMap | 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 |
CategoryTheory.Functor.PushoutObjObj.ofIsInitialLeft._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {C₃ : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {X₁ Y₁ : C₁} (f₁ : X₁ ⟶ Y₁) {X₂ Y₂ : C₂} (f₂ : X₂ ⟶ Y₂)
... | null | false |
Function.HasFiniteSupport.sup | Mathlib.Algebra.FiniteSupport.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : SemilatticeSup M] {f g : α → M},
Function.HasFiniteSupport f → Function.HasFiniteSupport g → Function.HasFiniteSupport fun a => f a ⊔ g a | 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 |
NonemptyFinLinOrd.ofHom | Mathlib.Order.Category.NonemptyFinLinOrd | {X Y : Type u} →
[inst : Nonempty X] →
[inst_1 : LinearOrder X] →
[inst_2 : Fintype X] →
[inst_3 : Nonempty Y] →
[inst_4 : LinearOrder Y] → [inst_5 : Fintype Y] → (X →o Y) → (NonemptyFinLinOrd.of X ⟶ NonemptyFinLinOrd.of Y) | Typecheck a `OrderHom` as a morphism in `NonemptyFinLinOrd`. | true |
Ideal.under_under | Mathlib.RingTheory.Ideal.Over | ∀ {A : Type u_2} [inst : CommSemiring A] {B : Type u_3} [inst_1 : CommSemiring B] {C : Type u_4} [inst_2 : Semiring C]
[inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C] [IsScalarTower A B C] (𝔓 : Ideal C),
Ideal.under A (Ideal.under B 𝔓) = Ideal.under A 𝔓 | null | true |
_private.Init.Data.Int.LemmasAux.0.Int.min_assoc._proof_1_1 | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), ¬min (min a b) c = min a (min b c) → False | null | false |
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 |
List.infix_filter_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {p : α → Bool} {l₁ l₂ : List α}, l₂ <:+: List.filter p l₁ ↔ ∃ l, l <:+: l₁ ∧ l₂ = List.filter p l | null | true |
continuousAt_pi | Mathlib.Topology.Constructions | ∀ {X : Type u} {ι : Type u_5} {A : ι → Type u_6} [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 |
Std.Do.SPred.true_intro | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs}, P ⊢ₛ ⌜True⌝ | null | true |
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 |
_private.Mathlib.Tactic.Abel.0.Mathlib.Tactic.Abel.addG.match_1 | Mathlib.Tactic.Abel | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) → ((p : Lean.Name) → (s : String) → motive (p.str s)) → ((n : Lean.Name) → motive n) → motive x | null | false |
Lean.Parser.Tactic.tacticSeq1Indented | Lean.Parser.Term.Basic | Lean.Parser.Parser | null | true |
BoxIntegral.Box.Ioo_subset_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), BoxIntegral.Box.Ioo I ⊆ ↑I | 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 |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ToArrowResult._sizeOf_inst | Lean.Meta.Sym.Simp.Forall | SizeOf Lean.Meta.Sym.Simp.ToArrowResult✝ | null | false |
FormalMultilinearSeries.coeff_eq_zero | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {p : FormalMultilinearSeries 𝕜 𝕜 E} {n : ℕ}, p.coeff n = 0 ↔ p n = 0 | 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 |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_5.splitter | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(rs : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l_1 : Std.DTreeMap.Internal.Impl α β) →
l_1.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecon... | null | true |
Subsemigroup.range_subtype | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (s : Subsemigroup M), (MulMemClass.subtype s).srange = s | null | true |
TestFunction.coe_sub | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (f g : TestFunction Ω F n), ⇑(f - g) = ⇑f - ⇑g | null | true |
CochainComplex.isStrictlyGE_mappingCone._auto_1 | Mathlib.Algebra.Homology.HomotopyCategory.Plus | Lean.Syntax | null | false |
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 |
ValuationSubring.instFieldSubtypeMemTop._proof_4 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K], SubringClass (Subfield K) K | 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 |
String.Pos.Raw.isValidForSlice_stringSliceTo | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos} {q : String.Pos.Raw},
String.Pos.Raw.IsValidForSlice (s.sliceTo p) q ↔ q ≤ p.offset ∧ String.Pos.Raw.IsValid s q | null | 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 |
Lean.Meta.instInhabitedUnificationHints.default | Lean.Meta.UnificationHint | Lean.Meta.UnificationHints | null | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_6 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} (l : List ι) (n : ℕ), (List.take n l).length + 1 ≤ l.length → (List.take n l).length < l.length | null | false |
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.Triangulated.TStructure.truncGEδLT_comp_truncLTι_app | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | 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 |
Lean.Omega.LinearCombo.coordinate_eval_0 | Init.Omega.LinearCombo | ∀ {a0 : ℤ} {t : List ℤ}, (Lean.Omega.LinearCombo.coordinate 0).eval (Lean.Omega.Coeffs.ofList (a0 :: t)) = a0 | null | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isNonTrivialRegular.match_1 | Lean.Meta.ExprDefEq | (motive : Option Lean.ProjectionFunctionInfo → Sort u_1) →
(__do_lift : Option Lean.ProjectionFunctionInfo) →
((projInfo : Lean.ProjectionFunctionInfo) → motive (some projInfo)) →
((x : Option Lean.ProjectionFunctionInfo) → motive x) → motive __do_lift | null | false |
Bundle.Pretrivialization.linearMapAt_def_of_notMem | 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) → AddCommMonoid (E x)] [inst_6 : (x : B) → Module R (E x)]
(e : Bundle.Pretrivialization F Bundle.Tot... | null | true |
AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.isLocallyFraction | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
TopCat.LocalPredicate fun x => HomogeneousLocalization.AtPrime 𝒜 x.asHomogeneousIdeal.toIdeal | We will define the structure sheaf as the subsheaf of all dependent functions in
`Π x : U, HomogeneousLocalization 𝒜 x` consisting of those functions which can locally be expressed
as a ratio of `A` of same grading. | true |
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 (fun x ... | null | true |
List.eq_nil_of_map_eq_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, List.map f l = [] → l = [] | null | true |
Lean.Elab.ContextInfo.parentDecl?._default | Lean.Elab.InfoTree.Types | Option Lean.Name | null | false |
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 (HeytAlg.of X) | null | true |
CategoryTheory.OplaxFunctor.comp | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{D : Type u₃} →
[inst_2 : CategoryTheory.Bicategory D] →
CategoryTheory.OplaxFunctor B C → CategoryTheory.OplaxFunctor C D → CategoryTheory.OplaxFunctor B D | Composition of oplax functors. | true |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.msgToInteractive.match_3 | Lean.Widget.InteractiveDiagnostic | (motive : Lean.Widget.EmbedFmt✝ → Sort u_1) →
(x : Lean.Widget.EmbedFmt✝) →
((ctx : Lean.Elab.ContextInfo) →
(infos : Std.TreeMap ℕ Lean.Elab.Info compare) → motive (Lean.Widget.EmbedFmt.code✝ ctx infos)) →
((ctx : Lean.Elab.ContextInfo) →
(lctx : Lean.LocalContext) → (g : Lean.MVarId) → m... | null | false |
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 |
Associates.FactorSet.prod | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {α : Type u_1} → [inst : CommMonoidWithZero α] → Associates.FactorSet α → Associates α | Evaluates the product of a `FactorSet` to be the product of the corresponding multiset,
or `0` if there is none. | 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 |
List.length_product | Mathlib.Data.List.ProdSigma | ∀ {α : Type u_1} {β : Type u_2} (l₁ : List α) (l₂ : List β), (l₁ ×ˢ l₂).length = l₁.length * l₂.length | null | 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 |
FirstOrder.Language.IsRelational | Mathlib.ModelTheory.Basic | FirstOrder.Language → Prop | A language is relational when it has no function symbols. | true |
_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 |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0._regBuiltin.String.reduceEq.declare_69._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.655475629._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit | 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 |
Submodule.map.congr_simp | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [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 f_1 : M →ₛₗ[σ₁₂] M₂),
f = f_1 → ∀ (p p_1 : Submodule ... | null | 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 |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Operations.0.SimpleGraph.Walk.dropLast_support_concat.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v_1 : V} (h : G.Adj u v_1) (p : G.Walk v_1 v)
(motive : (∃ x q, ∃ (h' : G.Adj x v), SimpleGraph.Walk.cons h p = q.concat h') → Prop)
(x : ∃ x q, ∃ (h' : G.Adj x v), SimpleGraph.Walk.cons h p = q.concat h'),
(∀ (w : V) (w_1 : G.Walk u w) (w_2 : G.Adj w v) (hp : SimpleGraph... | null | false |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.