name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
RBTree.RBNode.Balanced.below.red | Batteries.Recycling.RBTree.Basic | ∀ {α : Type u_1} {motive : (a : RBTree.RBNode α) → (a_1 : RBTree.RBColor) → (a_2 : ℕ) → a.Balanced a_1 a_2 → Prop}
{x : RBTree.RBNode α} {n : ℕ} {y : RBTree.RBNode α} {v : α} (a : x.Balanced RBTree.RBColor.black n)
(a_1 : y.Balanced RBTree.RBColor.black n),
RBTree.RBNode.Balanced.below a →
motive x RBTree.RBC... | null | true |
MvPFunctor.M.Path.child.injEq | Mathlib.Data.PFunctor.Multivariate.M | ∀ {n : ℕ} {P : MvPFunctor.{u} (n + 1)} (x : P.last.M) (a : P.A) (f : P.last.B a → P.last.M) (h : x.dest = ⟨a, f⟩)
(j : P.last.B a) (i : Fin2 n) (c : MvPFunctor.M.Path P (f j) i) (a_1 : P.A) (f_1 : P.last.B a_1 → P.last.M)
(h_1 : x.dest = ⟨a_1, f_1⟩) (j_1 : P.last.B a_1) (c_1 : MvPFunctor.M.Path P (f_1 j_1) i),
(M... | null | true |
Fin.zero_eq_top._simp_1 | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} [inst : NeZero n], (0 = ⊤) = (n = 1) | null | false |
CategoryTheory.ShortComplex.π₃._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(X : CategoryTheory.ShortComplex C), (CategoryTheory.CategoryStruct.id X).τ₃ = CategoryTheory.CategoryStruct.id X.X₃ | null | false |
AlgEquiv.instAlgEquivClass | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂], AlgEquivClass (A₁ ≃ₐ[R] A₂) R A₁ A₂ | null | true |
Subring.gc_map_comap | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (f : R →+* S),
GaloisConnection (Subring.map f) (Subring.comap f) | null | true |
_private.Init.Data.String.Lemmas.Pattern.Split.Basic.0.String.Slice.Pattern.Model.splitFromSteps.match_1.eq_1 | Init.Data.String.Lemmas.Pattern.Split.Basic | ∀ {s : String.Slice} (motive : List (String.Slice.Pattern.SearchStep s) → Sort u_1) (h_1 : Unit → motive [])
(h_2 :
(startPos endPos : s.Pos) →
(l : List (String.Slice.Pattern.SearchStep s)) →
motive (String.Slice.Pattern.SearchStep.rejected startPos endPos :: l))
(h_3 :
(p q : s.Pos) →
... | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.termH | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | Lean.ParserDescr | null | true |
CategoryTheory.GradedObject.ι_mapBifunctorComp₁₂MapObjIso_inv | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.cc._auto_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | Lean.Syntax | null | false |
Monoid.PushoutI.NormalWord.rcons._proof_1 | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_2} {G : ι → Type u_1} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (G i)] (i : ι) (p : Monoid.PushoutI.NormalWord.Pair d i) (i_1 : ι) (g : G i_1),
⟨i_1... | null | false |
BooleanSubalgebra.infClosed._simp_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] (L : BooleanSubalgebra α), InfClosed ↑L = True | null | false |
_private.Mathlib.LinearAlgebra.UnitaryGroup.0.Matrix.kronecker_mem_unitary._simp_1_9 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {α : Type u_1} {β : Type u_2} {p q : α × β}, (p = q) = (p.1 = q.1 ∧ p.2 = q.2) | null | false |
AlgebraicGeometry.HasAffineProperty.isLocal_affineProperty | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme)
{Q : outParam AlgebraicGeometry.AffineTargetMorphismProperty} [self : AlgebraicGeometry.HasAffineProperty P Q],
Q.IsLocal | null | true |
LinearMap.BilinMap.tensorDistrib._proof_20 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (A : Type u_1) {M₁ : Type u_2} [inst : CommSemiring A] [inst_1 : AddCommMonoid M₁] [inst_2 : Module A M₁],
IsScalarTower A A M₁ | null | false |
CategoryTheory.Limits.instIsLeftAdjointFunctorColim | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasColimitsOfShape J C], CategoryTheory.Limits.colim.IsLeftAdjoint | null | true |
MeasureTheory.L1.SimpleFunc.integralCLM'_L1_eq_integral | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} {𝕜 : Type u_4} [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_1 : NormedSpace ℝ E] [inst_2 : NormedRing 𝕜] [inst_3 : Module 𝕜 E]
[inst_4 : IsBoundedSMul 𝕜 E] [inst_5 : SMulCommClass ℝ 𝕜 E] [inst_6 : CompleteSpace E] (f : ↥(α →₁ₛ[μ] E)),... | null | true |
Std.Sat.AIG.RefVec.mk.congr_simp | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {w : ℕ}
(refs refs_1 : Vector Std.Sat.AIG.Fanin w) (e_refs : refs = refs_1)
(hrefs : ∀ {i : ℕ} (h : i < w), refs[i].gate < aig.decls.size),
{ refs := refs, hrefs := hrefs } = { refs := refs_1, hrefs := ⋯ } | null | true |
CategoryTheory.Functor.Elements.costructuredArrowULiftYonedaEquivalence._proof_6 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (F : CategoryTheory.Functor Cᵒᵖ (Type (max u_2 u_1)))
{X Y Z : CategoryTheory.CostructuredArrow CategoryTheory.uliftYoneda.{u_2, u_1, u_3} F} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.Functor.Elements.homMk
(CategoryTheory.CostructuredArrow.Hom.l... | null | false |
AffineIsometryEquiv.coe_vaddConst' | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_7} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] (p : P),
⇑(AffineEquiv.vaddConst 𝕜 p) = fun v => v +ᵥ p | null | true |
_private.Mathlib.Algebra.FreeAlgebra.0.FreeAlgebra.mk_mul | Mathlib.Algebra.FreeAlgebra | ∀ (R : Type u_1) (X : Type u_2) [inst : CommSemiring R] (x y : FreeAlgebra.Pre R X),
Quot.mk (FreeAlgebra.Rel R X) (x * y) = Quot.mk (FreeAlgebra.Rel R X) x * Quot.mk (FreeAlgebra.Rel R X) y | null | true |
Std.DTreeMap.Const.get_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k a : α} {h' : a ∈ t.erase k}, Std.DTreeMap.Const.get (t.erase k) a h' = Std.DTreeMap.Const.get t a ⋯ | null | true |
LinearEquiv.ofEq._proof_5 | Mathlib.Algebra.Module.Submodule.Equiv | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p q : Submodule R M) (h : p = q), Function.RightInverse (Set.equivOfEq ⋯).invFun (Set.equivOfEq ⋯).toFun | null | false |
Pi.inv_def | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : (i : ι) → Inv (G i)] (f : (i : ι) → G i), f⁻¹ = fun i => (f i)⁻¹ | null | true |
Lean.Parser.Command.quot | Lean.Parser.Command | Lean.Parser.Parser | Syntax quotation for (sequences of) commands.
The identical syntax for term quotations takes priority,
so ambiguous quotations like `` `($x $y) `` will be parsed as an application,
not two commands. Use `` `($x:command $y:command) `` instead.
Multiple commands will be put in a `` `null `` node,
but a single command wil... | true |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.isComplement_subgroup_left_iff_existsUnique_quotientMk''._simp_1_2 | Mathlib.GroupTheory.Complement | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
_private.Mathlib.Logic.Encodable.Basic.0.Encodable.decodeSum.match_1.splitter | Mathlib.Logic.Encodable.Basic | (motive : Bool → ℕ → Sort u_1) →
(x : Bool) →
(x_1 : ℕ) → ((m : ℕ) → motive false m) → ((x : Bool) → (m : ℕ) → (x = false → False) → motive x m) → motive x x_1 | null | true |
FormalGroup.𝔾ₐ._proof_2 | Mathlib.RingTheory.FormalGroup.Basic | ∀ {R : Type u_1} [inst : CommRing R], (MvPowerSeries.coeff fun₀ | 0 => 1) (MvPowerSeries.X 0 + MvPowerSeries.X 1) = 1 | null | false |
CategoryTheory.Functor.triangle | Mathlib.CategoryTheory.Whiskering | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B)
(G : CategoryTheory.Functor B C),
CategoryTheory.CategoryStruct.comp (F.associator (CategoryTheory.Fu... | null | true |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {motive : Mathlib.Tactic.BicategoryLike.WhiskerLeft → Sort u} →
((η : Mathlib.Tactic.BicategoryLike.HorizontalComp) → motive (Mathlib.Tactic.BicategoryLike.WhiskerLeft.of η)) →
((e : Mathlib.Tactic.BicategoryLike.Mor₂) →
(f : Mathlib.Tactic.BicategoryLike.Atom₁) →
(η : Mathlib.Tactic.BicategoryL... | null | false |
Std.DTreeMap.modify._proof_1 | Std.Data.DTreeMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} [inst : Std.LawfulEqCmp cmp] (t : Std.DTreeMap α β cmp)
(a : α) (f : β a → β a), (Std.DTreeMap.Internal.Impl.modify a f t.inner).WF | null | false |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.cellFrontier_one_eq._simp_1_3 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
Lean.Meta.SynthInstance.State.rec | Lean.Meta.SynthInstance | {motive : Lean.Meta.SynthInstance.State → Sort u} →
((result? : Option Lean.Meta.AbstractMVarsResult) →
(generatorStack : Array Lean.Meta.SynthInstance.GeneratorNode) →
(resumeStack : Array (Lean.Meta.SynthInstance.ConsumerNode × Lean.Meta.SynthInstance.Answer)) →
(tableEntries : Std.HashMap L... | null | false |
_private.Mathlib.GroupTheory.QuotientGroup.Basic.0.QuotientGroup.comap_comap_center._simp_1_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_4} [inst_1 : Group N] {K : Subgroup N} {f : G →* N} {x : G},
(x ∈ Subgroup.comap f K) = (f x ∈ K) | null | false |
IsMaxOn.norm_add_self | Mathlib.Analysis.Normed.Module.Extr | ∀ {α : Type u_1} {E : Type u_3} [inst : SeminormedAddCommGroup E] [NormedSpace ℝ E] {f : α → E} {s : Set α} {c : α},
IsMaxOn (norm ∘ f) s c → IsMaxOn (fun x => ‖f x + f c‖) s c | If `f : α → E` is a function such that `norm ∘ f` has a maximum on a set `s` at a point `c`,
then the function `fun x => ‖f x + f c‖` has a maximum on `s` at `c`. | true |
IsLocalRing.instOrderTopPrimeSpectrum | Mathlib.RingTheory.Spectrum.Prime.Topology | (R : Type u) → [inst : CommSemiring R] → [IsLocalRing R] → OrderTop (PrimeSpectrum R) | null | true |
Module.End.instDivisionRing._proof_6 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Module.End R M)] [inst_4 : IsSimpleModule R M] (q : ℚ≥0), ↑q = ↑q.num / ↑q.den | null | false |
NNReal.rpow_inv_rpow | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {y : ℝ}, y ≠ 0 → ∀ (x : NNReal), (x ^ y⁻¹) ^ y = x | null | true |
Int64.shiftRight_xor | Init.Data.SInt.Bitwise | ∀ {a b c : Int64}, (a ^^^ b) >>> c = a >>> c ^^^ b >>> c | null | true |
AddMemClass.toAddCommSemigroup._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : AddCommSemigroup M] {A : Type u_2} [inst_1 : SetLike A M] [inst_2 : AddMemClass A M] (S : A)
(a b : ↥S), a + b = b + a | null | false |
Std.Format.defIndent | Init.Data.Format.Basic | ℕ | The default indentation level, which is two spaces. | true |
Valuation.restrict_le_iff | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v.restrict x ≤ v.restrict y ↔ v x ≤ v y | null | true |
ProbabilityTheory.Kernel.indepFun_const_right | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {β : Type u_4} {β' : Type u_5} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
[ProbabilityTheory.IsZeroOrMarkovKernel κ] (X : Ω → β) (c : β'), ProbabilityTheory.Ker... | null | true |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.Clause.of_maxLiteral_eq_some._simp_1_4 | Std.Sat.CNF.RelabelFin | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.SplitEpi.map_section_ | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X Y : C} {f : X ⟶ Y} (se : CategoryTheory.SplitEpi f) (F : CategoryTheory.Functor C D),
(se.map F).section_ = F.map se.section_ | null | true |
CoheytingAlgebra.ctorIdx | Mathlib.Order.Heyting.Basic | {α : Type u_4} → CoheytingAlgebra α → ℕ | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs._proof_3 | Batteries.Data.List.Lemmas | ∀ {i : ℕ} {α : Type u_1} {xs : List α} {p : α → Bool},
i + 1 ≤ (List.findIdxs p xs).length → i < (List.findIdxs p xs).length | null | false |
Cardinal.ord_lt_omega0 | Mathlib.SetTheory.Ordinal.Basic | ∀ {a : Cardinal.{u_1}}, a.ord < Ordinal.omega0 ↔ a < Cardinal.aleph0 | null | true |
Commute.zpow_zpow_self₀ | Mathlib.Algebra.GroupWithZero.Semiconj | ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] (a : G₀) (m n : ℤ), Commute (a ^ m) (a ^ n) | null | true |
ULift.normedAddGroup | Mathlib.Analysis.Normed.Group.Constructions | {E : Type u_3} → [NormedAddGroup E] → NormedAddGroup (ULift.{u_6, u_3} E) | null | true |
HurwitzZeta.evenKernel_undef | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle) {x : ℝ}, x ≤ 0 → HurwitzZeta.evenKernel a x = 0 | For `x ≤ 0` the defining sum diverges, so the kernel is 0. | true |
Prod.instCompletelyDistribLattice._proof_3 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompletelyDistribLattice α] [inst_1 : CompletelyDistribLattice β] (a b : α × β),
Lattice.inf a b ≤ b | null | false |
Set.ordConnected_empty | Mathlib.Order.Interval.Set.OrdConnected | ∀ {α : Type u_1} [inst : Preorder α], ∅.OrdConnected | null | true |
ModuleCat.ihom_map_apply | Mathlib.Algebra.Category.ModuleCat.Monoidal.Closed | ∀ {R : Type u} [inst : CommRing R] {M N P : ModuleCat R} (f : N ⟶ P) (g : ↑↧(M ⟶ N)),
(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.ihom M).map f)) g = CategoryTheory.CategoryStruct.comp g f | null | true |
AffineEquiv.toEquiv_pointReflection | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (x : P₁), (AffineEquiv.pointReflection k x).toEquiv = Equiv.pointReflection x | null | true |
AlgebraicGeometry.morphismRestrictRestrictBasicOpen | Mathlib.AlgebraicGeometry.Restrict | {X Y : AlgebraicGeometry.Scheme} →
(f : X ⟶ Y) →
(U : Y.Opens) →
(r : ↑(Y.presheaf.obj (Opposite.op U))) →
CategoryTheory.Arrow.mk
(f ∣_ U ∣_
(↑U).basicOpen ((CategoryTheory.ConcreteCategory.hom (Y.presheaf.map (CategoryTheory.eqToHom ⋯).op)) r)) ≅
CategoryTheory.... | Restricting a morphism twice onto a basic open set is isomorphic to one restriction. | true |
Std.ExtDTreeMap.getEntryGT._proof_3 | Std.Data.ExtDTreeMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t : Std.ExtDTreeMap α β cmp)
(k : α) (h : ∃ a ∈ t, cmp a k = Ordering.gt) (x x_1 : Std.DTreeMap α β cmp) (x_2 : t = Std.ExtDTreeMap.mk x),
t = Std.ExtDTreeMap.mk x_1 → ∀ (h_1 : x.Equiv x_1), x.getEntryGT k ⋯ = x_1.getEntryGT k ⋯ | null | false |
_private.Lean.Elab.PreDefinition.MkInhabitant.0.Lean.Elab.mkInhabitantForAux?._sparseCasesOn_1 | Lean.Elab.PreDefinition.MkInhabitant | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.RepresentationTheory.Coinvariants.0.Representation.Coinvariants.lift._simp_4 | Mathlib.RepresentationTheory.Coinvariants | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range._simp_1_7 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
FreeAlgebra.Rel.add_compat_right | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] {a b c : FreeAlgebra.Pre R X},
FreeAlgebra.Rel R X a b → FreeAlgebra.Rel R X (c + a) (c + b) | null | true |
PointedCone.Face.instCompleteLattice._proof_3 | Mathlib.Geometry.Convex.Cone.Face.Lattice | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {C : PointedCone R M} (a b c : C.Face),
a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c | null | false |
Aesop.Hyp.mk.inj | Aesop.Forward.State | ∀ {fvarId? : Option Lean.FVarId} {subst : Aesop.Substitution} {fvarId?_1 : Option Lean.FVarId}
{subst_1 : Aesop.Substitution},
{ fvarId? := fvarId?, subst := subst } = { fvarId? := fvarId?_1, subst := subst_1 } →
fvarId? = fvarId?_1 ∧ subst = subst_1 | null | true |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.parseWith.match_1 | Std.Http.Protocol.H1 | (motive : Option ℕ → Sort u_1) →
(limit : Option ℕ) → ((limit : ℕ) → motive (some limit)) → ((x : Option ℕ) → motive x) → motive limit | null | false |
MvPowerSeries.Restricted.val_zero | Mathlib.RingTheory.MvPowerSeries.Restricted | ∀ {R : Type u_1} [inst : NormedRing R] {σ : Type u_2} [inst_1 : IsUltrametricDist R] (c : σ → ℝ), ↑0 = 0 | null | true |
Seminorm.comp._proof_2 | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_4} {𝕜₂ : Type u_3} {E : Type u_1} {E₂ : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SeminormedRing 𝕜₂]
{σ₁₂ : 𝕜 →+* 𝕜₂} [inst_2 : AddCommGroup E] [inst_3 : AddCommGroup E₂] [inst_4 : Module 𝕜 E] [inst_5 : Module 𝕜₂ E₂]
(p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂), (p.comp f.toAddMonoidHom).toFu... | null | false |
AddCommute.sub_sub_sub_comm | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b c d : G},
AddCommute b c → AddCommute (-b) d → AddCommute (-c) d → a - b - (c - d) = a - c - (b - d) | null | true |
IntermediateField.relfinrank_comap | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A : IntermediateField F E) (f : L →ₐ[F] E) (B : IntermediateField F L),
(IntermediateField.comap f A).relfinrank B = A.relfinrank (IntermediateField.map f B) | null | true |
Std.DTreeMap.Const.get?_union_of_not_mem_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{k : α}, k ∉ t₂ → Std.DTreeMap.Const.get? (t₁ ∪ t₂) k = Std.DTreeMap.Const.get? t₁ k | null | true |
Submodule.mem_mk._simp_1 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : AddSubmonoid M}
{x : M} (h : ∀ (c : R) {x : M}, x ∈ S.carrier → c • x ∈ S.carrier),
(x ∈ { toAddSubmonoid := S, smul_mem' := h }) = (x ∈ S) | null | false |
AddActionHom.prodMap._proof_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} {N : Type u_2} {σ : M → N}, CompTriple id σ σ | null | false |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.RxoIterator.toList_rxoIter._unary | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] {bound : α} (z : Std.DTreeMap.Internal.Zipper α β),
{ internalState := { iter := z, upper := bound } }.toList =
List.takeWhile (fun e => (compare e.fst bound).isLT) z.toList | null | false |
CategoryTheory.Pseudofunctor.DescentData.subtypeCompatibleHomEquiv._proof_9 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_1} {S : C}
{X : ι → C} (f : (i : ι) → X i ⟶ S) {M N : ↑(F.obj { as := Opposite.op S })},
Function.RightInverse (fun g => ⟨g.hom, ⋯⟩) fun φ => { hom ... | null | false |
IO.FileRight.casesOn | Init.System.IO | {motive : IO.FileRight → Sort u} →
(t : IO.FileRight) →
((user group other : IO.AccessRight) → motive { user := user, group := group, other := other }) → motive t | null | false |
NonUnitalSubsemiring.centralizer._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (s : Set R) {a b : R},
a ∈ s.centralizer → b ∈ s.centralizer → a + b ∈ s.centralizer | null | false |
DihedralGroup.orderOf_r_one | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ}, orderOf (DihedralGroup.r 1) = n | `r 1` has order `n`.
| true |
Lean.Lsp.Ipc.instFromJsonCallHierarchy | Lean.Data.Lsp.Ipc | Lean.FromJson Lean.Lsp.Ipc.CallHierarchy | null | true |
Bool.le_and | Mathlib.Data.Bool.Basic | ∀ {x y z : Bool}, x ≤ y → x ≤ z → x ≤ (y && z) | null | true |
instInhabitedAntisymmetrization._aux_1 | Mathlib.Order.Antisymmetrization | {α : Type u_1} → (r : α → α → Prop) → [inst : IsPreorder α r] → [Inhabited α] → Antisymmetrization α r | null | false |
CStarModule.inner_self_nonneg | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} {inst : NonUnitalSemiring A} {inst_1 : StarRing A} {inst_2 : Module ℂ A}
{inst_3 : AddCommGroup E} {inst_4 : Module ℂ E} {inst_5 : PartialOrder A} {inst_6 : SMul A E} {inst_7 : Norm A}
{inst_8 : Norm E} [self : CStarModule A E] {x : E}, 0 ≤ inner A x x | null | true |
Units.instFaithfulSMul | Mathlib.Algebra.Group.Action.Units | ∀ {M : Type u_3} {α : Type u_5} [inst : Monoid M] [inst_1 : SMul M α] [FaithfulSMul M α], FaithfulSMul Mˣ α | null | true |
Module.Relations.Solution.mk.sizeOf_spec | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] [inst_3 : SizeOf A] [inst_4 : SizeOf M] (var : relations.G → M)
(linearCombination_var_relation : ∀ (r : relations.R), (Finsupp.linearCombination A var) (relations.relation r) = 0),
sizeOf ... | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterMapWithPostcondition.match_3.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (it' : Std.IterM m β) (h : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.... | null | true |
Topology.RelCWComplex.isClosed_cellFrontier | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D] [T2Space X] {n : ℕ}
{i : Topology.RelCWComplex.cell C n}, IsClosed (Topology.RelCWComplex.cellFrontier n i) | null | true |
AlgCat.limitSemiring._aux_15 | Mathlib.Algebra.Category.AlgCat.Limits | {R : Type u_4} →
[inst : CommRing R] →
{J : Type u_3} →
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J (AlgCat R)) →
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections] →
(CategoryTheory.Limits.Types.Small.l... | null | false |
Lean.Meta.Grind.AC.EqCnstrProof.simp_ac.elim | Lean.Meta.Tactic.Grind.AC.Types | {motive_2 : Lean.Meta.Grind.AC.EqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.AC.EqCnstrProof) →
t.ctorIdx = 5 →
((lhs : Bool) →
(s : Lean.Grind.AC.Seq) →
(c₁ c₂ : Lean.Meta.Grind.AC.EqCnstr) → motive_2 (Lean.Meta.Grind.AC.EqCnstrProof.simp_ac lhs s c₁ c₂)) →
motive_2 t | null | false |
MeasurableSpace.DynkinSystem.GenerateHas.recOn | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} {s : Set (Set α)} {motive : (a : Set α) → MeasurableSpace.DynkinSystem.GenerateHas s a → Prop}
{a : Set α} (t : MeasurableSpace.DynkinSystem.GenerateHas s a),
(∀ (t : Set α) (a : t ∈ s), motive t ⋯) →
motive ∅ ⋯ →
(∀ {a : Set α} (a_1 : MeasurableSpace.DynkinSystem.GenerateHas s a), motive... | null | false |
Std.IterM.any_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β} {p : β → Bool},
Std.IterM.any p it = do
let __do_lift ← it.step
match ↑__do_lift.inflate wit... | null | true |
_private.Mathlib.Basic.Rel.0.SetRel.dom_eq_empty_iff._simp_1_1 | Mathlib.Basic.Rel | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.disjoint_conj._simp_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_4} {f : Equiv.Perm α} {x y : α}, (x = f⁻¹ y) = (f x = y) | null | false |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.Context.mk.injEq | Lean.Meta.Tactic.Simp.Types | ∀ (config : Lean.Meta.Simp.Config) (userConfig : Lean.Options) (zetaDeltaSet initUsedZetaDelta : Lean.FVarIdSet)
(metaConfig indexConfig : Lean.Meta.ConfigWithKey) (maxDischargeDepth : UInt32)
(simpTheorems : Lean.Meta.SimpTheoremsArray) (congrTheorems : Lean.Meta.SimpCongrTheorems)
(parent? : Option Lean.Expr) (... | null | true |
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.exists_algHom_adjoin_of_splits'._simp_1_2 | Mathlib.FieldTheory.Extension | ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {F' : Type u_3}
[inst_3 : Field F'] [inst_4 : Algebra F' E] {S S' : Set E},
(↑(IntermediateField.adjoin F S) ⊆ ↑(IntermediateField.adjoin F' S')) =
(Set.range ⇑(algebraMap F E) ⊆ ↑(IntermediateField.adjoin F' S') ∧ S ⊆ ↑(... | null | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.NormedSpace.0.HasMFDerivAt.smul | Mathlib.Geometry.Manifold.MFDeriv.NormedSpace | ∀ {𝕜 : 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] {x : M} {V : Type u_19} [inst_6 : Norme... | Given maps `f`, `g` from a manifold into a field `𝕜` and `𝕜`-vector space `V`, respectively, if
at some point `x`, `f` has differential `f' : TangentSpace I x →L[𝕜] 𝕜` and `g` has differential
`g' : TangentSpace I x →L[𝕜] V` (both phrased using the predicate `HasMFDerivAt`), it follows that
their scalar multiplica... | true |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.getRel._sparseCasesOn_2 | Mathlib.Tactic.GCongr.Core | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.List.Nat.Basic.0.List.dropLast.match_1.splitter._sparseCasesOn_4 | Init.Data.List.Nat.Basic | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CommAlgCat.instConcreteCategoryAlgHomCarrier._proof_3 | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {X : CommAlgCat R} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.posFittingComp_map_incl_sup_of_codisjoint._simp_1_3 | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [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] {N₁ N₂ : LieSubmodule R L M} {k : ℕ},
LieSubmodule.lcs k N₁ ⊔ LieSubmodule.lcs k N₂ = LieSubmodule.lcs k (N₁ ⊔ N₂) | null | false |
Subarray.toList_mkSlice_roo | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo hi : ℕ},
Std.Slice.toList (Std.Roo.Sliceable.mkSlice xs (lo<...hi)) = List.drop (lo + 1) (List.take hi (Std.Slice.toList xs)) | null | true |
AddCon.addConGen_le | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {r : M → M → Prop} {c : AddCon M}, addConGen r ≤ c ↔ r ≤ ⇑c | The smallest additive congruence relation containing a binary
relation `r` is contained in any additive congruence relation containing `r`. | true |
Set.mem_Ici_Ioi_of_subset_of_subset | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α} {s : Set α}, Set.Ioi a ⊆ s → s ⊆ Set.Ici a → s ∈ {Set.Ici a, Set.Ioi a} | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.