name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.RingTheory.Coalgebra.GroupLike.0.isGroupLikeElem_self._simp_1_1 | Mathlib.RingTheory.Coalgebra.GroupLike | ∀ (R : Type u_2) {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] (a : A),
IsGroupLikeElem R a = (CoalgebraStruct.counit a = 1 ∧ CoalgebraStruct.comul a = a ⊗ₜ[R] a) | null | false |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀_app_zero | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.fourδ₁Toδ₀ f₁ f₂ f₃ f₄ f₁₂ h₁₂).app 0 = f₁ | null | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.cond_simplify._regBuiltin.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.cond_simplify.declare_1._@.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.2756831831._hygCtx._hyg.17 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | IO Unit | null | false |
Combinatorics.Line._sizeOf_inst | Mathlib.Combinatorics.HalesJewett | (α : Type u_5) → (ι : Type u_6) → [SizeOf α] → [SizeOf ι] → SizeOf (Combinatorics.Line α ι) | null | false |
FiniteArchimedeanClass.lift_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {α : Type u_2}
(f : { a // a ≠ 0 } → α)
(h : ∀ (a b : { a // a ≠ 0 }), FiniteArchimedeanClass.mk ↑a ⋯ = FiniteArchimedeanClass.mk ↑b ⋯ → f a = f b) {a : M}
(ha : a ≠ 0), FiniteArchimedeanClass.lift f h (FiniteArchime... | null | true |
FirstOrder.Language.Sentence.cardGe.eq_1 | Mathlib.ModelTheory.Semantics | ∀ (L : FirstOrder.Language) (n : ℕ),
FirstOrder.Language.Sentence.cardGe L n =
(List.foldr (fun x1 x2 => x1 ⊓ x2) ⊤
(List.map
(fun ij =>
(((FirstOrder.Language.var ∘ Sum.inr) ij.1).bdEqual ((FirstOrder.Language.var ∘ Sum.inr) ij.2)).not)
(List.filter (fun ij => decide (ij.1... | null | true |
DirectLimit.NonUnitalStarRing.of._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonUnitalNonA... | null | false |
Subsemigroup.instCompleteLattice._proof_14 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] (x : Subsemigroup M), ∀ x_1 ∈ ⊥, x_1 ∈ x | null | false |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.instEncodableS | Mathlib.Tactic.DeriveEncodable | Encodable Mathlib.Deriving.Encodable.S✝ | null | true |
iSup_subtype' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {p : ι → Prop} {f : (i : ι) → p i → α},
⨆ i, ⨆ (h : p i), f i h = ⨆ x, f ↑x ⋯ | null | true |
BitVec.msb_twoPow | Init.Data.BitVec.Lemmas | ∀ {i w : ℕ}, (BitVec.twoPow w i).msb = (decide (i < w) && decide (i = w - 1)) | null | true |
GrpCat.SurjectiveOfEpiAuxs.tau._proof_1 | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B), ∃ y, y • ↑(GrpCat.Hom.hom f).range = ↑(GrpCat.Hom.hom f).range | null | false |
MulAction.isPreprimitive_stabilizer_of_surjective | Mathlib.GroupTheory.Perm.MaximalSubgroups | ∀ {M : Type u_1} {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] (s : Set α),
Function.Surjective MulAction.toPerm → MulAction.IsPreprimitive ↥(MulAction.stabilizer M s) ↑s | In the permutation group, the stabilizer of any set
acts primitively on that set. | true |
HomologicalComplex.dFrom_eq | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.dFrom i = CategoryTheory.CategoryStruct.comp (C.d i j) (C.xNextIso r).inv | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.entryAtIdx?.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | null | true |
Turing.PartrecToTM2.move₂ | Mathlib.Computability.TuringMachine.ToPartrec | (Turing.PartrecToTM2.Γ' → Bool) →
Turing.PartrecToTM2.K' → Turing.PartrecToTM2.K' → Turing.PartrecToTM2.Λ' → Turing.PartrecToTM2.Λ' | Move elements from `k₁` to `k₂` without reversion, by performing a double move via the `rev`
stack. | true |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Widget.UserWidget.577854155._hygCtx._hyg.1.recOn | Lean.Widget.UserWidget | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
(t : Lean.Widget.RpcEncodablePacket✝) → ((widgets : Lean.Json) → motive { widgets := widgets }) → motive t | null | false |
Mathlib.Notation3.mkScopedMatcher | Mathlib.Util.Notation3 | Lean.Name →
Lean.Name → Lean.Term → Array Lean.Name → OptionT Lean.Elab.TermElabM (List Mathlib.Notation3.DelabKey × Lean.Term) | Create a `Term` that represents a matcher for `scoped` notation.
Fails in the `OptionT` sense if a matcher couldn't be constructed.
Also returns a delaborator key like in `mkExprMatcher`.
Reminder: `$lit:ident : (scoped $scopedId:ident => $scopedTerm:Term)` | true |
_private.Mathlib.Algebra.Lie.Weights.Cartan.0.LieAlgebra.mem_zeroRootSubalgebra._simp_1_1 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ {R : Type u_2} {L : Type u_3} (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] (χ : L → R) (m : M),
(m ∈ LieModule.genWeightSpace M χ) = ∀ (x ... | null | false |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.model_distinctConstantsTheory._simp_1_1 | Mathlib.ModelTheory.Semantics | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
Ordinal.omega | Mathlib.SetTheory.Cardinal.Aleph | Ordinal.{u_1} ↪o Ordinal.{u_1} | The `omega` function gives the infinite initial ordinals listed by their ordinal index.
`omega 0 = ω`, `omega 1 = ω₁` is the first uncountable ordinal, and so on.
This is not to be confused with the first infinite ordinal `Ordinal.omega0`.
For a version including finite ordinals, see `Ordinal.preOmega`.
Conventions... | true |
AddChar.circleEquivComplex._proof_5 | Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Finite α] (ψ : AddChar α ℂ),
(fun ψ => AddChar.toMonoidHomEquiv.symm (Circle.coeHom.comp ψ.toMonoidHom))
((fun ψ => { toFun := fun a => ⟨ψ a, ⋯⟩, map_zero_eq_one' := ⋯, map_add_eq_mul' := ⋯ }) ψ) =
ψ | null | false |
Ideal.map_sup_comap_of_surjective | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[inst_3 : RingHomClass F R S],
Function.Surjective ⇑f → ∀ (I J : Ideal S), Ideal.map f (Ideal.comap f I ⊔ Ideal.comap f J) = I ⊔ J | null | true |
Lean.Parser.Term.subst.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Homeomorph.mulRight | Mathlib.Topology.Algebra.Group.Basic | {G : Type w} → [inst : TopologicalSpace G] → [inst_1 : Group G] → [SeparatelyContinuousMul G] → G → G ≃ₜ G | Multiplication from the right in a topological group as a homeomorphism. | true |
CategoryTheory.SimplicialObject.Splitting.toKaroubiNondegComplexIsoN₁_hom_f_PInfty_assoc | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C] {Z : ChainComplex C ℕ}
(h : AlgebraicTopology.AlternatingFaceMapComplex.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp s.toKaroubiNondegComplexIsoN₁.hom.... | null | true |
Batteries.Tactic.Lint.isAutoDecl | Batteries.Tactic.Lint.Basic | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → Lean.Name → m Bool | Returns true if `decl` is an automatically generated declaration.
Also returns true if `decl` is an internal name or created during macro
expansion.
See `Lean.Environment.isAutoDecl` for an identical pure version of this function on the environment.
| true |
CategoryTheory.Mon.tensorUnit_mul | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.MonObj.mul =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom | null | true |
Turing.TM2to1.trStmts₁.eq_3 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (k : K) (f : σ → Option (Γ k) → σ)
(q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2to1.trStmts₁ (Turing.TM2.Stmt.pop k f q) =
{Turing.TM2to1.Λ'.go k (Turing.TM2to1.StAct.pop f) q, Turing.TM2to1.Λ'.ret q} ∪ Turing.TM2to1.trStmts₁ q | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.proj._regBuiltin.Lean.Parser.Term.proj_1 | Lean.Parser.Term | IO Unit | null | false |
Module.DirectLimit.of._proof_3 | Mathlib.Algebra.Colimit.Module | ∀ (R : Type u_3) [inst : Semiring R] (ι : Type u_1) [inst_1 : Preorder ι] (G : ι → Type u_2)
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
[inst_4 : DecidableEq ι] (x : R) (x_1 : DirectSum ι G),
(↑(Module.DirectLimit.moduleCon f).mk').toFun (x... | null | false |
_private.Mathlib.Tactic.ClickSuggestions.Unfold.0.Mathlib.Tactic.ClickSuggestions.unfoldProjDefaultInst?.match_10 | Mathlib.Tactic.ClickSuggestions.Unfold | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((ci : Lean.ConstructorVal) → motive (some (Lean.ConstantInfo.ctorInfo ci))) →
((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave'_1 | Init.Tactics | Lean.Macro | Similar to `have`, but using `refine'` | false |
Real.analyticOn_cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {s : Set ℝ}, AnalyticOn ℝ Real.cos s | The function `Real.cos` is real analytic. | true |
DirectLimit.instMulDistribMulActionOfMulActionHomClass._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι... | null | false |
_private.Mathlib.CategoryTheory.Triangulated.Subcategory.0.CategoryTheory.ObjectProperty.extensionProduct_retractClosure_retractClosure_le._proof_1_3 | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] (A B : C)
(f₃ : B ⟶ (CategoryTheory.shiftFunctor C 1).obj A) (A' : C) (a₁ : A ⟶ A') (B' : C) (a₃ : B ⟶ B') (b₃ : B' ⟶ B),
CategoryTheory.CategoryStruct.comp a₃ b₃ = CategoryTheory.CategoryStruct.id B →
Category... | null | false |
Subgroup.rightCosetEquivSubgroup | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [inst : Group α] → {s : Subgroup α} → (g : α) → ↑(MulOpposite.op g • ↑s) ≃ ↥s | The natural bijection between a right coset `s * g` and `s`. | true |
Lean.CollectFVars.State.fvarIds._default | Lean.Util.CollectFVars | Array Lean.FVarId | null | false |
Lean.Lsp.instDecidableEqCompletionItemKind._proof_2 | Lean.Data.Lsp.LanguageFeatures | ∀ (x y : Lean.Lsp.CompletionItemKind), ¬x.ctorIdx = y.ctorIdx → x = y → False | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go.induct_unfolding | Init.Data.String.Pattern.String | ∀ (pat : String.Slice)
(motive :
(table : Array ℕ) →
0 < table.size →
table.size ≤ pat.utf8ByteSize →
(∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) → Vector ℕ pat.utf8ByteSize → Prop),
(∀ (table : Array ℕ) (ht₀ : 0 < table.size) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ)... | null | true |
RatFunc.instCommRing._proof_5 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u_1) [inst : CommRing K], Nat.unaryCast 0 = 0 | null | false |
HahnSeries.instIsScalarTower | Mathlib.RingTheory.HahnSeries.Addition | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] {V : Type u_8} [inst_1 : Monoid R] [inst_2 : AddMonoid V]
[inst_3 : DistribMulAction R V] {S : Type u_9} [inst_4 : Monoid S] [inst_5 : DistribMulAction S V] [inst_6 : SMul R S]
[IsScalarTower R S V], IsScalarTower R S (HahnSeries Γ V) | null | true |
Array.toListLitAux._f | Init.Data.Array.GetLit | {α : Type u_1} →
(xs : Array α) →
(n : ℕ) →
xs.size = n →
(x : ℕ) → Nat.below (motive := fun x => x ≤ xs.size → List α → List α) x → x ≤ xs.size → List α → List α | null | false |
Computation.liftRel_pure_right._simp_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (b : β),
Computation.LiftRel R ca (Computation.pure b) = ∃ a ∈ ca, R a b | null | false |
Lean.Parser.testParseFile | Lean.Parser.Module | Lean.Environment → System.FilePath → IO Lean.Syntax | null | true |
Set.Finite.eq_insert_of_subset_of_encard_eq_succ | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, s.Finite → s ⊆ t → t.encard = s.encard + 1 → ∃ a, t = insert a s | null | true |
Lean.Expr.getRevArg!._sunfold | Lean.Expr | Lean.Expr → ℕ → Lean.Expr | null | false |
Set.pi.eq_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Set ι) (t : (i : ι) → Set (α i)), s.pi t = {f | ∀ i ∈ s, f i ∈ t i} | null | true |
HomologicalComplex.homologyι_singleObjOpcyclesSelfIso_inv | Mathlib.Algebra.Homology.SingleHomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι) (j : ι)
(A : C),
CategoryTheory.CategoryStruct.comp (((HomologicalComplex.single C c j).obj A).... | null | true |
_private.Init.Data.List.Lemmas.0.List.map_eq_nil_iff.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} (motive : (l : List α) → List.map f l = [] → Prop) (l : List α)
(x : List.map f l = []), (∀ (x : List.map f [] = []), motive [] x) → motive l x | null | false |
CategoryTheory.Abelian.SpectralObject.d_d._auto_5 | Mathlib.Algebra.Homology.SpectralObject.Differentials | Lean.Syntax | null | false |
Array.countP_push_of_neg | Init.Data.Array.Count | ∀ {α : Type u_1} {p : α → Bool} {a : α} {xs : Array α}, ¬p a = true → Array.countP p (xs.push a) = Array.countP p xs | null | true |
Complex.HadamardThreeLines.norm_invInterpStrip | Mathlib.Analysis.Complex.Hadamard | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (f : ℂ → E) (z : ℂ) {ε : ℝ},
ε > 0 →
‖Complex.HadamardThreeLines.invInterpStrip f z ε‖ =
(ε + Complex.HadamardThreeLines.sSupNormIm f 0) ^ (z.re - 1) *
(ε + Complex.HadamardThreeLines.sSupNormIm f 1) ^ (-z.re) | Useful rewrite for the absolute value of `invInterpStrip` | true |
Submodule.moduleSubmodule._proof_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Submodule R M), 1 • b = b | null | false |
_private.Init.Meta.Defs.0.Lean.Syntax.getTailInfo?.match_1 | Init.Meta.Defs | (motive : Lean.Syntax → Sort u_1) →
(x : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive (Lean.Syntax.atom info val)) →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive (Lea... | null | false |
_private.Lean.DocString.Syntax.0.Lean.Doc.Syntax.link._regBuiltin.Lean.Doc.Syntax.link.docString_1 | Lean.DocString.Syntax | IO Unit | null | false |
Set.ncard_lt_card | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} [Finite α], s ≠ Set.univ → s.ncard < Nat.card α | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._simp_1_2 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : LT α] {x y : α}, (x > y) = (y < x) | null | false |
_private.Lean.Elab.MacroArgUtil.0.Lean.Elab.Command.expandMacroArg.mkSyntaxAndPat | Lean.Elab.MacroArgUtil | Option Lean.Ident → Lean.Term → Lean.TSyntax `stx → Lean.Elab.Command.CommandElabM (Lean.TSyntax `stx × Lean.Term) | null | true |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra.0.IntermediateField.algebraAdjoinAdjoin.instIsFractionRingSubtypeMemSubalgebraAdjoinAdjoin.match_3 | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ (F : Type u_2) [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E)
(motive : ↥(IntermediateField.adjoin F S) → Prop) (x : ↥(IntermediateField.adjoin F S)),
(∀ (val : E) (h : val ∈ IntermediateField.adjoin F S), motive ⟨val, h⟩) → motive x | null | false |
Odd.pow_injective | Mathlib.Algebra.Order.Ring.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [ExistsAddOfLE R] {n : ℕ},
Odd n → Function.Injective fun x => x ^ n | null | true |
CompHausLike.LocallyConstant.counitAppAppImage | Mathlib.Condensed.Discrete.LocallyConstant | {P : TopCat → Prop} →
[inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
{S : CompHausLike P} →
{Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} →
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] →
(f : LocallyConstant (↑S.toTop) (Y.o... | The projection of the counit. | true |
Finsupp.optionElim | Mathlib.Data.Finsupp.Option | {α : Type u_1} → {M : Type u_2} → [inst : Zero M] → M → (α →₀ M) → Option α →₀ M | Extend a finitely supported function on `α` to a finitely supported function on `Option α`,
provided a default value for `none`.
| true |
_private.Init.Data.UInt.Bitwise.0.UInt32.and_eq_neg_one_iff._simp_1_2 | Init.Data.UInt.Bitwise | ∀ {w : ℕ} {x y : BitVec w}, (x &&& y = BitVec.allOnes w) = (x = BitVec.allOnes w ∧ y = BitVec.allOnes w) | null | false |
Lean.Meta.Grind.Order.modify' | Lean.Meta.Tactic.Grind.Order.Types | (Lean.Meta.Grind.Order.State → Lean.Meta.Grind.Order.State) → Lean.Meta.Grind.GoalM Unit | null | true |
CategoryTheory.WideSubcategory.instMonoidalCategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : P.IsMonoidalStable]
{X₁ Y₁ X₂ Y₂ : CategoryTheory.WideSubcategory P} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
(CategoryTheory.wideSubcategoryInclusion P).map (CategoryT... | null | false |
_private.Lean.Parser.Extra.0.Lean.Parser.ppLine._regBuiltin.Lean.Parser.ppLine.docString_1 | Lean.Parser.Extra | IO Unit | null | false |
Set.isUnit_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : DivisionMonoid α] {s : Set α}, IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a | null | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.isIH._sparseCasesOn_1 | Lean.Meta.IndPredBelow | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Util.Diff.0.Lean.Diff.lcs.match_8 | Lean.Util.Diff | {α : Type} →
(left right : Subarray α) →
(motive : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right)) → Sort u_1) →
(best : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right))) →
((fst : ℕ) →
(v : α) →
(li : Fin (Std.Slice.size left)... | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkAndThenSeq._sunfold | Lean.Meta.Tactic.Grind.Split | List (Lean.TSyntax `grind) → Lean.CoreM (Lean.TSyntax `grind) | null | false |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse._proof_5 | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ} (φ : T₁ ⟶ T₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Pretriangulated.Triangle.mk T₂.mor₂.unop T₂.mor₁.unop
(CategoryTheory.Category... | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.finset_inf_span_singleton._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, (x ∈ Ideal.span {y}) = (y ∣ x) | null | false |
Lean.Level.imax.injEq | Lean.Level | ∀ (a a_1 a_2 a_3 : Lean.Level), (a.imax a_1 = a_2.imax a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
_private.Init.Data.SInt.Bitwise.0.Int16.shiftRight_or._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int16}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
fromModuleCatToModuleCatLinearEquivtoModuleCatObj.eq_1 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u) {ι : Type v} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι] (M : Type u_1)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] (i : ι),
fromModuleCatToModuleCatLinearEquivtoModuleCatObj R M i =
{
toFun :=
(AddEquiv.refl
↑(((ModuleCat.toMatrixModCat R ι).comp (... | null | true |
Pi.counit_comp_finsuppLcoeFun | 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],
CoalgebraStruct.counit ∘ₗ Finsupp.lcoeFun = CoalgebraStruct.counit | null | true |
CategoryTheory.Endofunctor.Algebra.Hom.mk.congr_simp | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} (f f_1 : A₀.a ⟶ A₁.a) (e_f : f = f_1)
(h : CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f),
{ f := f, h := h } = { f := f_1, h... | null | true |
FreeAddMonoid.lift_restrict | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : AddMonoid M] (f : FreeAddMonoid α →+ M),
FreeAddMonoid.lift (⇑f ∘ FreeAddMonoid.of) = f | null | true |
MultilinearMap.mk._flat_ctor | Mathlib.LinearAlgebra.Multilinear.Basic | {R : Type uR} →
{ι : Type uι} →
{M₁ : ι → Type v₁} →
{M₂ : Type v₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
... | null | false |
HomologicalComplex.singleMapHomologicalComplex_inv_app_ne | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] [inst_4 : CategoryTheory.Limits.HasZeroObject W₁]
[inst_5 : Cat... | null | true |
MvPolynomial.monomial_one_mul_cancel_right_iff | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p q : MvPolynomial σ R} {m : σ →₀ ℕ},
p * (MvPolynomial.monomial m) 1 = q * (MvPolynomial.monomial m) 1 ↔ p = q | null | true |
CategoryTheory.MonoidalCategoryStruct.recOn | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
[𝒞 : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.MonoidalCategoryStruct C → Sort u_1} →
(t : CategoryTheory.MonoidalCategoryStruct C) →
((tensorObj : C → C → C) →
(whiskerLeft : (X : C) → {Y₁ Y₂ : C} → (Y₁ ⟶ Y₂) → (tensorObj X Y₁ ⟶ tensorObj X Y₂)) →
... | null | false |
Encodable.decodeSum.eq_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable α] [inst_1 : Encodable β] (n : ℕ),
Encodable.decodeSum n =
match n.bodd, n.div2 with
| false, m => Option.map Sum.inl (Encodable.decode m)
| x, m => Option.map Sum.inr (Encodable.decode m) | null | true |
_private.Mathlib.Topology.ContinuousMap.StoneWeierstrass.0.ContinuousMap.ker_evalStarAlgHom_inter_adjoin_id._simp_1_5 | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
mul_isLeftRegular_iff._simp_2 | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : Semigroup R] {a : R} (b : R), IsLeftRegular a → IsLeftRegular (a * b) = IsLeftRegular b | null | false |
SemiRingCat.FilteredColimits.semiringObj._aux_8 | Mathlib.Algebra.Category.Ring.FilteredColimits | {J : Type u_1} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J SemiRingCat) →
(j : J) →
ℕ →
((F.comp (CategoryTheory.forget₂ SemiRingCat MonCat)).comp (CategoryTheory.forget MonCat)).obj j →
((F.comp (CategoryTheory.forget₂ SemiRingCat MonCat)).comp (C... | null | false |
Nat.map_add_toList_ric | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n k : ℕ}, List.map (fun x => x + k) (*...=n).toList = (k...=n + k).toList | null | true |
CoxeterMatrix.E₆._proof_2 | Mathlib.GroupTheory.Coxeter.Matrix | ∀ (i : Fin 6),
!![1, 2, 3, 2, 2, 2; 2, 1, 2, 3, 2, 2; 3, 2, 1, 3, 2, 2; 2, 3, 3, 1, 3, 2; 2, 2, 2, 3, 1, 3; 2, 2, 2, 2, 3, 1] i i = 1 | null | false |
Lean.Grind.PowIdentity.rec | Init.Grind.Ring.Basic | {α : Type u} →
[inst : Lean.Grind.CommSemiring α] →
{p : ℕ} →
{motive : Lean.Grind.PowIdentity α p → Sort u_1} →
((pow_eq : ∀ (x : α), x ^ p = x) → motive ⋯) → (t : Lean.Grind.PowIdentity α p) → motive t | null | false |
ZFSet.Hereditarily.eq_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (p : ZFSet.{u_1} → Prop) (x : ZFSet.{u_1}), ZFSet.Hereditarily p x = (p x ∧ ∀ y ∈ x, ZFSet.Hereditarily p y) | null | true |
scalarSMulCLE._proof_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ (H : Type u_1) [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H], ContinuousConstSMul ℂˣ H | null | false |
IsUniformInducing.isUltraUniformity | Mathlib.Topology.UniformSpace.Ultra.Completion | ∀ {X : Type u_1} {Y : Type u_2} [inst : UniformSpace X] [inst_1 : UniformSpace Y] [IsUltraUniformity Y] {f : X → Y},
IsUniformInducing f → IsUltraUniformity X | null | true |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._proof_28 | Mathlib.CategoryTheory.Bicategory.Monad.Basic | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B],
autoParam
(∀ {a b c : CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B} {f g : a ⟶ b} {h i : b ⟶ c} (η : f ⟶ g)
(θ : h ⟶ i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._aux_9 f θ)
(Categ... | null | false |
MeasureTheory.measurable_cylinderEvents_iff | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {α : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {mα : MeasurableSpace α} [m : (i : ι) → MeasurableSpace (X i)]
{Δ : Set ι} {g : α → (i : ι) → X i}, Measurable g ↔ ∀ ⦃i : ι⦄, i ∈ Δ → Measurable fun a => g a i | null | true |
CategoryTheory.InjectiveResolution.Hom.mk.injEq | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} {I : CategoryTheory.InjectiveResolution Z} {Z' : C}
{I' : CategoryTheory.InjectiveResolution Z'} {f : Z ⟶ Z'} (hom : I.cocomplex ⟶ I'.cocomplex)
(ι_... | null | true |
Quiver.Path.getElem_vertices_zero._proof_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {V : Type u_1} [inst : Quiver V] {a b : V} (p : Quiver.Path a b), 0 < p.vertices.length | null | false |
HomologicalComplex.natIsoSc'_inv_app_τ₂ | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i j k : ι) (hi : c.prev j = i) (hk : c.next j = k) (X : HomologicalComplex C c),
((HomologicalComplex.natIsoSc' C c i j k hi hk).inv.app X).τ₂ = CategoryTheory.Cate... | null | true |
Submodule.instIsModularLattice | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_10} {M : Type u_11} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsModularLattice (Submodule R M) | null | true |
isStarProjection_iff_eq_starProjection_range | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {p : E →L[𝕜] E},
IsStarProjection p ↔ ∃ (x : (↑p).range.HasOrthogonalProjection), p = (↑p).range.starProjection | An operator is a star projection if and only if it is an orthogonal projection. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.