name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.farFromTriangleFree_of_disjoint_triangles_aux._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {e : Sym2 V} [inst : Fintype ↑G.edgeSet], (e ∈ G.edgeFinset) = (e ∈ G.edgeSet) | false |
Int16.ofBitVec_sdiv | Init.Data.SInt.Lemmas | ∀ (a b : BitVec 16), Int16.ofBitVec (a.sdiv b) = Int16.ofBitVec a / Int16.ofBitVec b | true |
FractionalIdeal.dual_eq_zero_iff._simp_1 | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {K : Type u_2} {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L] [inst_11 : IsDomain A]
[inst_12 : IsFractionRing A K] [inst_13 : FiniteDimensional K L] [inst_14 : Algebra.IsSeparable K L]
[inst_15 : IsIntegralClosure B A L] [inst_16 : IsFractionRing B L] [inst_17 : IsIntegrallyClosed A]
[inst_18 : IsDedekindDomain B] {I : FractionalIdeal (nonZeroDivisors B) L}, (FractionalIdeal.dual A K I = 0) = (I = 0) | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.getKeyD_insertIfNew._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | false |
Algebra.IsStandardEtale.mk._flat_ctor | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_4} {S : Type u_5} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Nonempty (StandardEtalePresentation R S) → Algebra.IsStandardEtale R S | false |
LineDerivAdd.rec | Mathlib.Analysis.Distribution.DerivNotation | {V : Type u} →
{E : Type v} →
{F : Type w} →
[inst : AddCommGroup V] →
[inst_1 : AddCommGroup E] →
[inst_2 : AddCommGroup F] →
[inst_3 : LineDeriv V E F] →
{motive : LineDerivAdd V E F → Sort u_1} →
((lineDerivOp_add :
∀ (v : V) (x y : E),
LineDeriv.lineDerivOp v (x + y) = LineDeriv.lineDerivOp v x + LineDeriv.lineDerivOp v y) →
(lineDerivOp_left_add :
∀ (v w : V) (x : E),
LineDeriv.lineDerivOp (v + w) x = LineDeriv.lineDerivOp v x + LineDeriv.lineDerivOp w x) →
motive ⋯) →
(t : LineDerivAdd V E F) → motive t | false |
IntermediateField.le_extendScalars_iff | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {F E : IntermediateField K L}
(h : F ≤ E) (E' : IntermediateField (↥F) L),
E' ≤ IntermediateField.extendScalars h ↔ IntermediateField.restrictScalars K E' ≤ E | true |
squeeze_one_norm | Mathlib.Analysis.Normed.Group.Continuity | ∀ {α : Type u_1} {E : Type u_4} [inst : SeminormedGroup E] {f : α → E} {a : α → ℝ} {t₀ : Filter α},
(∀ (n : α), ‖f n‖ ≤ a n) → Filter.Tendsto a t₀ (nhds 0) → Filter.Tendsto f t₀ (nhds 1) | true |
Matroid.IsBasis'.contract_indep_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {I J X : Set α},
M.IsBasis' I X → ((M.contract X).Indep J ↔ M.Indep (J ∪ I) ∧ Disjoint X J) | true |
ValuativeRel.instCommMonoidWithZeroValueGroupWithZero._proof_3 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (x : R) (y : ↥(ValuativeRel.posSubmonoid R)),
1 * ValuativeRel.ValueGroupWithZero.mk x y = ValuativeRel.ValueGroupWithZero.mk x y | false |
Function.locallyFinsuppWithin.instSMulInt | Mathlib.Topology.LocallyFinsupp | {X : Type u_1} →
[inst : TopologicalSpace X] →
{U : Set X} → {Y : Type u_2} → [inst_1 : AddGroup Y] → SMul ℤ (Function.locallyFinsuppWithin U Y) | true |
_private.Mathlib.RingTheory.Extension.Presentation.Basic.0._auto_106 | Mathlib.RingTheory.Extension.Presentation.Basic | Lean.Syntax | false |
CategoryTheory.Lax.OplaxTrans.Hom.of.inj | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {as as_1 : CategoryTheory.Lax.OplaxTrans.Modification η θ},
{ as := as } = { as := as_1 } → as = as_1 | true |
WeierstrassCurve.Jacobian.nonsingular_iff_of_Y_eq_negY | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F},
P 2 ≠ 0 → P 1 = W.negY P → (W.Nonsingular P ↔ W.Equation P ∧ (MvPolynomial.eval P) W.polynomialX ≠ 0) | true |
Std.DTreeMap.Internal.Impl.Const.get!_alter_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α] (h : t.WF)
{k : α} [inst : Inhabited β] {f : Option β → Option β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl k =
(f (Std.DTreeMap.Internal.Impl.Const.get? t k)).get! | true |
Units.divp_sub | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Ring α] (a b : α) (u : αˣ), a /ₚ u - b = (a - b * ↑u) /ₚ u | true |
Lean.Meta.Match.Pattern.hasExprMVar._unsafe_rec | Lean.Meta.Match.Basic | Lean.Meta.Match.Pattern → Bool | false |
ModuleCat.biproductIsoPi | Mathlib.Algebra.Category.ModuleCat.Biproducts | {R : Type u} →
[inst : Ring R] → {J : Type} → [inst_1 : Finite J] → (f : J → ModuleCat R) → ⨁ f ≅ ModuleCat.of R ((j : J) → ↑(f j)) | true |
AddAction.IsPretransitive | Mathlib.Algebra.Group.Action.Pretransitive | (M : Type u_5) → (α : Type u_6) → [VAdd M α] → Prop | true |
Monoid.CoprodI.Word.prod_cons | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (i : ι) (m : M i) (w : Monoid.CoprodI.Word M)
(h1 : m ≠ 1) (h2 : w.fstIdx ≠ some i), (Monoid.CoprodI.Word.cons m w h2 h1).prod = Monoid.CoprodI.of m * w.prod | true |
Lean.Meta.SynthInstance.Context._sizeOf_inst | Lean.Meta.SynthInstance | SizeOf Lean.Meta.SynthInstance.Context | false |
instOneTangentSpaceRealModelWithCornersSelf | Mathlib.Geometry.Manifold.Instances.Icc | (x : ℝ) → One (TangentSpace (modelWithCornersSelf ℝ ℝ) x) | true |
finprod_pow | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M},
Function.HasFiniteMulSupport f → ∀ (n : ℕ), (∏ᶠ (i : α), f i) ^ n = ∏ᶠ (i : α), f i ^ n | true |
Lean.Elab.Command.Structure.StructFieldView | Lean.Elab.Structure | Type | true |
OrderIso.sumAssoc | Mathlib.Data.Sum.Order | (α : Type u_10) →
(β : Type u_11) → (γ : Type u_12) → [inst : LE α] → [inst_1 : LE β] → [inst_2 : LE γ] → (α ⊕ β) ⊕ γ ≃o α ⊕ β ⊕ γ | true |
CategoryTheory.Limits.isKernelOfComp._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {W : C} (g : Y ⟶ W) (h : X ⟶ W),
CategoryTheory.CategoryStruct.comp f g = h →
∀ (s : CategoryTheory.Limits.Fork f 0), CategoryTheory.CategoryStruct.comp s.ι h = 0 | false |
AddMonoidAlgebra.one_def | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : Zero M], 1 = AddMonoidAlgebra.single 0 1 | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.mkApplyProjControlDiscrPath | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow | Lean.Name → ℕ → ℕ → Lean.Name → ℕ → Array Lean.Meta.DiscrTree.Key | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.norm_LFunction_product_ge_one.match_1_1 | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {x : ℝ} (y : ℝ)
(motive : 1 < (1 + ↑x).re ∧ 1 < (1 + ↑x + Complex.I * ↑y).re ∧ 1 < (1 + ↑x + 2 * Complex.I * ↑y).re → Prop)
(x_1 : 1 < (1 + ↑x).re ∧ 1 < (1 + ↑x + Complex.I * ↑y).re ∧ 1 < (1 + ↑x + 2 * Complex.I * ↑y).re),
(∀ (h₀ : 1 < (1 + ↑x).re) (h₁ : 1 < (1 + ↑x + Complex.I * ↑y).re) (h₂ : 1 < (1 + ↑x + 2 * Complex.I * ↑y).re),
motive ⋯) →
motive x_1 | false |
Std.ExtTreeMap.getD_map | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {f : α → β → γ} {k : α} {fallback : γ},
(Std.ExtTreeMap.map f t).getD k fallback = (Option.map (f k) t[k]?).getD fallback | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.getElem!_toArray_roo_ne_zero_iff._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ¬(i < (n - (m + 1)).toNat ∧ m + 1 + ↑i ≠ 0 ↔ i < (n - (m + 1)).toNat ∧ m + ↑i ≠ -1) → False | false |
CPolynomialAt.contDiffAt | Mathlib.Analysis.Calculus.ContDiff.CPolynomial | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E}, CPolynomialAt 𝕜 f x → ∀ {n : WithTop ℕ∞}, ContDiffAt 𝕜 n f x | true |
Monoid.CoprodI.inv_def | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} (G : ι → Type u_4) [inst : (i : ι) → Group (G i)] (x : Monoid.CoprodI G),
x⁻¹ =
MulOpposite.unop
((Monoid.CoprodI.lift fun i => (MonoidHom.op Monoid.CoprodI.of).comp (MulEquiv.inv' (G i)).toMonoidHom) x) | true |
Matrix.IsHermitian.rank_eq_card_non_zero_eigs | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
(hA : A.IsHermitian), A.rank = Fintype.card { i // hA.eigenvalues i ≠ 0 } | true |
Set.imageFactorization | Mathlib.Data.Set.Operations | {α : Type u} → {β : Type v} → (f : α → β) → (s : Set α) → ↑s → ↑(f '' s) | true |
Lean.Parser.FirstTokens.optTokens.elim | Lean.Parser.Types | {motive : Lean.Parser.FirstTokens → Sort u} →
(t : Lean.Parser.FirstTokens) →
t.ctorIdx = 3 → ((a : List Lean.Parser.Token) → motive (Lean.Parser.FirstTokens.optTokens a)) → motive t | false |
_private.Mathlib.Tactic.Group.0.Mathlib.Tactic.Group._aux_Mathlib_Tactic_Group___macroRules_Mathlib_Tactic_Group_group_1.match_1 | Mathlib.Tactic.Group | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc | false |
List.getElem_dropLast | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i : ℕ} (h : i < xs.dropLast.length), xs.dropLast[i] = xs[i] | true |
CategoryTheory.Idempotents.whiskeringLeftObjToKaroubiFullyFaithful._proof_2 | Mathlib.CategoryTheory.Idempotents.FunctorExtension | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D]
{F G : CategoryTheory.Functor (CategoryTheory.Idempotents.Karoubi C) D}
(τ :
((CategoryTheory.Functor.whiskeringLeft C (CategoryTheory.Idempotents.Karoubi C) D).obj
(CategoryTheory.Idempotents.toKaroubi C)).obj
F ⟶
((CategoryTheory.Functor.whiskeringLeft C (CategoryTheory.Idempotents.Karoubi C) D).obj
(CategoryTheory.Idempotents.toKaroubi C)).obj
G),
((CategoryTheory.Functor.whiskeringLeft C (CategoryTheory.Idempotents.Karoubi C) D).obj
(CategoryTheory.Idempotents.toKaroubi C)).map
{
app := fun P =>
CategoryTheory.CategoryStruct.comp (F.map P.decompId_i)
(CategoryTheory.CategoryStruct.comp (τ.app P.X) (G.map P.decompId_p)),
naturality := ⋯ } =
τ | false |
AddGroupNorm.instPartialOrder._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E], Function.Injective fun f => ⇑f | false |
Lean.Server.Completion.HoverInfo.ctorElimType | Lean.Server.Completion.CompletionUtils | {motive : Lean.Server.Completion.HoverInfo → Sort u} → ℕ → Sort (max 1 u) | false |
Std.DHashMap.Raw.contains_diff | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ \ m₂).contains k = (m₁.contains k && !m₂.contains k) | true |
BaseIO.toIO | Init.System.IO | {α : Type} → BaseIO α → IO α | true |
Std.Do.PredTrans._sizeOf_1 | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → [SizeOf α] → Std.Do.PredTrans ps α → ℕ | false |
CategoryTheory.DifferentialObject.Hom._sizeOf_inst | 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} →
(X Y : CategoryTheory.DifferentialObject S C) → [SizeOf S] → [SizeOf C] → SizeOf (X.Hom Y) | false |
DvdNotUnit.eq_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (a b : α), DvdNotUnit a b = (a ≠ 0 ∧ ∃ x, ¬IsUnit x ∧ b = a * x) | true |
AlgebraicGeometry.HasRingHomProperty.of_isOpenImmersion | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P Q] {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y},
(RingHom.ContainsIdentities fun {R S} [CommRing R] [CommRing S] => Q) → ∀ [AlgebraicGeometry.IsOpenImmersion f], P f | true |
_private.Mathlib.Algebra.Order.Ring.Abs.0.geomSum.match_1 | Mathlib.Algebra.Order.Ring.Abs | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | false |
Std.Tactic.BVDecide.BVExpr.Cache.Inv_empty | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit),
Std.Tactic.BVDecide.BVExpr.Cache.Inv assign aig Std.Tactic.BVDecide.BVExpr.Cache.empty | true |
List.not_lex_nil | Init.Data.List.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {l : List α}, ¬List.Lex r l [] | true |
_private.Mathlib.Data.ZMod.Defs.0.Fin.val_intCast._proof_1_2 | Mathlib.Data.ZMod.Defs | ∀ (x : ℤ), ¬0 ≤ x → x < 0 | false |
CoxeterSystem.IsReduced.drop | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {ω : List B},
cs.IsReduced ω → ∀ (j : ℕ), cs.IsReduced (List.drop j ω) | true |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj.restriction.res | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_2 : CategoryTheory.Category.{v', u'} A] →
[CategoryTheory.Functor.IsDenseSubsite J₀ J F] →
(data : (X : C) → F.OneHypercoverDenseData J₀ J X) →
[inst_4 : CategoryTheory.Limits.HasLimitsOfSize.{w, w, v', u'} A] →
(G₀ : CategoryTheory.Sheaf J₀ A) →
{X : C} →
{X₀ Y₀ : C₀} →
{f : F.obj X₀ ⟶ X} →
{g : Y₀ ⟶ X₀} →
(data X).SieveStruct f g →
(CategoryTheory.Functor.OneHypercoverDenseData.essSurj.presheafObj data G₀ X ⟶
G₀.obj.obj (Opposite.op Y₀)) | true |
Lean.IR.IRType.void | Lean.Compiler.IR.Basic | Lean.IR.IRType | true |
PrincipalSeg.codRestrict._proof_4 | Mathlib.Order.InitialSeg | ∀ {α : Type u_2} {β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} (p : Set β) (f : PrincipalSeg r s)
(H : ∀ (a : α), f.toRelEmbedding a ∈ p) (H₂ : f.top ∈ p) (val : β) (property : val ∈ p),
⟨val, property⟩ ∈ Set.range ⇑(RelEmbedding.codRestrict p f.toRelEmbedding H) ↔
Subrel s (fun x => x ∈ p) ⟨val, property⟩ ⟨f.top, H₂⟩ | false |
IsUnit.inv_mul_cancel | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : DivisionMonoid α] {a : α}, IsUnit a → a⁻¹ * a = 1 | true |
InnerProductSpace.isIdempotentElem_rankOne_self_iff | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_4} [inst : RCLike 𝕜] {F : Type u_8} [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
{x : F}, x ≠ 0 → (IsIdempotentElem (((InnerProductSpace.rankOne 𝕜) x) x) ↔ ‖x‖ = 1) | true |
CategoryTheory.Triangulated.TStructure.truncGE_map_truncGEπ_app_assoc | 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.Triangulated.TStructure C) (n : ℤ) (X : C) {Z : C}
(h : (t.truncGE n).obj ((t.truncGE n).obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((t.truncGE n).map ((t.truncGEπ n).app X)) h =
CategoryTheory.CategoryStruct.comp ((t.truncGEπ n).app ((t.truncGE n).obj X)) h | true |
ChainCompletePartialOrder.casesOn | Mathlib.Order.BourbakiWitt | {α : Type u_2} →
{motive : ChainCompletePartialOrder α → Sort u} →
(t : ChainCompletePartialOrder α) →
([toPartialOrder : PartialOrder α] →
(cSup : NonemptyChain α → α) →
(le_cSup : ∀ (c : NonemptyChain α), ∀ x ∈ c.carrier, x ≤ cSup c) →
(cSup_le : ∀ (c : NonemptyChain α) (x : α), (∀ y ∈ c.carrier, y ≤ x) → cSup c ≤ x) →
motive { toPartialOrder := toPartialOrder, cSup := cSup, le_cSup := le_cSup, cSup_le := cSup_le }) →
motive t | false |
IsLowerSet.eq_univ_or_Iio | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} [WellFoundedLT α], IsLowerSet s → s = Set.univ ∨ ∃ a, s = Set.Iio a | true |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.Subfunctor.ext.match_1 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {C : Type u_3} {inst : CategoryTheory.Category.{u_2, u_3} C} {F : CategoryTheory.Functor C (Type u_1)}
(motive : CategoryTheory.Subfunctor F → Prop) (h : CategoryTheory.Subfunctor F),
(∀ (obj : (U : C) → Set (F.obj U)) (map : ∀ {U V : C} (i : U ⟶ V), obj U ⊆ F.map i ⁻¹' obj V),
motive { obj := obj, map := map }) →
motive h | false |
FiniteAddGrp.mk._flat_ctor | Mathlib.Algebra.Category.Grp.FiniteGrp | (toAddGrp : AddGrpCat) → [isFinite : Finite ↑toAddGrp] → FiniteAddGrp.{u} | false |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_2 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {j k l : ι} (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ : ℤ) (hn₁ : n₀ + 1 = n₁),
CategoryTheory.CategoryStruct.comp (X.cokernelSequenceOpcycles f₂ f₃ n₀ n₁ hn₁).f
(X.cokernelSequenceOpcycles f₂ f₃ n₀ n₁ hn₁).g =
0 | false |
Subrepresentation.mem_ofSubmodule_iff | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {M : Type u_4} [inst : CommSemiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid M]
[inst_3 : Module (MonoidAlgebra A G) M] {N : Submodule (MonoidAlgebra A G) M} {m : M},
m ∈ Subrepresentation.ofSubmodule N ↔ m ∈ N | true |
CategoryTheory.Pseudofunctor.DescentData.instCategory._proof_7 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {X_1 Y : F.DescentData f} (f_1 : X_1.Hom Y),
{
hom := fun i =>
CategoryTheory.CategoryStruct.comp
({ hom := fun x => CategoryTheory.CategoryStruct.id (X_1.obj x), comm := ⋯ }.hom i) (f_1.hom i),
comm := ⋯ } =
f_1 | false |
Multiset.toDFinsupp_singleton | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α), Multiset.toDFinsupp {a} = fun₀ | a => 1 | true |
Nat.Partrec'.idv | Mathlib.Computability.Halting | ∀ {n : ℕ}, Nat.Partrec'.Vec id | true |
Complex.tan_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ), Complex.tan (↑Real.pi - x) = -Complex.tan x | true |
Std.Time.TimeZone.LocalTimeType.identifier | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.LocalTimeType → String | true |
PrimeSpectrum.basicOpen_le_basicOpen_iff | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] (f g : R),
PrimeSpectrum.basicOpen f ≤ PrimeSpectrum.basicOpen g ↔ f ∈ (Ideal.span {g}).radical | true |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.toArrow.match_3 | Lean.Meta.Sym.Simp.Forall | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (α β : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.forallE n α β bi)) →
((x : Lean.Expr) → motive x) → motive e | false |
CategoryTheory.Limits.mkFanLimit._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | Lean.Syntax | false |
LinearMap.BilinForm.apply_dualBasis_right | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {V : Type u_5} {K : Type u_6} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Type u_9}
[inst_3 : DecidableEq ι] [inst_4 : Finite ι] {B : LinearMap.BilinForm K V} (hB : B.Nondegenerate),
B.IsSymm → ∀ (b : Module.Basis ι K V) (i j : ι), (B (b i)) ((B.dualBasis hB b) j) = if i = j then 1 else 0 | true |
CategoryTheory.ShortComplex.opcyclesIsoCokernel_inv | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasRightHomology] [inst_3 : CategoryTheory.Limits.HasCokernel S.f],
S.opcyclesIsoCokernel.inv = CategoryTheory.Limits.cokernel.desc S.f S.pOpcycles ⋯ | true |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.instOfTwoCocycle._simp_1 | Mathlib.Algebra.Lie.Extension | ∀ {M : Type u_1} {A : Type u_7} [inst : AddZeroClass A] [inst_1 : DistribSMul M A] (a : M) (b₁ b₂ : A),
a • b₁ + a • b₂ = a • (b₁ + b₂) | false |
_private.Mathlib.Order.Bounds.Basic.0.bddBelow_bddAbove_iff_subset_Icc._simp_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u} {s t r : Set α}, (r ⊆ s ∩ t) = (r ⊆ s ∧ r ⊆ t) | false |
Lean.Meta.Grind.Arith.CommRing.CommRing.casesOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive : Lean.Meta.Grind.Arith.CommRing.CommRing → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.CommRing) →
((toRing : Lean.Meta.Grind.Arith.CommRing.Ring) →
(invFn? : Option Lean.Expr) →
(semiringId? : Option ℕ) →
(commSemiringInst commRingInst : Lean.Expr) →
(noZeroDivInst? fieldInst? : Option Lean.Expr) →
(denoteEntries : Lean.PArray (Lean.Expr × Lean.Meta.Grind.Arith.CommRing.RingExpr)) →
(nextId steps : ℕ) →
(queue : Lean.Meta.Grind.Arith.CommRing.Queue) →
(basis : List Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
(diseqs : Lean.PArray Lean.Meta.Grind.Arith.CommRing.DiseqCnstr) →
(recheck : Bool) →
(invSet : Lean.PHashSet Lean.Expr) →
(numEq0? : Option Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
(numEq0Updated : Bool) →
motive
{ toRing := toRing, invFn? := invFn?, semiringId? := semiringId?,
commSemiringInst := commSemiringInst, commRingInst := commRingInst,
noZeroDivInst? := noZeroDivInst?, fieldInst? := fieldInst?,
denoteEntries := denoteEntries, nextId := nextId, steps := steps, queue := queue,
basis := basis, diseqs := diseqs, recheck := recheck, invSet := invSet,
numEq0? := numEq0?, numEq0Updated := numEq0Updated }) →
motive t | false |
Int8.toISize_toInt64 | Init.Data.SInt.Lemmas | ∀ (n : Int8), n.toInt64.toISize = n.toISize | true |
Part.omegaCompletePartialOrder._proof_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_1} (c : OmegaCompletePartialOrder.Chain (Part α)) (i : ℕ), c i ≤ Part.ωSup c | false |
AlgebraicGeometry.Scheme.Cover.LocallyDirected.trans_comp._autoParam | Mathlib.AlgebraicGeometry.Cover.Directed | Lean.Syntax | false |
Mathlib.Explode.Status.sintro.elim | Mathlib.Tactic.Explode.Datatypes | {motive : Mathlib.Explode.Status → Sort u} →
(t : Mathlib.Explode.Status) → t.ctorIdx = 0 → motive Mathlib.Explode.Status.sintro → motive t | false |
Lean.CodeAction.FindTacticResult.rec | Lean.Server.CodeActions.Provider | {motive : Lean.CodeAction.FindTacticResult → Sort u} →
((a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tactic a)) →
((preferred : Bool) →
(insertIdx : ℕ) →
(a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tacticSeq preferred insertIdx a)) →
(t : Lean.CodeAction.FindTacticResult) → motive t | false |
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor_aux | 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_3}
[inst_3 : Group G] [inst_4 : MulSemiringAction G B] [inst_5 : SMulCommClass G A B] [inst_6 : TopologicalSpace G]
(Q : Ideal B) {N N' : OpenNormalSubgroup G} (e : N ≤ N'),
∀ x ∈ MulAction.stabilizer (G ⧸ ↑N.toOpenSubgroup) (Ideal.under (↥(FixedPoints.subalgebra A B ↥↑N.toOpenSubgroup)) Q),
(QuotientGroup.map (↑N.toOpenSubgroup) N'.toOpenSubgroup.1 (MonoidHom.id G) e) x ∈
MulAction.stabilizer (G ⧸ ↑N'.toOpenSubgroup) (Ideal.under (↥(FixedPoints.subalgebra A B ↥↑N'.toOpenSubgroup)) Q) | true |
isCoprime_mul_unit_right_left | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {x : R}, IsUnit x → ∀ (y z : R), IsCoprime (y * x) z ↔ IsCoprime y z | true |
HereditarilyLindelofSpace.isHereditarilyLindelof_univ | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u_2} {inst : TopologicalSpace X} [self : HereditarilyLindelofSpace X], IsHereditarilyLindelof Set.univ | true |
Set.finrank_empty | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Nontrivial R],
Set.finrank R ∅ = 0 | true |
_private.Mathlib.Analysis.Convex.Between.0.Wbtw.trans_left_right._simp_1_2 | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {M : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (r s : R) (y : M),
r • y - s • y = (r - s) • y | false |
Lean.Meta.Tactic.TryThis.format.inputWidth | Lean.Meta.TryThis | Lean.Option ℕ | true |
Lean.Grind.CommRing.instBEqExpr.beq._sparseCasesOn_6 | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} →
(t : Lean.Grind.CommRing.Expr) →
((a b : Lean.Grind.CommRing.Expr) → motive (a.add b)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.hasExt_iff | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C],
CategoryTheory.HasExt C ↔
∀ (X Y : C) (n : ℤ),
0 ≤ n →
Small.{w, w'}
((DerivedCategory.singleFunctor C 0).obj X ⟶
(CategoryTheory.shiftFunctor (DerivedCategory C) n).obj ((DerivedCategory.singleFunctor C 0).obj Y)) | true |
EMetric.pair_reduction | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : PseudoEMetricSpace T] {a : ENNReal} {n : ℕ} {J : Finset T},
↑J.card ≤ a ^ n →
∀ (c : ENNReal) (E : Type u_2) [inst_1 : PseudoEMetricSpace E],
∃ K ⊆ J ×ˢ J,
↑K.card ≤ a * ↑J.card ∧
(∀ (s t : T), (s, t) ∈ K → edist s t ≤ ↑n * c) ∧
∀ (f : T → E), ⨆ s, ⨆ t, edist (f ↑s) (f ↑↑t) ≤ 2 * ⨆ p, edist (f (↑p).1) (f (↑p).2) | true |
Nat.AtLeastTwo.ne_one | Mathlib.Data.Nat.Init | ∀ {n : ℕ} [n.AtLeastTwo], n ≠ 1 | true |
CategoryTheory.kernelCokernelCompSequence.snakeInput_v₁₂_τ₃ | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.kernelCokernelCompSequence.snakeInput f g).v₁₂.τ₃ = g | true |
_private.Lean.Elab.DocString.0.Lean.Doc.ArgSpec.ctorElim | Lean.Elab.DocString | {motive : Lean.Doc.ArgSpec✝ → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Doc.ArgSpec✝¹) → ctorIdx = Lean.Doc.ArgSpec.ctorIdx✝ t → Lean.Doc.ArgSpec.ctorElimType✝ ctorIdx → motive t | false |
instOfNatFloat | Init.Data.OfScientific | {n : ℕ} → OfNat Float n | true |
CategoryTheory.HasCodetector.casesOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasCodetector C → Sort u} →
(t : CategoryTheory.HasCodetector C) →
((hasCodetector : ∃ G, CategoryTheory.IsCodetector G) → motive ⋯) → motive t | false |
hasDerivWithinAt_congr_set' | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s t : Set 𝕜} (y : 𝕜),
s =ᶠ[nhdsWithin x {y}ᶜ] t → (HasDerivWithinAt f f' s x ↔ HasDerivWithinAt f f' t x) | true |
Array.zip_eq_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array β}, as.zip bs = Array.zipWith Prod.mk as bs | true |
_private.Mathlib.LinearAlgebra.BilinearForm.Orthogonal.0.LinearMap.BilinForm.ker_restrict_eq_of_codisjoint._simp_1_1 | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {R₂ : Type u_2} {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₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | false |
_private.Std.Data.DHashMap.Internal.AssocList.Basic.0.Std.DHashMap.Internal.AssocList.map.go._sunfold | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} →
((a : α) → β a → γ a) →
Std.DHashMap.Internal.AssocList α γ → Std.DHashMap.Internal.AssocList α β → Std.DHashMap.Internal.AssocList α γ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.