name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | allowCompletion bool 2
classes |
|---|---|---|---|
DoubleCoset.eq_of_not_disjoint | Mathlib.GroupTheory.DoubleCoset | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {a b : G},
¬Disjoint (DoubleCoset.doubleCoset a ↑H ↑K) (DoubleCoset.doubleCoset b ↑H ↑K) →
DoubleCoset.doubleCoset a ↑H ↑K = DoubleCoset.doubleCoset b ↑H ↑K | true |
Mathlib.Tactic.Bicategory.naturality_inv | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {p : a ⟶ b} {f g : b ⟶ c} {pf : a ⟶ c} {η : f ≅ g}
(η_f : CategoryTheory.CategoryStruct.comp p f ≅ pf) (η_g : CategoryTheory.CategoryStruct.comp p g ≅ pf),
CategoryTheory.Bicategory.whiskerLeftIso p η ≪≫ η_g = η_f →
CategoryTheory.Bicategory.whiske... | true |
ISize.div_self | Init.Data.SInt.Lemmas | ∀ {a : ISize}, a / a = if a = 0 then 0 else 1 | true |
Affine.Simplex.altitudeFoot_mem_affineSpan_image_compl | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.altitudeFoot i ∈ affineSpan ℝ (s.points '' {i}ᶜ) | true |
One.toOfNat1.hcongr_2 | Mathlib.GroupTheory.CoprodI | ∀ (α α' : Type u_1), α = α' → ∀ (inst : One α) (inst' : One α'), inst ≍ inst' → One.toOfNat1 ≍ One.toOfNat1 | true |
CategoryTheory.RetractArrow.left_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g), h.left.i = h.i.left | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Search.0.Lean.Meta.Grind.Arith.Cutsat.CooperSplit.assert.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | (motive : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u_1) →
(c₃? : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
((c₃ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive (some c₃)) →
((x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive x) → motive c₃? | false |
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : ↑I.multicospan.sections),
(fun s =>
⟨fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
| CategoryTheory.Limits.WalkingMulticospan.right... | false |
IsInvApply.rec | Mathlib.Data.FunLike.IsApply | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : Inv β] →
[inst_2 : Inv F] →
{motive : IsInvApply F α β → Sort u} →
((inv_apply : ∀ (f : F) (x : α), f⁻¹ x = (f x)⁻¹) → motive ⋯) → (t : IsInvApply F α β) → motive t | false |
Std.ExtTreeSet.self_le_max?_insert | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k kmi : α},
(t.insert k).max?.get ⋯ = kmi → (cmp k kmi).isLE = true | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.exists_eq_some_of_findSome?_eq_some._proof_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {x : α} {f : Fin n → Option α}, Fin.findSome? f = some x → ∃ i, f i = some x | false |
DirectSum.Decomposition.casesOn | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
{ℳ : ι → σ} →
{motive : DirectSum.Decomposition ℳ → Sort u} →
(t ... | false |
_private.Init.Data.String.Basic.0.String.Slice.Pos.ofSliceFrom_le_ofSliceFrom_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | false |
Lean.Expr.ensureHasNoMVars | Mathlib.Lean.Expr.Basic | Lean.Expr → Lean.MetaM Unit | true |
Int.inductionOn'.neg._f | Mathlib.Data.Int.Init | {motive : ℤ → Sort u_1} →
(b : ℤ) →
motive b → ((k : ℤ) → k ≤ b → motive k → motive (k - 1)) → (n : ℕ) → Nat.below n → motive (b + Int.negSucc n) | false |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx?.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} (x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : ℕ),
Std.DTreeMap.Internal.Impl.Const.entryAtIdx? x x_1 =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.leaf, x => none
| Std.DTreeMap.Internal.Impl.inner size k v l r, n =>
match compare n l.size with
| Ordering.... | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.elim | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
t.ctorIdx = 3 →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f)) →
motive t | false |
UInt8._sizeOf_inst | Init.SizeOf | SizeOf UInt8 | false |
Int.reduceNeg._regBuiltin.Int.reduceNeg.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.2123988823._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | false |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffOn_iff_target._simp_1_1 | 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... | false |
_private.Mathlib.Data.Set.Finite.Basic.0.Finset.exists.match_1_3 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {p : Finset α → Prop} (motive : (∃ s, ∃ (hs : s.Finite), p hs.toFinset) → Prop)
(x : ∃ s, ∃ (hs : s.Finite), p hs.toFinset),
(∀ (s : Set α) (hs : s.Finite) (hs' : p hs.toFinset), motive ⋯) → motive x | false |
_private.Lean.Elab.BuiltinDo.Match.0.Lean.Elab.Do.elabPatterns._sparseCasesOn_1 | Lean.Elab.BuiltinDo.Match | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | false |
UnitAddTorus.mFourierLp._proof_7 | Mathlib.Analysis.Fourier.AddCircleMulti | ∀ {d : Type u_1}, CompactSpace (d → UnitAddCircle) | false |
IsAbsoluteValue.abv_nonneg | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R] (abv : R → S)
[IsAbsoluteValue abv] (x : R), 0 ≤ abv x | true |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.associator._proof_13 | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ : CategoryTheory.Arrow C)
[inst_3 :
CategoryTheory.Limits.PreservesColimit
(CategoryTheory.Limits.span (CategoryTheory.MonoidalCategoryStruct... | false |
CoxeterMatrix.instGroupGroup._proof_20 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (M : CoxeterMatrix B),
autoParam
(∀ (n : ℕ) (a : M.Group),
CoxeterMatrix.instGroupGroup._aux_17 M (↑n.succ) a = CoxeterMatrix.instGroupGroup._aux_17 M (↑n) a * a)
DivInvMonoid.zpow_succ'._autoParam | false |
Std.Http.URI.Path.mk.injEq | Std.Internal.Http.Data.URI.Basic | ∀ (segments : Array Std.Http.URI.EncodedSegment) (absolute : Bool) (segments_1 : Array Std.Http.URI.EncodedSegment)
(absolute_1 : Bool),
({ segments := segments, absolute := absolute } = { segments := segments_1, absolute := absolute_1 }) =
(segments = segments_1 ∧ absolute = absolute_1) | true |
EReal.coe_ennreal_le_coe_ennreal_iff._simp_1 | Mathlib.Data.EReal.Basic | ∀ {x y : ENNReal}, (↑x ≤ ↑y) = (x ≤ y) | false |
CategoryTheory.nerveFunctor.full | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | CategoryTheory.nerveFunctor.Full | true |
_private.Init.Data.String.Lemmas.Search.0.String.front_eq._simp_1_1 | Init.Data.String.Lemmas.Search | ∀ {s : String}, s.front = s.toSlice.front | false |
CategoryTheory.Presieve.BindStruct.hg | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Presieve X}
{R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {Z : C} {h : Z ⟶ X} (self : S.BindStruct R h),
R ⋯ self.g | true |
Pi.comul_coe_finsupp | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Type u_4}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : CoalgebraStruct R M] (x : n →₀ M),
CoalgebraStruct.comul ⇑x = (TensorProduct.map Finsupp.lcoeFun Finsupp.lcoeFun) (CoalgebraStruct.comul x) | true |
ModuleCat.monModuleEquivalenceAlgebraForget._proof_5 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : CategoryTheory.Mon (ModuleCat R)) (x : R)
(x_1 : ↑(ModuleCat.MonModuleEquivalenceAlgebra.functor.obj A)), id (x • x_1) = id (x • x_1) | false |
CategoryTheory.Subobject.Classifier.instUniqueHomΩ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {c : CategoryTheory.Subobject.Classifier C} → (Y : C) → Unique (Y ⟶ c.Ω₀) | true |
CategoryTheory.Limits.prod.mapIso_hom | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
(f : W ≅ Y) (g : X ≅ Z), (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_of_msb_false._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {p : Prop} [h : Decidable p], (false = decide p) = ¬p | false |
Lean.Server.Snapshots.Snapshot.recOn | Lean.Server.Snapshots | {motive : Lean.Server.Snapshots.Snapshot → Sort u} →
(t : Lean.Server.Snapshots.Snapshot) →
((stx : Lean.Syntax) →
(mpState : Lean.Parser.ModuleParserState) →
(cmdState : Lean.Elab.Command.State) → motive { stx := stx, mpState := mpState, cmdState := cmdState }) →
motive t | false |
AddLocalization.liftOn₂_mk | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M → ↥S → M → ↥S → p)
(H :
∀ {a a' : M} {b b' : ↥S} {c c' : M} {d d' : ↥S},
(AddLocalization.r S) (a, b) (a', b') → (AddLocalization.r S) (c, d) (c', d') → f a b c d = f a' b' c' d')
(a c : M) (b d : ↥S), (AddLocalization.mk... | true |
CategoryTheory.Functor.Monoidal.whiskerLeft_app_snd | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(F₁ : CategoryTheory.Functor J C) {F₂ F₂' : CategoryTheory.Functor J C} (g : F₂ ⟶ F₂') (j : J),
CategoryTheory.CategoryStruct.comp ((C... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Operations.0.SimpleGraph.Walk.exists_concat_eq_cons.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u w : V} (motive : (v : V) → G.Walk u v → G.Adj v w → Prop) (v : V)
(x : G.Walk u v) (x_1 : G.Adj v w),
(∀ (h : G.Adj u w), motive u SimpleGraph.Walk.nil h) →
(∀ (v v_1 : V) (h' : G.Adj u v_1) (p : G.Walk v_1 v) (h : G.Adj v w), motive v (SimpleGraph.Walk.cons h' p) h) →
... | false |
Polynomial.map_evalRingHom_eval | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p | true |
MulArchimedeanClass.mk_right_le_mk_mul_iff._simp_2 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk (a * b)) = (MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk a) | false |
Units.isOpenMap_val | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], IsOpenMap Units.val | true |
IsSemisimpleModule.recOn | Mathlib.RingTheory.SimpleModule.Basic | {R : Type u_2} →
[inst : Ring R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsSemisimpleModule R M → Sort u} →
(t : IsSemisimpleModule R M) →
([toComplementedLattice : ComplementedLattice (Submodule R M)] → motive ⋯) → motive ... | false |
Pi.instSub | Mathlib.Algebra.Notation.Pi.Defs | {ι : Type u_1} → {G : ι → Type u_4} → [(i : ι) → Sub (G i)] → Sub ((i : ι) → G i) | true |
_private.Mathlib.CategoryTheory.GlueData.0.CategoryTheory.GlueData.π_epi._proof_1 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (D : CategoryTheory.GlueData C)
[inst_1 : CategoryTheory.Limits.HasMulticoequalizer D.diagram] [inst_2 : CategoryTheory.Limits.HasColimits C],
CategoryTheory.Epi D.π | false |
Set.Definable.compl | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {s : Set (α → M)},
A.Definable L s → A.Definable L sᶜ | true |
PresheafOfModules.instIsLocalizationSheafOfModulesSheafificationInverseImageFunctorOppositeAbWToPresheaf | Mathlib.Algebra.Category.ModuleCat.Sheaf.Localization | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | true |
Std.DHashMap.get?_eq_some_getD | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {a : α}
{fallback : β a}, a ∈ m → m.get? a = some (m.getD a fallback) | true |
Finset.sup_eq_sSup_image | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (s : Finset α) (f : α → β), s.sup f = sSup (f '' ↑s) | true |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier | Mathlib.Algebra.Category.MonCat.Basic | CategoryTheory.ConcreteCategory AddCommMonCat fun x1 x2 => ↑x1 →+ ↑x2 | true |
Ordinal.typein_lt_nat | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (x : ℕ), (Ordinal.typein LT.lt).toRelEmbedding x = ↑x | true |
_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 | false |
_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) | 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... | true |
WCovBy.eq_or_covBy._to_dual_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ⩿ a → a = b ∨ b ⋖ a | 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... | true |
Fin.shiftLeft | Init.Data.Fin.Basic | {n : ℕ} → Fin n → Fin n → Fin n | 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 | 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 | false |
Mathlib.Tactic.Abel._aux_Mathlib_Tactic_Abel___macroRules_Mathlib_Tactic_Abel_abel1!_1 | Mathlib.Tactic.Abel | Lean.Macro | false |
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... | 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 | true |
Finset.nontrivial_iff_ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, a ∈ s → (s.Nontrivial ↔ s ≠ {a}) | true |
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 } | 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 | true |
pure_le_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X], pure ≤ nhds | 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) | false |
Lean.Elab.Term.MutualClosure.FixPoint.run | Lean.Elab.MutualDef | Array Lean.FVarId → Lean.Elab.Term.MutualClosure.UsedFVarsMap → Lean.Elab.Term.MutualClosure.UsedFVarsMap | 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₂)
... | 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 | 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) | 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 𝔓 | 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 | 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 | true |
Std.Do.SPred.true_intro | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs}, P ⊢ₛ ⌜True⌝ | 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 | false |
BoxIntegral.Box.Ioo_subset_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), BoxIntegral.Box.Ioo I ⊆ ↑I | true |
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 | 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... | true |
Subsemigroup.range_subtype | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (s : Subsemigroup M), (MulMemClass.subtype s).srange = s | true |
CochainComplex.isStrictlyGE_mappingCone._auto_1 | Mathlib.Algebra.Homology.HomotopyCategory.Plus | Lean.Syntax | false |
ValuationSubring.instFieldSubtypeMemTop._proof_4 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K], SubringClass (Subfield K) K | false |
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 | true |
Lean.Meta.instInhabitedUnificationHints.default | Lean.Meta.UnificationHint | Lean.Meta.UnificationHints | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_6 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} (a : ι) (l : List ι) (n : ℕ), n + 2 ≤ (a :: l).length → n + 1 < (a :: l).length | false |
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.... | true |
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 | true |
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... | 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 | 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 = [] | true |
Lean.Elab.ContextInfo.parentDecl?._default | Lean.Elab.InfoTree.Types | Option Lean.Name | false |
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 | 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... | false |
Associates.FactorSet.prod | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {α : Type u_1} → [inst : CommMonoidWithZero α] → Associates.FactorSet α → Associates α | 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 | true |
FirstOrder.Language.IsRelational | Mathlib.ModelTheory.Basic | FirstOrder.Language → Prop | 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 ... | 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... | false |
CategoryTheory.ShortComplex.moduleCat_exact_iff | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
S.Exact ↔
∀ (x₂ : ↑S.X₂),
(CategoryTheory.ConcreteCategory.hom S.g) x₂ = 0 → ∃ x₁, (CategoryTheory.ConcreteCategory.hom S.f) x₁ = x₂ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.