name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.derivedLitsInvariant_confirmRupHint._proof_1_14 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ (rupHints : Array ℕ) (i : Fin rupHints.size), ↑i + 1 ≤ rupHints.size → ↑i < rupHints.size |
Lean.Lsp.instToJsonChangeAnnotation.toJson | Lean.Data.Lsp.Basic | Lean.Lsp.ChangeAnnotation → Lean.Json |
Lean.Lsp.instFromJsonCallHierarchyPrepareParams.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.CallHierarchyPrepareParams |
HomologicalComplex.homotopyCofiber.XIsoBiprod.congr_simp | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel] (i j : ι) (hij : c.Rel i j)
[inst_4 : CategoryTheory.Limits.HasBinaryBiproduct (F.X j) (G.X i)],
HomologicalComplex.homotopyCofiber.XIsoBiprod φ i j hij = HomologicalComplex.homotopyCofiber.XIsoBiprod φ i j hij |
AntitoneOn.Ico | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f g : α → β} {s : Set α},
AntitoneOn f s → MonotoneOn g s → MonotoneOn (fun x => Set.Ico (f x) (g x)) s |
List.reduceOption_cons_of_some | Mathlib.Data.List.ReduceOption | ∀ {α : Type u_1} (x : α) (l : List (Option α)), (some x :: l).reduceOption = x :: l.reduceOption |
Ordinal.invVeblen₂_gamma | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), o.gamma.invVeblen₂ = 0 |
IsJordan.mk._flat_ctor | Mathlib.Algebra.Jordan.Basic | ∀ {A : Type u_1} [inst : Mul A],
(∀ (a b : A), a * b * a = a * (b * a)) →
(∀ (a b : A), a * a * (a * b) = a * (a * a * b)) →
(∀ (a b : A), a * a * (b * a) = a * a * b * a) →
(∀ (a b : A), a * b * (a * a) = a * (b * (a * a))) →
(∀ (a b : A), b * a * (a * a) = b * (a * a) * a) → IsJordan A |
_private.Mathlib.Data.Nat.ChineseRemainder.0.Nat.modEq_list_map_prod_iff._simp_1_2 | Mathlib.Data.Nat.ChineseRemainder | ∀ {k : ℕ} {l : List ℕ}, k.Coprime l.prod = ∀ n ∈ l, k.Coprime n |
_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) |
Combinatorics.Line._sizeOf_inst | Mathlib.Combinatorics.HalesJewett | (α : Type u_5) → (ι : Type u_6) → [SizeOf α] → [SizeOf ι] → SizeOf (Combinatorics.Line α ι) |
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 ⋯ |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_430 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g (g a)}.card) + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g (g a)}.card) <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
BitVec.msb_twoPow | Init.Data.BitVec.Lemmas | ∀ {i w : ℕ}, (BitVec.twoPow w i).msb = (decide (i < w) && decide (i = w - 1)) |
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 |
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 |
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 |
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 |
_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 |
Ordinal.omega | Mathlib.SetTheory.Cardinal.Aleph | Ordinal.{u_1} ↪o Ordinal.{u_1} |
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' := ⋯ }) ψ) =
ψ |
Batteries.Tactic.Lint.isAutoDecl | Batteries.Tactic.Lint.Basic | Lean.Name → Lean.CoreM Bool |
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 |
DirectLimit.instMulDistribMulActionOfMulActionHomClass._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : 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 : Nonempty ι]
[inst_5 : Monoid R] [inst_6 : (i : ι) → Monoid (G i)] [inst_7 : (i : ι) → MulDistribMulAction R (G i)]
[inst_8 : ∀ (i j : ι) (h : i ≤ j), MonoidHomClass (T h) (G i) (G j)]
[inst_9 : ∀ (i j : ι) (h : i ≤ j), MulActionHomClass (T h) R (G i) (G j)] (r : R),
r • ⟦⟨Classical.arbitrary ι, 1⟩⟧ = 1 |
Lean.CollectFVars.State.fvarIds._default | Lean.Util.CollectFVars | Array Lean.FVarId |
Lean.Lsp.instDecidableEqCompletionItemKind._proof_2 | Lean.Data.Lsp.LanguageFeatures | ∀ (x y : Lean.Lsp.CompletionItemKind), ¬x.ctorIdx = y.ctorIdx → x = y → False |
Lean.Server.Watchdog.WorkerState.ctorIdx | Lean.Server.Watchdog | Lean.Server.Watchdog.WorkerState → ℕ |
_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 : ℕ) (hi : i < table.size), table[i] ≤ i) (h_1 : table.size < pat.utf8ByteSize),
let patByte := pat.getUTF8Byte { byteIdx := table.size } h_1;
let dist :=
String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance✝ pat patByte table ht h
table[table.size - 1] ⋯;
motive (table.push ↑dist) ⋯ ⋯ ⋯
(String.Slice.Pattern.ForwardSliceSearcher.buildTable.go✝ pat (table.push ↑dist) ⋯ ⋯ ⋯) →
motive table ht₀ ht h
(String.Slice.Pattern.ForwardSliceSearcher.buildTable.go✝¹ pat (table.push ↑dist) ⋯ ⋯ ⋯)) →
(∀ (table : Array ℕ) (ht₀ : 0 < table.size) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (h_1 : ¬table.size < pat.utf8ByteSize),
motive table ht₀ ht h (Vector.mk table ⋯)) →
∀ (table : Array ℕ) (ht₀ : 0 < table.size) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i),
motive table ht₀ ht h (String.Slice.Pattern.ForwardSliceSearcher.buildTable.go✝² pat table ht₀ ht h) |
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) |
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 |
Lean.Parser.testParseFile | Lean.Parser.Module | Lean.Environment → System.FilePath → IO (Lean.TSyntax `Lean.Parser.Module.module) |
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 |
Lean.Expr.getRevArg!._sunfold | Lean.Expr | Lean.Expr → ℕ → Lean.Expr |
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).homologyι j)
(HomologicalComplex.singleObjOpcyclesSelfIso c j A).inv =
(HomologicalComplex.singleObjHomologySelfIso c j A).hom |
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 |
Submodule.moduleSubmodule._proof_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Submodule R M), 1 • b = b |
_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) |
_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) |
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 |
_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) |
Set.isUnit_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : DivisionMonoid α] {s : Set α}, IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.State.mk.inj | Lean.Compiler.LCNF.InferBorrow | ∀ {owned : Lean.FVarIdHashSet} {modified : Bool} {paramMap : Lean.Compiler.LCNF.ParamMap✝}
{owned_1 : Lean.FVarIdHashSet} {modified_1 : Bool} {paramMap_1 : Lean.Compiler.LCNF.ParamMap✝¹},
{ owned := owned, modified := modified, paramMap := paramMap } =
{ owned := owned_1, modified := modified_1, paramMap := paramMap_1 } →
owned = owned_1 ∧ modified = modified_1 ∧ paramMap = paramMap_1 |
_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 |
_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)) → (ri : Fin (Std.Slice.size right)) → motive (some (fst, v, li, ri))) →
((x : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right))) → motive x) → motive best |
AddSubgroup.Normal.hcongr_3 | Mathlib.GroupTheory.IsSubnormal | ∀ (A A' : Type u_2),
A = A' →
∀ (inst : AddGroup A) (inst' : AddGroup A'),
inst ≍ inst' → ∀ (H : AddSubgroup A) (H' : AddSubgroup A'), H ≍ H' → H.Normal ≍ H'.Normal |
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.CategoryStruct.comp
((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).unitIso.inv.app T₂.obj₁).unop
((CategoryTheory.shiftFunctor C 1).map T₂.mor₃.unop))).mor₂
φ.hom₁.unop =
CategoryTheory.CategoryStruct.comp φ.hom₂.unop
(CategoryTheory.Pretriangulated.Triangle.mk T₁.mor₂.unop T₁.mor₁.unop
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).unitIso.inv.app T₁.obj₁).unop
((CategoryTheory.shiftFunctor C 1).map T₁.mor₃.unop))).mor₂ |
_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) |
_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) |
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 (MatrixModCat.toModuleCat R i)).obj (ModuleCat.of R M))).toFun,
map_add' := ⋯, map_smul' := ⋯,
invFun :=
(AddEquiv.refl
↑(((ModuleCat.toMatrixModCat R ι).comp (MatrixModCat.toModuleCat R i)).obj (ModuleCat.of R M))).invFun,
left_inv := ⋯, right_inv := ⋯ } |
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 |
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 := ⋯ } |
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₂] →
(toFun : ((i : ι) → M₁ i) → M₂) →
(∀ [inst : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι) (x y : M₁ i),
toFun (Function.update m i (x + y)) =
toFun (Function.update m i x) + toFun (Function.update m i y)) →
(∀ [inst_5 : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι) (c : R) (x : M₁ i),
toFun (Function.update m i (c • x)) = c • toFun (Function.update m i x)) →
MultilinearMap R M₁ M₂ |
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 : CategoryTheory.Limits.HasZeroObject W₂] (F : CategoryTheory.Functor W₁ W₂)
[inst_6 : F.PreservesZeroMorphisms] (c : ComplexShape ι) [inst_7 : DecidableEq ι] {i j : ι},
i ≠ j → ∀ (X : W₁), ((HomologicalComplex.singleMapHomologicalComplex F c j).inv.app X).f i = 0 |
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 |
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₂)) →
(whiskerRight : {X₁ X₂ : C} → (X₁ ⟶ X₂) → (Y : C) → tensorObj X₁ Y ⟶ tensorObj X₂ Y) →
(tensorHom : {X₁ Y₁ X₂ Y₂ : C} → (X₁ ⟶ Y₁) → (X₂ ⟶ Y₂) → (tensorObj X₁ X₂ ⟶ tensorObj Y₁ Y₂)) →
(tensorUnit : C) →
(associator : (X Y Z : C) → tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z)) →
(leftUnitor : (X : C) → tensorObj tensorUnit X ≅ X) →
(rightUnitor : (X : C) → tensorObj X tensorUnit ≅ X) →
motive
{ tensorObj := tensorObj, whiskerLeft := whiskerLeft, whiskerRight := whiskerRight,
tensorHom := tensorHom, tensorUnit := tensorUnit, associator := associator,
leftUnitor := leftUnitor, rightUnitor := rightUnitor }) →
motive t |
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.boddDiv2 with
| (false, m) => Option.map Sum.inl (Encodable.decode m)
| (fst, m) => Option.map Sum.inr (Encodable.decode m) |
_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) |
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) |
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 |
Submodule.instIsModularLattice | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsModularLattice (Submodule R M) |
BoundedOrderHom.toOrderHom | Mathlib.Order.Hom.Bounded | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : BoundedOrder α] → [inst_3 : BoundedOrder β] → BoundedOrderHom α β → α →o β |
HomologicalComplex₂.totalFlipIso_hom_f_D₁ | Mathlib.Algebra.Homology.TotalComplexSymmetry | ∀ {C : Type u_1} {I₁ : Type u_2} {I₂ : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Preadditive C] {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
(K : HomologicalComplex₂ C c₁ c₂) (c : ComplexShape J) [inst_2 : TotalComplexShape c₁ c₂ c]
[inst_3 : TotalComplexShape c₂ c₁ c] [inst_4 : TotalComplexShapeSymmetry c₁ c₂ c] [inst_5 : K.HasTotal c]
[inst_6 : DecidableEq J] (j j' : J),
CategoryTheory.CategoryStruct.comp ((K.totalFlipIso c).hom.f j) (K.D₁ c j j') =
CategoryTheory.CategoryStruct.comp (K.flip.D₂ c j j') ((K.totalFlipIso c).hom.f j') |
CategoryTheory.Limits.HasImage.exists_image | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y}
[self : CategoryTheory.Limits.HasImage f], Nonempty (CategoryTheory.Limits.ImageFactorisation f) |
CategoryTheory.ShortComplex.homologyFunctorIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] [CategoryTheory.CategoryWithHomology C] [F.PreservesHomology]
(S : CategoryTheory.ShortComplex C), (S.map F).HasHomology |
Turing.ToPartrec.Code.fix.sizeOf_spec | Mathlib.Computability.TMConfig | ∀ (a : Turing.ToPartrec.Code), sizeOf a.fix = 1 + sizeOf a |
ContinuousMap.continuousAt | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β)) (x : α),
ContinuousAt (⇑f) x |
LinearMap.mapMatrix_neg | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {S : Type u_8} {α : Type u_11} {β : Type u_12} [inst : Semiring R]
[inst_1 : Semiring S] {σᵣₛ : R →+* S} [inst_2 : AddCommMonoid α] [inst_3 : AddCommGroup β] [inst_4 : Module R α]
[inst_5 : Module S β] (f : α →ₛₗ[σᵣₛ] β), (-f).mapMatrix = -f.mapMatrix |
CategoryTheory.Limits.Types.Pushout.Rel'.inr_inl | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂} (s : S),
CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inr (g s)) (Sum.inl (f s)) |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.formula3._simp_1_1 | Mathlib.NumberTheory.FLT.Three | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑a ^ n = ↑(a ^ n) |
RelSeries.last_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {β : Type u_2} {s : SetRel β β} (p : RelSeries r) (f : r.Hom s),
(p.map f).last = f p.last |
Matroid.IsBase.compl_isBase_of_dual | Mathlib.Combinatorics.Matroid.Dual | ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M✶.IsBase B → M.IsBase (M.E \ B) |
MeasureTheory.measure_union_lt_top_iff | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
μ (s ∪ t) < ⊤ ↔ μ s < ⊤ ∧ μ t < ⊤ |
Lean.PrettyPrinter.Parenthesizer.Context._sizeOf_1 | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer.Context → ℕ |
Lean.logInfo | Lean.Log | {m : Type → Type} →
[Monad m] → [Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadOptions m] → Lean.MessageData → m Unit |
ContinuousLinearEquiv.coe_inj | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
[inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] {e e' : M₁ ≃SL[σ₁₂] M₂}, ↑e = ↑e' ↔ e = e' |
Std.DTreeMap.isEmpty_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.keys.isEmpty = t.isEmpty |
Finset.sdiff_eq_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ \ s₂ = {x ∈ s₁ | x ∉ s₂} |
_private.Std.Data.TreeMap.Raw.Lemmas.0.Std.TreeMap.Raw.Equiv.trans.match_1_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp}
(motive : t₁.Equiv t₂ → t₂.Equiv t₃ → Prop) (x : t₁.Equiv t₂) (x_1 : t₂.Equiv t₃),
(∀ (h : t₁.inner.Equiv t₂.inner) (h' : t₂.inner.Equiv t₃.inner), motive ⋯ ⋯) → motive x x_1 |
Nat.twoStepInduction | Mathlib.Data.Nat.Init | {P : ℕ → Sort u_1} → P 0 → P 1 → ((n : ℕ) → P n → P (n + 1) → P (n + 2)) → (a : ℕ) → P a |
Fin.coe_divNat | Batteries.Data.Fin.Lemmas | ∀ {m n : ℕ} (i : Fin (m * n)), ↑i.divNat = ↑i / n |
Metric.hausdorffEDist_ne_top_of_nonempty_of_bounded | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α},
s.Nonempty → t.Nonempty → Bornology.IsBounded s → Bornology.IsBounded t → Metric.hausdorffEDist s t ≠ ⊤ |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.MonotoneOn.intervalIntegral_slope_le._proof_1_11 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {a b c : ℝ}, a ≤ b → ∀ x ∈ Set.Icc b (b + c), x ∈ Set.uIcc a (b + c) |
continuousAt_sign_of_neg | Mathlib.Topology.Instances.Sign | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : TopologicalSpace α] [inst_2 : PartialOrder α] [inst_3 : DecidableLT α]
[OrderTopology α] {a : α}, a < 0 → ContinuousAt (⇑SignType.sign) a |
_private.Lean.Meta.Tactic.Induction.0.Lean.MVarId.induction.match_1 | Lean.Meta.Tactic.Induction | (motive : Option ℕ → Sort u_1) →
(paramPos? : Option ℕ) → (Unit → motive none) → ((paramPos : ℕ) → motive (some paramPos)) → motive paramPos? |
PNat.XgcdType | Mathlib.Data.PNat.Xgcd | Type |
IsApproximateAddSubgroup.addSubgroup | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_2} [inst_1 : SetLike S G] [AddSubgroupClass S G] {H : S},
IsApproximateAddSubgroup 1 ↑H |
CommBialgCat.isoMk | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} →
[inst : CommRing R] →
{X Y : Type v} →
{x : CommRing X} →
{x_1 : CommRing Y} →
{x_2 : Bialgebra R X} → {x_3 : Bialgebra R Y} → (X ≃ₐc[R] Y) → (CommBialgCat.of R X ≅ CommBialgCat.of R Y) |
RestrictedProduct.continuous_eval | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} [inst : (i : ι) → TopologicalSpace (R i)]
(i : ι), Continuous fun x => x i |
Std.DTreeMap.Raw.size_le_size_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k}, t.size ≤ (t.insertIfNew k v).size |
Std.HashMap.values | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List β |
Std.HashMap.Raw.getKey?_filter_key | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → Bool} {k : α},
m.WF → (Std.HashMap.Raw.filter (fun k x => f k) m).getKey? k = Option.filter f (m.getKey? k) |
VSub.casesOn | Mathlib.Algebra.Notation.Defs | {G : Type u_1} →
{P : Type u_2} →
{motive : VSub G P → Sort u} → (t : VSub G P) → ((vsub : P → P → G) → motive { vsub := vsub }) → motive t |
Module.Basis.ofSplitExact._proof_3 | Mathlib.LinearAlgebra.Basis.Exact | ∀ {R : Type u_2} {M : Type u_4} {K : Type u_6} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup K] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R K] [inst_6 : Module R P]
{f : K →ₗ[R] M} {g : M →ₗ[R] P} {s : M →ₗ[R] K},
s ∘ₗ f = LinearMap.id →
Function.Exact ⇑f ⇑g →
∀ {ι : Type u_5} {κ : Type u_1} {a : κ → ι} (v : Module.Basis ι R M),
Function.Injective a → (∀ (i : κ), s (v (a i)) = 0) → LinearIndependent R (⇑g ∘ ⇑v ∘ a) |
Std.IterM.mk.injEq | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} (internalState internalState_1 : α),
({ internalState := internalState } = { internalState := internalState_1 }) = (internalState = internalState_1) |
AddAut.conj._proof_6 | Mathlib.Algebra.Group.End | ∀ {G : Type u_1} [inst : AddGroup G] (g₁ g₂ : G),
Additive.ofMul
{ toFun := fun h => g₁ + g₂ + h + -(g₁ + g₂), invFun := fun h => -(g₁ + g₂) + h + (g₁ + g₂), left_inv := ⋯,
right_inv := ⋯, map_add' := ⋯ } =
Additive.ofMul
{ toFun := fun h => g₁ + h + -g₁, invFun := fun h => -g₁ + h + g₁, left_inv := ⋯, right_inv := ⋯,
map_add' := ⋯ } +
Additive.ofMul
{ toFun := fun h => g₂ + h + -g₂, invFun := fun h => -g₂ + h + g₂, left_inv := ⋯, right_inv := ⋯,
map_add' := ⋯ } |
CategoryTheory.WithInitial.mapId | Mathlib.CategoryTheory.WithTerminal.Basic | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
CategoryTheory.WithInitial.map (CategoryTheory.Functor.id C) ≅
CategoryTheory.Functor.id (CategoryTheory.WithInitial C) |
Lean.Elab.Command.Scope.varUIds._default | Lean.Elab.Command.Scope | Array Lean.Name |
CategoryTheory.ShortComplex.Splitting.ofIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (s : S₁.Splitting) (e : S₁ ≅ S₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp e.inv.τ₃ (CategoryTheory.CategoryStruct.comp s.s e.hom.τ₂)) S₂.g =
CategoryTheory.CategoryStruct.id S₂.X₃ |
Lean.Grind.Ring.neg_zsmul | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Ring α] (i : ℤ) (a : α), -i • a = -(i • a) |
Lean.Meta.RefinedDiscrTree.Key.labelledStar.noConfusion | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {P : Sort u} →
{id id' : ℕ} →
Lean.Meta.RefinedDiscrTree.Key.labelledStar id = Lean.Meta.RefinedDiscrTree.Key.labelledStar id' →
(id = id' → P) → P |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.