name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Batteries.Lean.EStateM.0.EStateM.bind.match_1.splitter | Batteries.Lean.EStateM | {ε σ α : Type u_1} →
(motive : EStateM.Result ε σ α → Sort u_2) →
(x : EStateM.Result ε σ α) →
((a : α) → (s : σ) → motive (EStateM.Result.ok a s)) →
((e : ε) → (s : σ) → motive (EStateM.Result.error e s)) → motive x |
Substring.Raw.Valid.drop | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → ∀ (n : ℕ), (s.drop n).Valid |
LocallyConstant.coe_const | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (y : Y), ⇑(LocallyConstant.const X y) = Function.const X y |
AffineSubspace.coe_direction_eq_vsub_set_right | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P}, p ∈ s → ↑s.direction = (fun x => x -ᵥ p) '' ↑s |
EckmannHilton.IsUnital | Mathlib.GroupTheory.EckmannHilton | {X : Type u} → (X → X → X) → X → Prop |
AlgebraicGeometry.instUniversallyClosedToImage | Mathlib.AlgebraicGeometry.Morphisms.Proper | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.UniversallyClosed f],
AlgebraicGeometry.UniversallyClosed (AlgebraicGeometry.Scheme.Hom.toImage f) |
LocallyBoundedMap.instFunLike._proof_1 | Mathlib.Topology.Bornology.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : Bornology α] [inst_1 : Bornology β] (f g : LocallyBoundedMap α β),
(fun f => f.toFun) f = (fun f => f.toFun) g → f = g |
RootPairing.GeckConstruction.ωConj | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{P : RootPairing ι R M N} →
(b : P.Base) →
[inst_5 : DecidableEq ι] →
[inst_6 : Fintype ι] →
Matrix (↥b.support ⊕ ι) (↥b.support ⊕ ι) R ≃ₗ⁅R⁆ Matrix (↥b.support ⊕ ι) (↥b.support ⊕ ι) R |
_private.Lean.Server.FileWorker.0.Lean.Server.FileWorker.importsLoadedRef | Lean.Server.FileWorker | IO.Ref Bool |
Lean.Elab.Term.Quotation.match_syntax.expand | Lean.Elab.Quotation | Lean.Syntax → Lean.Elab.TermElabM Lean.Syntax |
_private.Mathlib.Computability.DFA.0.DFA.acceptsFrom_inter._simp_1_2 | Mathlib.Computability.DFA | ∀ {α : Type u_1} {x : List α} {l m : Language α}, (x ∈ l ⊓ m) = (x ∈ l ∧ x ∈ m) |
Lean.Compiler.LCNF.Decl.lambdaLifting | Lean.Compiler.LCNF.LambdaLifting | Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure →
Bool →
Bool →
Lean.Name →
optParam Bool false →
optParam ℕ 0 → Lean.Compiler.LCNF.CompilerM (Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) |
PartOrdEmb.coe_comp | Mathlib.Order.Category.PartOrdEmb | ∀ {X Y Z : PartOrdEmb} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors.0.UniqueFactorizationMonoid.normalizedFactorsEquiv._simp_3 | Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Monoid M] [inst_1 : Monoid N] {x : M} [inst_2 : EquivLike F M N]
[MulEquivClass F M N] (f : F), Irreducible (f x) = Irreducible x |
Turing.Dir.right | Mathlib.Computability.TuringMachine.Tape | Turing.Dir |
_private.Mathlib.Order.CompleteBooleanAlgebra.0.sSup_disjoint_iff._simp_1_2 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (iSup s = ⊥) = ∀ (i : ι), s i = ⊥ |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_sUnion_le.match_1_3 | Mathlib.SetTheory.ZFC.Rank | ∀ (x : PSet.{u_1}) ⦃y : PSet.{u_1}⦄ (motive : (∃ z ∈ x, y ∈ z) → Prop) (h : ∃ z ∈ x, y ∈ z),
(∀ (w : PSet.{u_1}) (left : w ∈ x) (right : y ∈ w), motive ⋯) → motive h |
Ring.DirectLimit.hom_ext | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] {g₁ g₂ : Ring.DirectLimit G f →+* P},
(∀ (i : ι), g₁.comp (Ring.DirectLimit.of G f i) = g₂.comp (Ring.DirectLimit.of G f i)) → g₁ = g₂ |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.Term.listDecode_encode_list._simp_1_9 | Mathlib.ModelTheory.Encoding | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : LE α] [CanonicallyOrderedAdd α] (a : α), (0 ≤ a) = True |
_private.Mathlib.CategoryTheory.Comma.StructuredArrow.Small.0.CategoryTheory.StructuredArrow.small_inverseImage_proj_of_locallySmall._simp_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Small | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {ι : Type u'} (X : ι → C) (Y : C),
CategoryTheory.ObjectProperty.ofObj X Y = ∃ i, X i = Y |
CoeHTCT.mk.noConfusion | Init.Coe | {α : Sort u} →
{β : Sort v} → {P : Sort u_1} → {coe coe' : α → β} → { coe := coe } = { coe := coe' } → (coe ≍ coe' → P) → P |
CategoryTheory.MonadicRightAdjoint.recOn | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
{motive : CategoryTheory.MonadicRightAdjoint R → Sort u} →
(t : CategoryTheory.MonadicRightAdjoint R) →
((L : CategoryTheory.Functor C D) →
(adj : L ⊣ R) →
(eqv : (CategoryTheory.Monad.comparison adj).IsEquivalence) →
motive { L := L, adj := adj, eqv := eqv }) →
motive t |
CentroidHom.instRing._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α], SMulCommClass ℕ α α |
LieRing.ofAssociativeRing | Mathlib.Algebra.Lie.OfAssociative | {A : Type v} → [Ring A] → LieRing A |
TensorProduct.finsuppRight | Mathlib.LinearAlgebra.DirectSum.Finsupp | (R : Type u_1) →
(S : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : Semiring S] →
[inst_2 : Algebra R S] →
(M : Type u_3) →
[inst_3 : AddCommMonoid M] →
[inst_4 : Module R M] →
[inst_5 : Module S M] →
[inst_6 : IsScalarTower R S M] →
(N : Type u_4) →
[inst_7 : AddCommMonoid N] →
[inst_8 : Module R N] →
(ι : Type u_5) → [DecidableEq ι] → TensorProduct R M (ι →₀ N) ≃ₗ[S] ι →₀ TensorProduct R M N |
CategoryTheory.ShortComplex.isColimitColimitCocone | Mathlib.Algebra.Homology.ShortComplex.Limits | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
(F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)) →
[inst_3 : CategoryTheory.Limits.HasColimit (F.comp CategoryTheory.ShortComplex.π₁)] →
[inst_4 : CategoryTheory.Limits.HasColimit (F.comp CategoryTheory.ShortComplex.π₂)] →
[inst_5 : CategoryTheory.Limits.HasColimit (F.comp CategoryTheory.ShortComplex.π₃)] →
CategoryTheory.Limits.IsColimit (CategoryTheory.ShortComplex.colimitCocone F) |
Mathlib.Command.MinImports.getSyntaxNodeKinds._unsafe_rec | Mathlib.Tactic.MinImports | Lean.Syntax → Lean.NameSet |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas.0.RootPairing.RootPositiveForm.rootLength_le_of_pairingIn_eq._proof_1_6 | Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_6 : CharZero R], FaithfulSMul ℤ R |
Aesop.instInhabitedGoalId.default | Aesop.Tree.Data | Aesop.GoalId |
Lean.Parser.getAlias | Lean.Parser.Extension | {α : Type} → IO.Ref (Lean.Parser.AliasTable α) → Lean.Name → IO (Option (Lean.Parser.AliasValue α)) |
Lean.Data.AC.ContextInformation.mk | Init.Data.AC | {α : Sort u} → (α → ℕ → Bool) → (α → Bool) → (α → Bool) → Lean.Data.AC.ContextInformation α |
Lean.Meta.Grind.AC.ProofM | Lean.Meta.Tactic.Grind.AC.Proof | Type → Type |
Filter.cardinalInterFilter_sup | Mathlib.Order.Filter.CardinalInter | ∀ {α : Type u} (l₁ l₂ : Filter α) {c₁ c₂ : Cardinal.{u}} [CardinalInterFilter l₁ c₁] [CardinalInterFilter l₂ c₂],
CardinalInterFilter (l₁ ⊔ l₂) (min c₁ c₂) |
ContDiffWithinAt.mono | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞}, ContDiffWithinAt 𝕜 n f s x → ∀ {t : Set E}, t ⊆ s → ContDiffWithinAt 𝕜 n f t x |
Qq.Impl.mkNAryFunctionType._unsafe_rec | Qq.Match | ℕ → Lean.MetaM Lean.Expr |
_private.Mathlib.Analysis.SpecificLimits.Basic.0.tendsto_nat_floor_atTop._simp_1_1 | Mathlib.Analysis.SpecificLimits.Basic | ∀ {α : Type u_2} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : FloorSemiring α] {a : α} {n : ℕ},
0 ≤ a → (n ≤ ⌊a⌋₊) = (↑n ≤ a) |
CategoryTheory.MonadIso.toNatIso | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → {M N : CategoryTheory.Monad C} → (M ≅ N) → (M.toFunctor ≅ N.toFunctor) |
TopModuleCat.noConfusionType | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | Sort u_1 →
{R : Type u} →
[inst : Ring R] →
[inst_1 : TopologicalSpace R] →
TopModuleCat R →
{R' : Type u} → [inst' : Ring R'] → [inst'_1 : TopologicalSpace R'] → TopModuleCat R' → Sort u_1 |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Finite.0.SimpleGraph.odd_ncard_oddComponents._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Finite | ∀ {α : Type u_1} (s : Set α) [inst : Fintype ↑s], s.toFinset.card = s.ncard |
imaginaryPart_smul | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [inst_3 : StarModule ℂ A]
(z : ℂ) (a : A), imaginaryPart (z • a) = z.re • imaginaryPart a + z.im • realPart a |
Quiver.rec | Mathlib.Combinatorics.Quiver.Basic | {V : Type u} →
{motive : Quiver V → Sort u_1} → ((Hom : V → V → Type v) → motive { Hom := Hom }) → (t : Quiver V) → motive t |
AddSemigroupAction.mk | Mathlib.Algebra.Group.Action.Defs | {G : Type u_9} →
{P : Type u_10} →
[inst : AddSemigroup G] →
[toVAdd : VAdd G P] → (∀ (g₁ g₂ : G) (p : P), (g₁ + g₂) +ᵥ p = g₁ +ᵥ g₂ +ᵥ p) → AddSemigroupAction G P |
List.range'_one | Init.Data.List.Basic | ∀ {s step : ℕ}, List.range' s 1 step = [s] |
InnerProductSpace.Core.inner_self_eq_norm_mul_norm | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), RCLike.re (inner 𝕜 x x) = ‖x‖ * ‖x‖ |
Matroid.isColoop_iff_mem_coloops | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsColoop e ↔ e ∈ M.coloops |
Aesop.incrementIteration | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM Q Unit |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.map_comp | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {J : Type u} [inst_1 : LinearOrder J]
[inst_2 : SuccOrder J] {j : J} (hj : ¬IsMax j) (F : CategoryTheory.Functor (↑(Set.Iic j)) C) {X : C}
(τ : F.obj ⟨j, ⋯⟩ ⟶ X) (i₁ i₂ i₃ : J) (h₁₂ : i₁ ≤ i₂) (h₂₃ : i₂ ≤ i₃) (h : i₃ ≤ Order.succ j),
CategoryTheory.SmallObject.SuccStruct.extendToSucc.map hj F τ i₁ i₃ ⋯ h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.SuccStruct.extendToSucc.map hj F τ i₁ i₂ h₁₂ ⋯)
(CategoryTheory.SmallObject.SuccStruct.extendToSucc.map hj F τ i₂ i₃ h₂₃ h) |
Metric.exists_continuous_real_forall_closedEBall_subset | Mathlib.Topology.MetricSpace.PartitionOfUnity | ∀ {ι : Type u_1} {X : Type u_2} [inst : EMetricSpace X] {K U : ι → Set X},
(∀ (i : ι), IsClosed (K i)) →
(∀ (i : ι), IsOpen (U i)) →
(∀ (i : ι), K i ⊆ U i) →
LocallyFinite K →
∃ δ, (∀ (x : X), 0 < δ x) ∧ ∀ (i : ι), ∀ x ∈ K i, Metric.closedEBall x (ENNReal.ofReal (δ x)) ⊆ U i |
Complex.UnitDisc.coe_mul._simp_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z w : Complex.UnitDisc), ↑z * ↑w = ↑(z * w) |
SimpleGraph.Walk.concat_dropLast | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (hp : G.Adj p.penultimate v), p.dropLast.concat hp = p |
Dioph.reindex_dioph | Mathlib.NumberTheory.Dioph | ∀ {α : Type u} (β : Type u) {S : Set (α → ℕ)} (f : α → β), Dioph S → Dioph {v | v ∘ f ∈ S} |
NontriviallyNormedField.ofNormNeOne | Mathlib.Analysis.Normed.Field.Basic | {𝕜 : Type u_5} → [h' : NormedField 𝕜] → (∃ x, x ≠ 0 ∧ ‖x‖ ≠ 1) → NontriviallyNormedField 𝕜 |
_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.evalSpecialize.match_1 | Lean.Elab.Tactic.ElabTerm | (motive : Lean.FVarId × Lean.MVarId → Sort u_1) →
(__discr : Lean.FVarId × Lean.MVarId) →
((fst : Lean.FVarId) → (mvarId : Lean.MVarId) → motive (fst, mvarId)) → motive __discr |
Mathlib.Tactic.Linarith.leftOfIneqProof | Mathlib.Tactic.Linarith.Verification | Lean.Expr → Lean.MetaM Lean.Expr |
CategoryTheory.Presieve.HasPairwisePullbacks.mk | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R : CategoryTheory.Presieve X},
(∀ {Y Z : C} {f : Y ⟶ X}, R f → ∀ {g : Z ⟶ X}, R g → CategoryTheory.Limits.HasPullback f g) → R.HasPairwisePullbacks |
tendsto_indicator_thickening_indicator_closure | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {β : Type u_2} [inst_1 : Zero β] [inst_2 : TopologicalSpace β]
(f : α → β) (E : Set α),
Filter.Tendsto (fun δ => (Metric.thickening δ E).indicator f) (nhdsWithin 0 (Set.Ioi 0))
(nhds ((closure E).indicator f)) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_insert_le_minKey?._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
Valuation.ofAddValuation._proof_4 | Mathlib.RingTheory.Valuation.Basic | ∀ {Γ₀ : Type u_1} [inst : LinearOrderedCommMonoidWithZero Γ₀] {a b : Multiplicative (Additive Γ₀)ᵒᵈᵒᵈ},
Additive.toMul (OrderDual.ofDual (OrderDual.ofDual (Multiplicative.toAdd a))) ≤
Additive.toMul (OrderDual.ofDual (OrderDual.ofDual (Multiplicative.toAdd b))) ↔
Additive.toMul (OrderDual.ofDual (OrderDual.ofDual (Multiplicative.toAdd a))) ≤
Additive.toMul (OrderDual.ofDual (OrderDual.ofDual (Multiplicative.toAdd b))) |
Set.centralizer.eq_1 | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} (S : Set M) [inst : Mul M], S.centralizer = {c | ∀ m ∈ S, m * c = c * m} |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.pushAllArgs._unsafe_rec | Lean.Meta.Sym.Simp.DiscrTree | Lean.Expr → Array Lean.Expr → Array Lean.Expr |
CategoryTheory.ObjectProperty.isColocal_iff_isIso | Mathlib.CategoryTheory.Localization.Bousfield | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C) {X Y : C}
(f : X ⟶ Y), P X → P Y → (P.isColocal f ↔ CategoryTheory.IsIso f) |
_private.Lean.Elab.Tactic.Do.ProofMode.MGoal.0.Lean.Elab.Tactic.Do.ProofMode.parseHyp?._sparseCasesOn_1 | Lean.Elab.Tactic.Do.ProofMode.MGoal | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
(Nat.hasNotBit 1024 t.ctorIdx → motive t) → motive t |
_private.Batteries.Linter.UnreachableTactic.0.Batteries.Linter.UnreachableTactic.getTactics._sparseCasesOn_1 | Batteries.Linter.UnreachableTactic | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Data.Vector.Basic.0.List.Vector.traverse._proof_1 | Mathlib.Data.Vector.Basic | ∀ {n : ℕ} {F : Type u_1 → Type u_1} {α β : Type u_1} (v : List α),
v.length = n → F (List.Vector β v.length) = F (List.Vector β n) |
SeminormedGroup.toUniformSpace._inherited_default | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
(dist : E → E → ℝ) →
(∀ (x : E), dist x x = 0) →
(∀ (x y : E), dist x y = dist y x) → (∀ (x y z : E), dist x z ≤ dist x y + dist y z) → UniformSpace E |
Mathlib.Tactic.Push.instBEqHead | Mathlib.Tactic.Push.Attr | BEq Mathlib.Tactic.Push.Head |
CategoryTheory.PreZeroHypercover.instUniqueI₀Singleton | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S T : C} → (f : S ⟶ T) → Unique (CategoryTheory.PreZeroHypercover.singleton f).I₀ |
_private.Mathlib.RingTheory.SurjectiveOnStalks.0.RingHom.surjectiveOnStalks_iff_forall_maximal._simp_1_1 | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {f : R →+* S} (P : Ideal S)
[inst_2 : P.IsPrime],
Function.Surjective ⇑(Localization.localRingHom (Ideal.comap f P) P f ⋯) =
∀ (s : S), ∃ x r, ∃ c ∉ P, f r ∉ P ∧ c * f r * s = c * f x |
Std.Sat.AIG.rec | Std.Sat.AIG.Basic | {α : Type} →
[inst : DecidableEq α] →
[inst_1 : Hashable α] →
{motive : Std.Sat.AIG α → Sort u} →
((decls : Array (Std.Sat.AIG.Decl α)) →
(cache : Std.Sat.AIG.Cache α decls) →
(hdag : Std.Sat.AIG.IsDAG α decls) →
(hzero : 0 < decls.size) →
(hconst : decls[0] = Std.Sat.AIG.Decl.false) →
motive { decls := decls, cache := cache, hdag := hdag, hzero := hzero, hconst := hconst }) →
(t : Std.Sat.AIG α) → motive t |
Representation.freeLift_toLinearMap | Mathlib.RepresentationTheory.Equiv | ∀ {G : Type v} [inst : Monoid G] {V : Type v'} [inst_1 : AddCommMonoid V] {k : Type u} [inst_2 : CommSemiring k]
[inst_3 : Module k V] (σ : Representation k G V) {α : Type w'} (f : α → V),
(σ.freeLift f).toLinearMap =
(Finsupp.linearCombination k fun x => (σ x.2) (f x.1)) ∘ₗ ↑(Finsupp.curryLinearEquiv k).symm |
dite_dite_distrib_left | Mathlib.Logic.Lemmas | ∀ {α : Sort u_1} {p q : Prop} [inst : Decidable p] [inst_1 : Decidable q] {a : p → α} {b : ¬p → q → α}
{c : ¬p → ¬q → α},
(dite p a fun hp => dite q (b hp) (c hp)) = if hq : q then dite p a fun hp => b hp hq else dite p a fun hp => c hp hq |
CategoryTheory.Limits.colimitQuotientCoproduct_epi | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.SmallCategory J]
[inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, u} C] (F : CategoryTheory.Functor J C),
CategoryTheory.Epi (CategoryTheory.Limits.colimitQuotientCoproduct F) |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.carrier.asIdeal.prime.match_1_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : SetLike σ A] {𝒜 : ℕ → σ} {y : A} (motive : SetLike.IsHomogeneousElem 𝒜 y → Prop)
(x : SetLike.IsHomogeneousElem 𝒜 y), (∀ (ny : ℕ) (hny : y ∈ 𝒜 ny), motive ⋯) → motive x |
Std.Iter.isSome_atIdxSlow?_repeat | Std.Data.Iterators.Lemmas.Producers.Repeat | ∀ {α : Type w} {f : α → α} {init : α} {k : ℕ}, (Std.Iter.atIdxSlow? k (Std.Iter.repeat f init)).isSome = true |
CategoryTheory.MorphismProperty.HasOfPostcompProperty.mk | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W W' : CategoryTheory.MorphismProperty C},
(∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), W' g → W (CategoryTheory.CategoryStruct.comp f g) → W f) →
W.HasOfPostcompProperty W' |
StarAlgHom.toNonUnitalStarAlgHom._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] (f : A →⋆ₐ[R] B) (c : R) (x : A),
f (c • x) = c • f x |
Set.Nontrivial.preimage | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set β}, s.Nontrivial → Function.Surjective f → (f ⁻¹' s).Nontrivial |
tsub_tsub_le_tsub_add | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] [AddLeftMono α]
{a b c : α}, a - (b - c) ≤ a - b + c |
ProofWidgets.Jsx.proofWidgetsJsxAttrVal_ | ProofWidgets.Data.Html | Lean.ParserDescr |
CategoryTheory.Limits.Types.instHasImageMapsType | Mathlib.CategoryTheory.Limits.Types.Images | CategoryTheory.Limits.HasImageMaps (Type u) |
Std.TreeMap.instEmptyCollection | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → EmptyCollection (Std.TreeMap α β cmp) |
div_div_div_cancel_left | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : CommGroup G] (a b c : G), c / a / (c / b) = b / a |
Lean.IR.LocalContextEntry.param.injEq | Lean.Compiler.IR.Basic | ∀ (a a_1 : Lean.IR.IRType), (Lean.IR.LocalContextEntry.param a = Lean.IR.LocalContextEntry.param a_1) = (a = a_1) |
Std.Iter.Equiv.foldM_eq | Std.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α₁ α₂ β γ : Type w} {m : Type w → Type w'} [Std.Iterator α₁ Id β] [Std.Iterator α₂ Id β]
[inst : Std.Iterator α₁ Id β] [inst_1 : Std.Iterator α₂ Id β] [Std.Iterators.Finite α₁ Id]
[Std.Iterators.Finite α₂ Id] [inst_4 : Monad m] [LawfulMonad m] [inst_6 : Std.IteratorLoop α₁ Id m]
[Std.LawfulIteratorLoop α₁ Id m] [inst_8 : Std.IteratorLoop α₂ Id m] [Std.LawfulIteratorLoop α₂ Id m] {init : γ}
{f : γ → β → m γ} {ita : Std.Iter β} {itb : Std.Iter β},
ita.Equiv itb → Std.Iter.foldM f init ita = Std.Iter.foldM f init itb |
Matrix.updateRow_subsingleton | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} [inst : Subsingleton m] (A : Matrix m n R) (i : m) (b : n → R),
A.updateRow i b = (Matrix.replicateRow (Fin 1) b).submatrix (Function.const m 0) id |
IsAddRegular.nsmul | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {a : R} (n : ℕ), IsAddRegular a → IsAddRegular (n • a) |
LocallyConstant.coe_inv | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Inv Y] (f : LocallyConstant X Y), ⇑f⁻¹ = (⇑f)⁻¹ |
DoubleCentralizer.instCStarAlgebraComplex | Mathlib.Analysis.CStarAlgebra.Multiplier | {A : Type u_1} → [inst : NonUnitalCStarAlgebra A] → CStarAlgebra (DoubleCentralizer ℂ A) |
_private.Mathlib.Order.Filter.Tendsto.0.Filter.not_tendsto_iff_exists_frequently_notMem._simp_1_2 | Mathlib.Order.Filter.Tendsto | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.gluedCocone._simp_1 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h |
_private.Batteries.Data.List.Lemmas.0.List.countBefore_cons_succ_of_not_beq._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {xs : List α} {i : ℕ} [inst : BEq α] {a : α},
(a == x) = false → List.countBefore x (a :: xs) (i + 1) = List.countBefore x xs i |
TrivSqZeroExt.instL1SeminormedRing.match_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} (motive : TrivSqZeroExt R M → TrivSqZeroExt R M → Prop) (x x_1 : TrivSqZeroExt R M),
(∀ (r₁ : R) (m₁ : M) (r₂ : R) (m₂ : M), motive (r₁, m₁) (r₂, m₂)) → motive x x_1 |
CategoryTheory.MonadicRightAdjoint.mk._flat_ctor | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
(L : CategoryTheory.Functor C D) →
(adj : L ⊣ R) → (CategoryTheory.Monad.comparison adj).IsEquivalence → CategoryTheory.MonadicRightAdjoint R |
Std.Do.SPred.bientails.of_eq | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q : Std.Do.SPred σs}, P = Q → P ⊣⊢ₛ Q |
MeasureTheory.predictablePart_add_ae_eq | Mathlib.Probability.Martingale.Centering | ∀ {Ω : Type u_1} {E : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] {ℱ : MeasureTheory.Filtration ℕ m0}
[MeasureTheory.SigmaFiniteFiltration μ ℱ] {f g : ℕ → Ω → E},
MeasureTheory.Martingale f ℱ μ →
(MeasureTheory.StronglyAdapted ℱ fun n => g (n + 1)) →
g 0 = 0 →
(∀ (n : ℕ), MeasureTheory.Integrable (g n) μ) → ∀ (n : ℕ), MeasureTheory.predictablePart (f + g) ℱ μ n =ᵐ[μ] g n |
Nat.exists_eq_add_one._simp_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ}, (∃ n, a = n + 1) = (0 < a) |
Lean.Meta.Grind.AC.EqCnstrProof.erase0.injEq | Lean.Meta.Tactic.Grind.AC.Types | ∀ (c c_1 : Lean.Meta.Grind.AC.EqCnstr),
(Lean.Meta.Grind.AC.EqCnstrProof.erase0 c = Lean.Meta.Grind.AC.EqCnstrProof.erase0 c_1) = (c = c_1) |
Std.AnyAsyncStream.casesOn | Std.Sync.StreamMap | {α : Type} →
{motive : Std.AnyAsyncStream α → Sort u} →
(t : Std.AnyAsyncStream α) →
({t : Type} → [inst : Std.Internal.Async.IO.AsyncStream t α] → (a : t) → motive (Std.AnyAsyncStream.mk a)) →
motive t |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.«_aux_Std_Data_DHashMap_Internal_RawLemmas___macroRules_Std_DHashMap_Internal_Raw₀_tacticSimp_to_model[_]Using__1»._sparseCasesOn_1 | Std.Data.DHashMap.Internal.RawLemmas | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.addMatchCondsToSplitter._sunfold | Lean.Meta.Tactic.Grind.CasesMatch | Lean.Expr → ℕ → Lean.Expr |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.