name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Aesop.mkLocalRuleSet | Aesop.RuleSet | Array (Aesop.GlobalRuleSet × Lean.Name × Lean.Name) → Aesop.Options' → Lean.CoreM Aesop.LocalRuleSet |
_private.Lean.Elab.PreDefinition.TerminationMeasure.0.Lean.Elab.TerminationMeasure.structuralArg._sparseCasesOn_1 | Lean.Elab.PreDefinition.TerminationMeasure | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Set.definable_finset_sup | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {ι : Type u_2}
{f : ι → Set (α → M)}, (∀ (i : ι), A.Definable L (f i)) → ∀ (s : Finset ι), A.Definable L (s.sup f) |
Lean.Grind.Ring.OfSemiring.Q.ind | Init.Grind.Ring.Envelope | ∀ {α : Type u} [inst : Lean.Grind.Semiring α] {β : Lean.Grind.Ring.OfSemiring.Q α → Prop},
(∀ (a : α × α), β (Lean.Grind.Ring.OfSemiring.Q.mk a)) → ∀ (q : Lean.Grind.Ring.OfSemiring.Q α), β q |
CochainComplex.IsKProjective.homotopyZero_def | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) (hL : HomologicalComplex.Acyclic L) [inst_2 : K.IsKProjective],
CochainComplex.IsKProjective.homotopyZero f hL = ⋯.some |
CategoryTheory.Limits.spanIsoMk._auto_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | Lean.Syntax |
Lean.Parser.Command.GrindCnstr.notStrictValue.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer |
Mathlib.Tactic.ITauto.applyProof | Mathlib.Tactic.ITauto | Lean.MVarId → Lean.NameMap Lean.Expr → Mathlib.Tactic.ITauto.Proof → Lean.MetaM Unit |
OrderDual.btw | Mathlib.Order.Circular | (α : Type u_1) → [Btw α] → Btw αᵒᵈ |
Aesop.RuleApplication.mk | Aesop.RuleTac.Basic | Array Aesop.Subgoal →
Lean.Meta.SavedState → Option (Array Aesop.Script.LazyStep) → Option Aesop.Percent → Aesop.RuleApplication |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.VarMem_append._simp_1_2 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {a : α} {xs ys : Array α}, (a ∈ xs ++ ys) = (a ∈ xs ∨ a ∈ ys) |
SimplicialObject.Splitting.d | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : CategoryTheory.SimplicialObject C} →
(s : SimplicialObject.Splitting X) → [CategoryTheory.Preadditive C] → (i j : ℕ) → s.N i ⟶ s.N j |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get!_union_of_contains_eq_false_right._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.mkSparseCasesOn._sparseCasesOn_1 | Lean.Meta.Constructions.SparseCasesOn | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
instCountableFreeGroup | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u) [Countable α], Countable (FreeGroup α) |
Lean.Parser.Tactic.tacticHave' | Init.Tactics | Lean.ParserDescr |
OpenAddSubgroup.coe_toOpens | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {U : OpenAddSubgroup G}, ↑↑U = ↑U |
Lean.JsonRpc.MessageKind.notification.elim | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.MessageKind → Sort u} →
(t : Lean.JsonRpc.MessageKind) → t.ctorIdx = 1 → motive Lean.JsonRpc.MessageKind.notification → motive t |
NonUnitalStarSubalgebra.mem_toNonUnitalSubring._simp_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A] [inst_3 : Star A]
{S : NonUnitalStarSubalgebra R A} {x : A}, (x ∈ S.toNonUnitalSubring) = (x ∈ S) |
NonUnitalSubsemiringClass.toNonUnitalCommSemiring._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {S : Type u_2} (s : S) {R : Type u_1} [inst : NonUnitalCommSemiring R] [inst_1 : SetLike S R]
[inst_2 : NonUnitalSubsemiringClass S R] (x x_1 : ↥s), ↑(x * x_1) = ↑(x * x_1) |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.functorPushforward_monotone.match_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} {X : C}
(x : CategoryTheory.Presieve X) (x_1 : D) (x_2 : x_1 ⟶ F.obj X)
(motive : CategoryTheory.Presieve.functorPushforward F x x_2 → Prop)
(x_3 : CategoryTheory.Presieve.functorPushforward F x x_2),
(∀ (Z : C) (g : Z ⟶ X) (u : x_1 ⟶ F.obj Z) (hg : x g) (hf : x_2 = CategoryTheory.CategoryStruct.comp u (F.map g)),
motive ⋯) →
motive x_3 |
JoinedIn.mono | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {U V : Set X}, JoinedIn U x y → U ⊆ V → JoinedIn V x y |
Lean.Lsp.LeanFileProgressProcessingInfo.mk.inj | Lean.Data.Lsp.Extra | ∀ {range : Lean.Lsp.Range} {kind : Lean.Lsp.LeanFileProgressKind} {range_1 : Lean.Lsp.Range}
{kind_1 : Lean.Lsp.LeanFileProgressKind},
{ range := range, kind := kind } = { range := range_1, kind := kind_1 } → range = range_1 ∧ kind = kind_1 |
Std.Tactic.BVDecide.BVExpr.bitblast.mkFullAdderCarry._proof_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (lhs rhs cin : aig.Ref)
(hsub : aig.decls.size ≤ (aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.decls.size),
(aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.decls.size ≤
((aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.mkAndCached
{ lhs := (aig.mkXorCached { lhs := lhs, rhs := rhs }).ref, rhs := cin.cast hsub }).aig.decls.size |
_private.Mathlib.Analysis.InnerProductSpace.Projection.FiniteDimensional.0._aux_Mathlib_Analysis_InnerProductSpace_Projection_FiniteDimensional___unexpand_Inner_inner_1 | Mathlib.Analysis.InnerProductSpace.Projection.FiniteDimensional | Lean.PrettyPrinter.Unexpander |
SimpleGraph.Subgraph.instInfSet._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (s : Set G.Subgraph) {v w : V},
(∀ ⦃G' : G.Subgraph⦄, G' ∈ s → G'.Adj v w) ∧ G.Adj v w → v ∈ ⋂ i ∈ s, i.verts |
Condensed.lanPresheafNatIso | Mathlib.Condensed.Discrete.Colimit | {F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))} →
((S : Profinite) → CategoryTheory.Limits.IsColimit (F.mapCocone S.asLimitCone.op)) → (Condensed.lanPresheaf F ≅ F) |
_private.Mathlib.Algebra.Homology.CochainComplexOpposite.0.CochainComplex.homotopyUnop._proof_4 | Mathlib.Algebra.Homology.CochainComplexOpposite | ∀ (p p' : ℤ), p = p' → ComplexShape.embeddingUpIntDownInt.f p' = ComplexShape.embeddingUpIntDownInt.f p |
LieModule.genWeightSpace_zero_normalizer_eq_self | Mathlib.Algebra.Lie.Weights.Basic | ∀ (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], (LieModule.genWeightSpace M 0).normalizer = LieModule.genWeightSpace M 0 |
CategoryTheory.Localization.liftNatIso_hom | Mathlib.CategoryTheory.Localization.Predicate | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : L.IsLocalization W] (F₁ F₂ : CategoryTheory.Functor C E) (F₁' F₂' : CategoryTheory.Functor D E)
[h₁ : CategoryTheory.Localization.Lifting L W F₁ F₁'] [h₂ : CategoryTheory.Localization.Lifting L W F₂ F₂']
(e : F₁ ≅ F₂),
(CategoryTheory.Localization.liftNatIso L W F₁ F₂ F₁' F₂' e).hom =
CategoryTheory.Localization.liftNatTrans L W F₁ F₂ F₁' F₂' e.hom |
isZGroup_iff_exists_mulEquiv | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] [Finite G],
IsZGroup G ↔ ∃ N H φ x, IsCyclic ↥H ∧ IsCyclic ↥N ∧ (Nat.card ↥N).Coprime (Nat.card ↥H) |
Finset.noncommProd_mulSingle | Mathlib.Data.Finset.NoncommProd | ∀ {ι : Type u_2} {M : ι → Type u_6} [inst : (i : ι) → Monoid (M i)] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(x : (i : ι) → M i), Finset.univ.noncommProd (fun i => Pi.mulSingle i (x i)) ⋯ = x |
Topology.IsQuotientMap.trivializationOfSMulDisjoint.match_7 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_2} {X : Type u_1} {f : E → X} (U : Set E) (e : E) (motive : f e ∈ f '' U → Prop) (x : f e ∈ f '' U),
(∀ (e' : E) (he' : e' ∈ U) (hfe : f e' = f e), motive ⋯) → motive x |
CategoryTheory.pi.coconeOfCoconeCompEval | Mathlib.CategoryTheory.Limits.Pi | {I : Type v₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
{J : Type v₁} →
[inst_1 : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J ((i : I) → C i)} →
((i : I) → CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Pi.eval C i))) →
CategoryTheory.Limits.Cocone F |
CategoryTheory.ShortComplex.ShortExact.fIsKernel._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.ShortExact → CategoryTheory.Mono S.f |
Nat.getElem?_toArray_rio | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, (*...n).toArray[i]? = if i < n then some i else none |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_210 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] (w w_1 : α)
(h : List.idxOfNth w [] 1 + 1 ≤ (List.filter (fun x => decide (x = w_1)) []).length),
(List.findIdxs (fun x => decide (x = w_1)) [])[List.idxOfNth w [] 1] < [].length |
ENat.card_prod | Mathlib.SetTheory.Cardinal.Finite | ∀ (α : Type u_3) (β : Type u_4), ENat.card (α × β) = ENat.card α * ENat.card β |
_private.Mathlib.Data.Set.Image.0.Set.disjoint_image_left._simp_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u} {s t : Set α}, Disjoint s t = (s ∩ t = ∅) |
_private.Mathlib.Tactic.GCongr.Core.0.Lean.MVarId.gcongr.match_1 | Mathlib.Tactic.GCongr.Core | (motive : DoResultPR PUnit.{1} Bool PUnit.{1} → Sort u_1) →
(r : DoResultPR PUnit.{1} Bool PUnit.{1}) →
((a u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Bool) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r |
ModuleCat.forget₂AddCommGroup_reflectsLimitOfSize | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u} [inst : Ring R],
CategoryTheory.Limits.ReflectsLimitsOfSize.{t, v, w, w, max u (w + 1), w + 1}
(CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat) |
smul_left_cancel_iff._simp_2 | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : Group α] [inst_1 : MulAction α β] (g : α) {x y : β}, (g • x = g • y) = (x = y) |
Matrix.vecCons_inj._simp_1 | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {n : ℕ} {x y : α} {u v : Fin n → α}, (Matrix.vecCons x u = Matrix.vecCons y v) = (x = y ∧ u = v) |
LinearMap.ofAEval._proof_6 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_3} {A : Type u_4} {M : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] {N : Type u_1} [inst_7 : AddCommMonoid N] [inst_8 : Module R N]
[inst_9 : Module (Polynomial R) N] (f : M →ₗ[R] N),
(∀ (m : M), f (a • m) = Polynomial.X • f m) →
∀ (n : ℕ) (k : R),
(∀ (x : Module.AEval R M a),
(f ∘ₗ ↑(Module.AEval.of R M a).symm).toFun ((Polynomial.C k * Polynomial.X ^ n) • x) =
(RingHom.id (Polynomial R)) (Polynomial.C k * Polynomial.X ^ n) •
(f ∘ₗ ↑(Module.AEval.of R M a).symm).toFun x) →
∀ (m : Module.AEval R M a),
(f ∘ₗ ↑(Module.AEval.of R M a).symm).toFun ((Polynomial.C k * Polynomial.X ^ (n + 1)) • m) =
(RingHom.id (Polynomial R)) (Polynomial.C k * Polynomial.X ^ (n + 1)) •
(f ∘ₗ ↑(Module.AEval.of R M a).symm).toFun m |
Rat.sub | Init.Data.Rat.Basic | ℚ → ℚ → ℚ |
HopfAlgCat.MonoidalCategory.inducingFunctorData._proof_6 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (x : HopfAlgCat R),
(TensorProduct.mk R x.carrier (CategoryTheory.MonoidalCategoryStruct.tensorUnit (HopfAlgCat R)).carrier).compr₂ₛₗ
((fun x_1 => ↑x_1)
((CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)).map
(CategoryTheory.MonoidalCategoryStruct.rightUnitor x).hom).toBialgHom') =
(TensorProduct.mk R x.carrier (CategoryTheory.MonoidalCategoryStruct.tensorUnit (HopfAlgCat R)).carrier).compr₂ₛₗ
((fun x_1 => ↑x_1)
(((CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj
((CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)).obj x)
((CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)).obj
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (HopfAlgCat R))))).symm ≪≫
CategoryTheory.MonoidalCategory.tensorIso
(CategoryTheory.Iso.refl ((CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)).obj x))
(CategoryTheory.Iso.refl (CategoryTheory.MonoidalCategoryStruct.tensorUnit (BialgCat R))).symm) ≪≫
CategoryTheory.MonoidalCategoryStruct.rightUnitor
((CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)).obj x)).hom.toBialgHom') |
CategoryTheory.Limits.natTransIntoForgetCompFiberwiseColimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Grothendieck | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{H : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} H]
(G : CategoryTheory.Functor (CategoryTheory.Grothendieck F) H)
[inst_2 :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasColimit ((F.map f).toFunctor.comp ((CategoryTheory.Grothendieck.ι F Y).comp G))]
(x x_1 : CategoryTheory.Grothendieck F) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp (G.map f)
(CategoryTheory.Limits.colimit.ι ((CategoryTheory.Grothendieck.ι F x_1.base).comp G) x_1.fiber) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimit.ι ((CategoryTheory.Grothendieck.ι F x.base).comp G) x.fiber)
(((CategoryTheory.Grothendieck.forget F).comp (CategoryTheory.Limits.fiberwiseColimit G)).map f) |
CategoryTheory.BraidedCategory.Hexagon.functor₁₃₂ | Mathlib.CategoryTheory.Monoidal.Braided.Multifunctor | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.MonoidalCategory C] →
CategoryTheory.Functor C (CategoryTheory.Functor C (CategoryTheory.Functor C C)) |
jacobiTheta₂.eq_1 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (z τ : ℂ), jacobiTheta₂ z τ = ∑' (n : ℤ), jacobiTheta₂_term n z τ |
PeriodPair.mem_lattice | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {L : PeriodPair} {x : ℂ}, x ∈ L.lattice ↔ ∃ m n, ↑m * L.ω₁ + ↑n * L.ω₂ = x |
Std.Do._aux_Std_Do_PostCond___unexpand_Std_Do_PostCond_entails_1 | Std.Do.PostCond | Lean.PrettyPrinter.Unexpander |
DFinsupp.Lex.acc_zero | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop},
(∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0) → Acc (DFinsupp.Lex r s) 0 |
Algebra.FormallySmooth.liftOfSurjective.eq_1 | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {B : Type u_1}
[inst_3 : CommRing B] [inst_4 : Algebra R B] {C : Type u_4} [inst_5 : CommRing C] [inst_6 : Algebra R C]
[inst_7 : Algebra.FormallySmooth R A] (f : A →ₐ[R] C) (g : B →ₐ[R] C) (hg : Function.Surjective ⇑g)
(hg' : IsNilpotent (RingHom.ker ↑g)),
Algebra.FormallySmooth.liftOfSurjective f g hg hg' =
Algebra.FormallySmooth.lift (RingHom.ker ↑g) hg' ((↑(Ideal.quotientKerAlgEquivOfSurjective hg).symm).comp f) |
Lean.Omega.IntList.dvd_gcd | Init.Omega.IntList | ∀ (xs : Lean.Omega.IntList) (c : ℕ), (∀ {a : ℤ}, a ∈ xs → ↑c ∣ a) → c ∣ xs.gcd |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory.termπ_3 | Mathlib.MeasureTheory.Group.FundamentalDomain | Lean.ParserDescr |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_22 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls size : ℕ) (l r : Std.DTreeMap.Internal.Impl α β),
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(size + 0 ≤ 1 ∨ size ≤ 3 * 0 ∧ 0 ≤ 3 * size) ∧ ls = size + 1 + 0 →
¬l.size + 1 + r.size + 1 + 0 > 3 * 0 → False |
RingHom.Etale.toAlgebra | Mathlib.RingTheory.RingHom.Etale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] {f : R →+* S}, f.Etale → Algebra.Etale R S |
Finset.prod_insert_of_eq_one_if_notMem | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} {a : ι} [inst : CommMonoid M] {f : ι → M} [inst_1 : DecidableEq ι],
(a ∉ s → f a = 1) → ∏ x ∈ insert a s, f x = ∏ x ∈ s, f x |
BooleanSubalgebra.copy._proof_3 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (L : BooleanSubalgebra α) (s : Set α) (hs : s = ↑L), ⊥ ∈ (L.copy s ⋯).carrier |
codisjoint_bot._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] {a : α}, Codisjoint a ⊥ = (a = ⊤) |
RCLike.inv_re | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] (z : K), RCLike.re z⁻¹ = RCLike.re z / RCLike.normSq z |
MeasureTheory.Measure.AbsolutelyContinuous.add_left_iff | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ₁ μ₂ ν : MeasureTheory.Measure α},
(μ₁ + μ₂).AbsolutelyContinuous ν ↔ μ₁.AbsolutelyContinuous ν ∧ μ₂.AbsolutelyContinuous ν |
Matrix.comp_diagonal_diagonal | Mathlib.Data.Matrix.Composition | ∀ {I : Type u_1} {J : Type u_2} {R : Type u_5} [inst : DecidableEq I] [inst_1 : DecidableEq J] [inst_2 : Zero R]
(d : I → J → R),
(Matrix.comp I I J J R) (Matrix.diagonal fun i => Matrix.diagonal fun j => d i j) =
Matrix.diagonal fun ij => d ij.1 ij.2 |
iteratedDerivWithin_fun_id | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : ℕ} {x : 𝕜} {s : Set 𝕜},
x ∈ s → UniqueDiffOn 𝕜 s → iteratedDerivWithin n (fun x => x) s x = if n = 0 then x else if n = 1 then 1 else 0 |
MeasurableSpace.CountablySeparated.rec | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | {α : Type u_3} →
[inst : MeasurableSpace α] →
{motive : MeasurableSpace.CountablySeparated α → Sort u} →
((countably_separated : HasCountableSeparatingOn α MeasurableSet Set.univ) → motive ⋯) →
(t : MeasurableSpace.CountablySeparated α) → motive t |
PresheafOfModules.colimitPresheafOfModules_map | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
[inst_2 :
∀ {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.Limits.PreservesColimit (F.comp (PresheafOfModules.evaluation R Y))
(ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f)))]
[inst_3 : ∀ (X : Cᵒᵖ), CategoryTheory.Limits.HasColimit (F.comp (PresheafOfModules.evaluation R X))] {x Y : Cᵒᵖ}
(f : x ⟶ Y),
(PresheafOfModules.colimitPresheafOfModules F).map f =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimMap (F.whiskerLeft (PresheafOfModules.restriction R f)))
(CategoryTheory.preservesColimitIso (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f)))
(F.comp (PresheafOfModules.evaluation R Y))).inv |
CategoryTheory.ProjectiveResolution.extAddEquivCohomologyClass._proof_1 | Mathlib.CategoryTheory.Abelian.Projective.Ext | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.ProjectiveResolution X) {n : ℕ}
(x y : CochainComplex.HomComplex.CohomologyClass R.cochainComplex ((CochainComplex.singleFunctor C 0).obj Y) ↑n),
R.extEquivCohomologyClass.symm.toFun (x + y) =
R.extEquivCohomologyClass.symm.toFun x + R.extEquivCohomologyClass.symm.toFun y |
CategoryTheory.Functor.Elements.coconeπOpCompShrinkYonedaObj_pt | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.LocallySmall.{w, v₁, u₁} C]
(F : CategoryTheory.Functor C (Type w)) (X : C),
(CategoryTheory.Functor.Elements.coconeπOpCompShrinkYonedaObj F X).pt = F.obj X |
_private.Std.Data.Iterators.Lemmas.Consumers.Monadic.Set.0.Std.IterM.toExtTreeSet_eq_ofList._simp_1_3 | Std.Data.Iterators.Lemmas.Consumers.Monadic.Set | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {l : List α},
List.foldl (fun acc a => acc.insert a) ∅ l = Std.ExtTreeSet.ofList l cmp |
Lean.Meta.checkAssignment | Lean.Meta.ExprDefEq | Lean.MVarId → Array Lean.Expr → Lean.Expr → Lean.MetaM (Option Lean.Expr) |
GetElem.getElem.congr_simp | Init.GetElem | ∀ {coll : Type u} {idx : Type v} {elem : Type w} {valid : coll → idx → Prop} [self : GetElem coll idx elem valid]
(xs xs_1 : coll) (e_xs : xs = xs_1) (i i_1 : idx) (e_i : i = i_1) (h : valid xs i), xs[i] = xs_1[i_1] |
Aesop.Frontend.evalSaturate? | Aesop.Frontend.Saturate | Lean.Elab.Tactic.Tactic |
Lean.Elab.CommandContextInfo.fileMap | Lean.Elab.InfoTree.Types | Lean.Elab.CommandContextInfo → Lean.FileMap |
zero_le_four | Mathlib.Algebra.Order.Monoid.NatCast | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : Preorder α] [ZeroLEOneClass α] [AddLeftMono α], 0 ≤ 4 |
Aesop.NormM.Context.mk | Aesop.Search.Expansion.Norm | Aesop.Options' → Aesop.LocalRuleSet → Aesop.NormSimpContext → Aesop.NormM.Context |
_private.Mathlib.RingTheory.Localization.Module.0.IsLocalizedModule.linearIndependent_lift._simp_1_1 | Mathlib.RingTheory.Localization.Module | ∀ {M' : Type u_1} {α : Type u_2} [inst : MulOneClass M'] [inst_1 : SMul M' α] {S : Submonoid M'} (g : ↥S) (a : α),
↑g • a = g • a |
ENNReal.hasSum_coe._simp_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → NNReal} {r : NNReal}, HasSum (fun a => ↑(f a)) ↑r = HasSum f r |
_private.Init.Data.String.Lemmas.Pattern.Split.0.String.Slice.Pattern.Model.split._proof_7 | Init.Data.String.Lemmas.Pattern.Split | ∀ {s : String.Slice} (start : s.Pos) (h : ¬start = s.endPos), start ≤ start.next h |
Nat.mod_pow_succ | Init.Data.Nat.Mod | ∀ {x b k : ℕ}, x % b ^ (k + 1) = x % b ^ k + b ^ k * (x / b ^ k % b) |
FractionalIdeal.map_div | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
[inst_3 : IsFractionRing R₁ K] [inst_4 : IsDomain R₁] {K' : Type u_5} [inst_5 : Field K'] [inst_6 : Algebra R₁ K']
[inst_7 : IsFractionRing R₁ K'] (I J : FractionalIdeal (nonZeroDivisors R₁) K) (h : K ≃ₐ[R₁] K'),
FractionalIdeal.map (↑h) (I / J) = FractionalIdeal.map (↑h) I / FractionalIdeal.map (↑h) J |
Int8.ofInt_neg | Init.Data.SInt.Lemmas | ∀ (a : ℤ), Int8.ofInt (-a) = -Int8.ofInt a |
ProbabilityTheory.integral_tilted_mul_eq_mgf | Mathlib.Probability.Moments.Tilted | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ} {t : ℝ} {E : Type u_2}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (g : Ω → E),
(∫ (ω : Ω), g ω ∂μ.tilted fun x => t * X x) = ∫ (ω : Ω), (Real.exp (t * X ω) / ProbabilityTheory.mgf X μ t) • g ω ∂μ |
MeasureTheory.SimpleFunc.approxOn.congr_simp | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : PseudoEMetricSpace α]
[inst_2 : OpensMeasurableSpace α] [inst_3 : MeasurableSpace β] (f f_1 : β → α) (e_f : f = f_1) (hf : Measurable f)
(s s_1 : Set α) (e_s : s = s_1) (y₀ y₀_1 : α) (e_y₀ : y₀ = y₀_1) (h₀ : y₀ ∈ s)
[inst_4 : TopologicalSpace.SeparableSpace ↑s] (n n_1 : ℕ),
n = n_1 → MeasureTheory.SimpleFunc.approxOn f hf s y₀ h₀ n = MeasureTheory.SimpleFunc.approxOn f_1 ⋯ s_1 y₀_1 ⋯ n_1 |
LieSubmodule.restr_toSubmodule | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : LieAlgebra R L] (N : LieSubmodule R L M)
(H : LieSubalgebra R L), ↑(N.restr H) = ↑N |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.minKey?_alterKey_eq_self._simp_1_3 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {o : Option α}, (o.isNone = true) = (o = none) |
Turing.PartrecToTM2.unrev | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.Λ' → Turing.PartrecToTM2.Λ' |
CategoryTheory.Limits.Sigma.isoColimit.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete α) C)
[inst_1 : CategoryTheory.Limits.HasCoproduct fun j => X.obj { as := j }]
[inst_2 : CategoryTheory.Limits.HasColimit X],
CategoryTheory.Limits.Sigma.isoColimit X =
(CategoryTheory.Limits.coproductIsCoproduct' X).coconePointUniqueUpToIso (CategoryTheory.Limits.colimit.isColimit X) |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction.0.SSet.Truncated.liftOfStrictSegal_app_1._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | 1 ≤ 2 |
CategoryTheory.Abelian.LeftResolution.chainComplexMap_f_succ_succ._proof_1 | Mathlib.Algebra.Homology.LeftResolution.Basic | ∀ {A : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) {X Y : A} (f : X ⟶ Y) [inst_2 : ι.Full] [inst_3 : ι.Faithful]
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_5 : CategoryTheory.Abelian A] (n : ℕ),
CategoryTheory.CategoryStruct.comp (ι.map ((Λ.chainComplex X).d (n + 1) n)) (ι.map ((Λ.chainComplexMap f).f n)) =
CategoryTheory.CategoryStruct.comp (ι.map ((Λ.chainComplexMap f).f (n + 1)))
(ι.map ((Λ.chainComplex Y).d (n + 1) n)) |
WeierstrassCurve.Projective.Point.toAffine | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {F : Type u} → [inst : Field F] → (W : WeierstrassCurve.Projective F) → (Fin 3 → F) → W.toAffine.Point |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.nf_repr_split'._simp_1_3 | Mathlib.SetTheory.Ordinal.Notation | ONote.NF 0 = True |
MeasureTheory.exists_lt_lowerSemicontinuous_lintegral_ge | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] (μ : MeasureTheory.Measure α)
[μ.WeaklyRegular] [MeasureTheory.SigmaFinite μ] (f : α → NNReal),
Measurable f →
∀ {ε : ENNReal},
ε ≠ 0 → ∃ g, (∀ (x : α), ↑(f x) < g x) ∧ LowerSemicontinuous g ∧ ∫⁻ (x : α), g x ∂μ ≤ ∫⁻ (x : α), ↑(f x) ∂μ + ε |
Continuous.cfcₙ_fun._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax |
Topology.IsLocallyConstructible.isConstructible_of_subset_of_isCompact | Mathlib.Topology.Constructible | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s t : Set X} [PrespectralSpace X] [QuasiSeparatedSpace X],
Topology.IsLocallyConstructible s → s ⊆ t → IsCompact t → Topology.IsConstructible s |
List.splitLengths_nil | Mathlib.Data.List.SplitLengths | ∀ {α : Type u_1} (l : List α), [].splitLengths l = [] |
Ultrafilter.mk.inj | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_2} {toFilter : Filter α} {neBot' : toFilter.NeBot}
{le_of_le : ∀ (g : Filter α), g.NeBot → g ≤ toFilter → toFilter ≤ g} {toFilter_1 : Filter α}
{neBot'_1 : toFilter_1.NeBot} {le_of_le_1 : ∀ (g : Filter α), g.NeBot → g ≤ toFilter_1 → toFilter_1 ≤ g},
{ toFilter := toFilter, neBot' := neBot', le_of_le := le_of_le } =
{ toFilter := toFilter_1, neBot' := neBot'_1, le_of_le := le_of_le_1 } →
toFilter = toFilter_1 |
Valued.toUniformSpace | Mathlib.Topology.Algebra.Valued.ValuationTopology | {R : Type u} →
{inst : Ring R} →
{Γ₀ : outParam (Type v)} → {inst_1 : LinearOrderedCommGroupWithZero Γ₀} → [self : Valued R Γ₀] → UniformSpace R |
Nat.Partition.UniquePartitionZero._proof_2 | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ (x : Nat.Partition 0), x = default |
Set.notMem_Ioc_of_le | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b c : α}, c ≤ a → c ∉ Set.Ioc a b |
Order.Coframe.recOn | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
{motive : Order.Coframe α → Sort u} →
(t : Order.Coframe α) →
([toCompleteLattice : CompleteLattice α] →
[toSDiff : SDiff α] →
(sdiff_le_iff : ∀ (a b c : α), a \ b ≤ c ↔ a ≤ b ⊔ c) →
[toHNot : HNot α] →
(top_sdiff : ∀ (a : α), ⊤ \ a = ￢a) →
motive
{ toCompleteLattice := toCompleteLattice, toSDiff := toSDiff, sdiff_le_iff := sdiff_le_iff,
toHNot := toHNot, top_sdiff := top_sdiff }) →
motive t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.