name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
TopologicalSpace.Clopens.coe_inf | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] (s t : TopologicalSpace.Clopens α), ↑(s ⊓ t) = ↑s ∩ ↑t |
Lean.Elab.Term.StructInst.FieldLHS.fieldIndex.injEq | Lean.Elab.StructInst | ∀ (ref : Lean.Syntax) (idx : ℕ) (ref_1 : Lean.Syntax) (idx_1 : ℕ),
(Lean.Elab.Term.StructInst.FieldLHS.fieldIndex ref idx = Lean.Elab.Term.StructInst.FieldLHS.fieldIndex ref_1 idx_1) =
(ref = ref_1 ∧ idx = idx_1) |
SimpleGraph.center_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1}, ⊤.center = Set.univ |
CategoryTheory.RetractArrow.map_i_left | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W} (h : CategoryTheory.RetractArrow f g) (F : CategoryTheory.Functor C D),
(h.map F).i.left = F.map h.i.left |
_private.Mathlib.Data.Int.Interval.0.Finset.Ioc_succ_succ._simp_1_2 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) |
Finset.filter_subset._simp_1 | Mathlib.Data.Finset.Filter | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Finset α), (Finset.filter p s ⊆ s) = True |
SheafOfModules.hom_ext_iff | Mathlib.Algebra.Category.ModuleCat.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} {X Y : SheafOfModules R} {f g : X ⟶ Y}, f = g ↔ f.val = g.val |
algebraMap_smul | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : Semiring A] [inst_2 : Algebra R A] {M : Type u_3}
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [IsScalarTower R A M] (r : R) (m : M),
(algebraMap R A) r • m = r • m |
pi_generateFrom_eq_finite | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {X : ι → Type u_9} {g : (a : ι) → Set (Set (X a))} [Finite ι],
(∀ (a : ι), ⋃₀ g a = Set.univ) →
Pi.topologicalSpace = TopologicalSpace.generateFrom {t | ∃ s, (∀ (a : ι), s a ∈ g a) ∧ t = Set.univ.pi s} |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_11 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ (A : Type u) [inst : CommRing A] (K : Type v) [inst_1 : Field K] [inst_2 : Algebra A K] [inst_3 : IsDomain A]
[inst_4 : ValuationRing A] [inst_5 : IsFractionRing A K] (x : K),
(x ∈ (ValuationRing.valuation A K).integer) = ∃ a, (algebraMap A K) a = x |
TwoSidedIdeal.asIdealOpposite | Mathlib.RingTheory.TwoSidedIdeal.Operations | {R : Type u_1} → [inst : Ring R] → TwoSidedIdeal R →o Ideal Rᵐᵒᵖ |
Mathlib.Meta.NormNum.evalIsSquareRat | Mathlib.Tactic.NormNum.IsSquare | Mathlib.Meta.NormNum.NormNumExt |
Std.MaxEqOr | Init.Data.Order.Classes | (α : Type u) → [Max α] → Prop |
BitVec.ofInt_iSizeToInt | Init.Data.SInt.Lemmas | ∀ (x : ISize), BitVec.ofInt System.Platform.numBits x.toInt = x.toBitVec |
Btw.rec | Mathlib.Order.Circular | {α : Type u_1} → {motive : Btw α → Sort u} → ((btw : α → α → α → Prop) → motive { btw := btw }) → (t : Btw α) → motive t |
MeasurableSpace.DynkinSystem.instPartialOrder._proof_3 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} (x x_1 x_2 : MeasurableSpace.DynkinSystem α), x ≤ x_1 → x_1 ≤ x_2 → x ≤ x_2 |
Std.DTreeMap.Internal.Impl.getKey._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] → (t : Std.DTreeMap.Internal.Impl α β) → (k : α) → Std.DTreeMap.Internal.Impl.contains k t = true → α |
Lean.Meta.Grind.AC.DiseqCnstrProof.erase_dup | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.DiseqCnstr → Lean.Meta.Grind.AC.DiseqCnstrProof |
Sum.swap_swap_eq | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2}, Sum.swap ∘ Sum.swap = id |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_382 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
UniformSpace.hausdorff | Mathlib.Topology.UniformSpace.Closeds | (α : Type u_1) → [UniformSpace α] → UniformSpace (Set α) |
Sum.getRight_eq_getRight? | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {x : α ⊕ β} (h₁ : x.isRight = true) (h₂ : x.getRight?.isSome = true),
x.getRight h₁ = x.getRight?.get h₂ |
Lean.Meta.Sym.getInt16Value? | Lean.Meta.Sym.LitValues | Lean.Expr → OptionT Id Int16 |
Submodule.instDiv._proof_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(I J : Submodule R A) {a b : A},
a ∈ {x | ∀ y ∈ J, x * y ∈ I} → b ∈ {x | ∀ y ∈ J, x * y ∈ I} → ∀ y ∈ J, (a + b) * y ∈ I |
SeminormedCommGroup | Mathlib.Analysis.Normed.Group.Defs | Type u_8 → Type u_8 |
Topology.IsQuotientMap.trivializationOfVAddDisjoint._proof_8 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_2} {X : Type u_1} {f : E → X} {G : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G E] (U : Set E),
(∀ (g : G) (e : E), f (g +ᵥ e) = f e) → ∀ (g : G) ⦃x : X⦄, x ∈ f '' U → x ∈ f '' ((fun x => g +ᵥ x) ⁻¹' U) |
Computability.«term_≡ᵀ_» | Mathlib.Computability.TuringDegree | Lean.TrailingParserDescr |
Vector.push_inj_left | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a : α} {xs ys : Vector α n}, xs.push a = ys.push a ↔ xs = ys |
Lean.mkPtrSet | Lean.Util.PtrSet | {α : Type} → optParam ℕ 64 → Lean.PtrSet α |
Subtype.forall_set_subtype | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {t : Set α} (p : Set α → Prop), (∀ (s : Set ↑t), p (Subtype.val '' s)) ↔ ∀ s ⊆ t, p s |
Lean.Widget.GetGoToLocationParams.noConfusionType | Lean.Server.FileWorker.WidgetRequests | Sort u → Lean.Widget.GetGoToLocationParams → Lean.Widget.GetGoToLocationParams → Sort u |
SimpleGraph.Subgraph.botIso._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (x : ↑⊥.verts), (False.elim ⋯).elim = x |
CategoryTheory.Grothendieck.map._proof_2 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat}
(α : F ⟶ G) (X : CategoryTheory.Grothendieck F),
{ base := (CategoryTheory.CategoryStruct.id X).base,
fiber :=
CategoryTheory.CategoryStruct.comp ((CategoryTheory.eqToHom ⋯).toNatTrans.app X.fiber)
((α.app X.base).toFunctor.map (CategoryTheory.CategoryStruct.id X).fiber) } =
CategoryTheory.CategoryStruct.id { base := X.base, fiber := (α.app X.base).toFunctor.obj X.fiber } |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.isSeparated._simp_5 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map g) (AlgebraicGeometry.Spec.map f) =
AlgebraicGeometry.Spec.map (CategoryTheory.CategoryStruct.comp f g) |
Turing.TM1to0.trAux._sunfold | Mathlib.Computability.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
(M : Λ → Turing.TM1.Stmt Γ Λ σ) → Γ → Turing.TM1.Stmt Γ Λ σ → σ → Turing.TM1to0.Λ' M × Turing.TM0.Stmt Γ |
ContinuousAlternatingMap.piLIE._proof_6 | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {ι' : Type u_2} {F : ι' → Type u_3}
[inst_1 : (i' : ι') → SeminormedAddCommGroup (F i')] [inst_2 : (i' : ι') → NormedSpace 𝕜 (F i')],
SMulCommClass 𝕜 𝕜 ((i : ι') → F i) |
Function.IsFixedPt.eq_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u₁} (f : α → α) (x : α), Function.IsFixedPt f x = (f x = x) |
Dvd.noConfusion | Init.Prelude | {P : Sort u} →
{α : Type u_1} → {t : Dvd α} → {α' : Type u_1} → {t' : Dvd α'} → α = α' → t ≍ t' → Dvd.noConfusionType P t t' |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁.elim | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
t.ctorIdx = 9 →
((c : Lean.Meta.Grind.Arith.Cutsat.CooperSplit) →
motive_7 (Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁ c)) →
motive_7 t |
Algebra.WeaklyQuasiFiniteAt.of_quasiFiniteAt_residueField | Mathlib.RingTheory.QuasiFinite.Weakly | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
(q : Ideal S) [inst_3 : q.IsPrime] [inst_4 : p.IsPrime] [q.LiesOver p] (Q : Ideal (p.Fiber S)) [inst_6 : Q.IsPrime],
Ideal.comap Algebra.TensorProduct.includeRight.toRingHom Q = q →
∀ [Algebra.QuasiFiniteAt p.ResidueField Q], Algebra.WeaklyQuasiFiniteAt R q |
Std.TreeSet.Raw.maxD_eq_iff_mem_and_forall | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp],
t.WF → t.isEmpty = false → ∀ {km fallback : α}, t.maxD fallback = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp k km).isLE = true |
CompactlySupportedContinuousMap.instInf._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : SemilatticeInf β] [inst_2 : Zero β]
[inst_3 : TopologicalSpace β] (f g : CompactlySupportedContinuousMap α β), HasCompactSupport (⇑f ⊓ ⇑g) |
_private.Mathlib.Algebra.Algebra.Bilinear.0.LinearMap.pow_mulLeft.match_1_1 | Mathlib.Algebra.Algebra.Bilinear | ∀ (motive : ℕ → Prop) (n : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive n |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀_app_zero | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.fourδ₁Toδ₀ f₁ f₂ f₃ f₄ f₁₂ h₁₂).app 0 = f₁ |
FiniteArchimedeanClass.lift_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {α : Type u_2}
(f : { a // a ≠ 0 } → α)
(h : ∀ (a b : { a // a ≠ 0 }), FiniteArchimedeanClass.mk ↑a ⋯ = FiniteArchimedeanClass.mk ↑b ⋯ → f a = f b) {a : M}
(ha : a ≠ 0), FiniteArchimedeanClass.lift f h (FiniteArchimedeanClass.mk a ha) = f ⟨a, ha⟩ |
FirstOrder.Language.Sentence.cardGe.eq_1 | Mathlib.ModelTheory.Semantics | ∀ (L : FirstOrder.Language) (n : ℕ),
FirstOrder.Language.Sentence.cardGe L n =
(List.foldr (fun x1 x2 => x1 ⊓ x2) ⊤
(List.map
(fun ij =>
(((FirstOrder.Language.var ∘ Sum.inr) ij.1).bdEqual ((FirstOrder.Language.var ∘ Sum.inr) ij.2)).not)
(List.filter (fun ij => decide (ij.1 ≠ ij.2)) (List.finRange n ×ˢ List.finRange n)))).exs |
Subsemigroup.instCompleteLattice._proof_14 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] (s : Set (Subsemigroup M)), ∀ a ∈ s, sInf s ≤ a |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.instEncodableS | Mathlib.Tactic.DeriveEncodable | Encodable Mathlib.Deriving.Encodable.S✝ |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.entryAtIdx?.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () |
Turing.PartrecToTM2.move₂ | Mathlib.Computability.TMToPartrec | (Turing.PartrecToTM2.Γ' → Bool) →
Turing.PartrecToTM2.K' → Turing.PartrecToTM2.K' → Turing.PartrecToTM2.Λ' → Turing.PartrecToTM2.Λ' |
Mathlib.Notation3.mkScopedMatcher | Mathlib.Util.Notation3 | Lean.Name →
Lean.Name → Lean.Term → Array Lean.Name → OptionT Lean.Elab.TermElabM (List Mathlib.Notation3.DelabKey × Lean.Term) |
_private.Mathlib.Algebra.Lie.Weights.Cartan.0.LieAlgebra.mem_zeroRootSubalgebra._simp_1_1 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ {R : Type u_2} {L : Type u_3} (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] (χ : L → R) (m : M),
(m ∈ LieModule.genWeightSpace M χ) = ∀ (x : L), ∃ k, (((LieModule.toEnd R L M) x - χ x • 1) ^ k) m = 0 |
Lean.Parser.Term.subst.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer |
Ideal.map_sup_comap_of_surjective | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[inst_3 : RingHomClass F R S],
Function.Surjective ⇑f → ∀ (I J : Ideal S), Ideal.map f (Ideal.comap f I ⊔ Ideal.comap f J) = I ⊔ J |
Homeomorph.mulRight | Mathlib.Topology.Algebra.Group.Basic | {G : Type w} → [inst : TopologicalSpace G] → [inst_1 : Group G] → [SeparatelyContinuousMul G] → G → G ≃ₜ G |
Turing.TM2to1.trStmts₁.eq_3 | Mathlib.Computability.TuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (k : K) (f : σ → Option (Γ k) → σ)
(q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2to1.trStmts₁ (Turing.TM2.Stmt.pop k f q) =
{Turing.TM2to1.Λ'.go k (Turing.TM2to1.StAct.pop f) q, Turing.TM2to1.Λ'.ret q} ∪ Turing.TM2to1.trStmts₁ q |
Module.DirectLimit.of._proof_3 | Mathlib.Algebra.Colimit.Module | ∀ (R : Type u_3) [inst : Semiring R] (ι : Type u_1) [inst_1 : Preorder ι] (G : ι → Type u_2)
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
[inst_4 : DecidableEq ι] (x : R) (x_1 : DirectSum ι G),
(↑(Module.DirectLimit.moduleCon f).mk').toFun (x • x_1) = (↑(Module.DirectLimit.moduleCon f).mk').toFun (x • x_1) |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave'_1 | Init.Tactics | Lean.Macro |
Real.analyticOn_cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {s : Set ℝ}, AnalyticOn ℝ Real.cos s |
Subgroup.rightCosetEquivSubgroup | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [inst : Group α] → {s : Subgroup α} → (g : α) → ↑(MulOpposite.op g • ↑s) ≃ ↥s |
Batteries.RBNode.Balanced.below.black | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1} {motive : (a : Batteries.RBNode α) → (a_1 : Batteries.RBColor) → (a_2 : ℕ) → a.Balanced a_1 a_2 → Prop}
{x : Batteries.RBNode α} {c₁ : Batteries.RBColor} {n : ℕ} {y : Batteries.RBNode α} {c₂ : Batteries.RBColor} {v : α}
(a : x.Balanced c₁ n) (a_1 : y.Balanced c₂ n),
Batteries.RBNode.Balanced.below a →
motive x c₁ n a → Batteries.RBNode.Balanced.below a_1 → motive y c₂ n a_1 → Batteries.RBNode.Balanced.below ⋯ |
RatFunc.instCommRing._proof_5 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u_1) [inst : CommRing K], Nat.unaryCast 0 = 0 |
Set.pi.eq_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Set ι) (t : (i : ι) → Set (α i)), s.pi t = {f | ∀ i ∈ s, f i ∈ t i} |
_private.Mathlib.RingTheory.Ideal.Height.0.Ideal.sup_primeHeight_of_maximal_eq_ringKrullDim._proof_1_2 | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R], Ideal.IsMaximal ⊥ → Ideal.IsPrime ⊥ |
_private.Init.Data.List.Lemmas.0.List.map_eq_nil_iff.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} (motive : (l : List α) → List.map f l = [] → Prop) (l : List α)
(x : List.map f l = []), (∀ (x : List.map f [] = []), motive [] x) → motive l x |
Complex.HadamardThreeLines.norm_invInterpStrip | Mathlib.Analysis.Complex.Hadamard | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (f : ℂ → E) (z : ℂ) {ε : ℝ},
ε > 0 →
‖Complex.HadamardThreeLines.invInterpStrip f z ε‖ =
(ε + Complex.HadamardThreeLines.sSupNormIm f 0) ^ (z.re - 1) *
(ε + Complex.HadamardThreeLines.sSupNormIm f 1) ^ (-z.re) |
_private.Init.Meta.Defs.0.Lean.Syntax.getTailInfo?.match_1 | Init.Meta.Defs | (motive : Lean.Syntax → Sort u_1) →
(x : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive (Lean.Syntax.atom info val)) →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive (Lean.Syntax.ident info rawVal val preresolved)) →
((kind : Lean.SyntaxNodeKind) →
(args : Array Lean.Syntax) → motive (Lean.Syntax.node Lean.SourceInfo.none kind args)) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node info kind args)) →
((x : Lean.Syntax) → motive x) → motive x |
Set.ncard_lt_card | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} [Finite α], s ≠ Set.univ → s.ncard < Nat.card α |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra.0.IntermediateField.algebraAdjoinAdjoin.instIsFractionRingSubtypeMemSubalgebraAdjoinAdjoin.match_3 | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ (F : Type u_2) [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E)
(motive : ↥(IntermediateField.adjoin F S) → Prop) (x : ↥(IntermediateField.adjoin F S)),
(∀ (val : E) (h : val ∈ IntermediateField.adjoin F S), motive ⟨val, h⟩) → motive x |
CompHausLike.LocallyConstant.counitAppAppImage | Mathlib.Condensed.Discrete.LocallyConstant | {P : TopCat → Prop} →
[inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
{S : CompHausLike P} →
{Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} →
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] →
(f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (CompHausLike.of P PUnit.{u + 1})))) →
(a : Function.Fiber ⇑f) → Y.obj (Opposite.op (CompHausLike.LocallyConstant.fiber f a)) |
Finsupp.optionElim | Mathlib.Data.Finsupp.Option | {α : Type u_1} → {M : Type u_2} → [inst : Zero M] → M → (α →₀ M) → Option α →₀ M |
Lean.Meta.Grind.Order.modify' | Lean.Meta.Tactic.Grind.Order.Types | (Lean.Meta.Grind.Order.State → Lean.Meta.Grind.Order.State) → Lean.Meta.Grind.GoalM Unit |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkAndThenSeq._sunfold | Lean.Meta.Tactic.Grind.Split | List (Lean.TSyntax `grind) → Lean.CoreM (Lean.TSyntax `grind) |
Lean.Level.imax.injEq | Lean.Level | ∀ (a a_1 a_2 a_3 : Lean.Level), (a.imax a_1 = a_2.imax a_3) = (a = a_2 ∧ a_1 = a_3) |
FreeAddMonoid.lift_restrict | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : AddMonoid M] (f : FreeAddMonoid α →+ M),
FreeAddMonoid.lift (⇑f ∘ FreeAddMonoid.of) = f |
mul_isLeftRegular_iff._simp_2 | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : Semigroup R] {a : R} (b : R), IsLeftRegular a → IsLeftRegular (a * b) = IsLeftRegular b |
Nat.map_add_toList_ric | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n k : ℕ}, List.map (fun x => x + k) (*...=n).toList = (k...=n + k).toList |
CoxeterMatrix.E₆._proof_2 | Mathlib.GroupTheory.Coxeter.Matrix | ∀ (i : Fin 6),
!![1, 2, 3, 2, 2, 2; 2, 1, 2, 3, 2, 2; 3, 2, 1, 3, 2, 2; 2, 3, 3, 1, 3, 2; 2, 2, 2, 3, 1, 3; 2, 2, 2, 2, 3, 1] i i = 1 |
_private.Mathlib.Order.CompleteLattice.Basic.0.iInf_eq_bot._simp_1_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : InfSet α] {f : ι → α}, iInf f = sInf (Set.range f) |
MeasureTheory.measurable_cylinderEvents_iff | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {α : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {mα : MeasurableSpace α} [m : (i : ι) → MeasurableSpace (X i)]
{Δ : Set ι} {g : α → (i : ι) → X i}, Measurable g ↔ ∀ ⦃i : ι⦄, i ∈ Δ → Measurable fun a => g a i |
CategoryTheory.InjectiveResolution.Hom.mk.injEq | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} {I : CategoryTheory.InjectiveResolution Z} {Z' : C}
{I' : CategoryTheory.InjectiveResolution Z'} {f : Z ⟶ Z'} (hom : I.cocomplex ⟶ I'.cocomplex)
(ι_f_zero_comp_hom_f_zero :
CategoryTheory.CategoryStruct.comp (I.ι.f 0) (hom.f 0) =
CategoryTheory.CategoryStruct.comp (((CochainComplex.single₀ C).map f).f 0) (I'.ι.f 0))
(hom_1 : I.cocomplex ⟶ I'.cocomplex)
(ι_f_zero_comp_hom_f_zero_1 :
CategoryTheory.CategoryStruct.comp (I.ι.f 0) (hom_1.f 0) =
CategoryTheory.CategoryStruct.comp (((CochainComplex.single₀ C).map f).f 0) (I'.ι.f 0)),
({ hom := hom, ι_f_zero_comp_hom_f_zero := ι_f_zero_comp_hom_f_zero } =
{ hom := hom_1, ι_f_zero_comp_hom_f_zero := ι_f_zero_comp_hom_f_zero_1 }) =
(hom = hom_1) |
Quiver.Path.getElem_vertices_zero._proof_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {V : Type u_1} [inst : Quiver V] {a b : V} (p : Quiver.Path a b), 0 < p.vertices.length |
HomologicalComplex.natIsoSc'_inv_app_τ₂ | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i j k : ι) (hi : c.prev j = i) (hk : c.next j = k) (X : HomologicalComplex C c),
((HomologicalComplex.natIsoSc' C c i j k hi hk).inv.app X).τ₂ = CategoryTheory.CategoryStruct.id (X.X j) |
isStarProjection_iff_eq_starProjection_range | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {p : E →L[𝕜] E},
IsStarProjection p ↔ ∃ (x : (↑p).range.HasOrthogonalProjection), p = (↑p).range.starProjection |
ContinuousLinearMap.IsPositive.isSelfAdjoint | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {T : E →L[𝕜] E}, T.IsPositive → IsSelfAdjoint T |
_private.Mathlib.LinearAlgebra.Dual.Defs.0.LinearMap.range_dualMap_dual_eq_span_singleton.match_1_3 | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R M₁]
(f m : Module.Dual R M₁) (motive : (∃ a, a • f = m) → Prop) (x : ∃ a, a • f = m),
(∀ (r : R) (hr : r • f = m), motive ⋯) → motive x |
Ordinal.uniqueIioOne._proof_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ (a : ↑(Set.Iio 1)), a = ⟨0, ⋯⟩ |
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Adjunction_Basic___unexpand_CategoryTheory_Bicategory_Adjunction_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | Lean.PrettyPrinter.Unexpander |
Equiv.permCongrHom_symm | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} (e : α ≃ β), e.permCongrHom.symm = e.symm.permCongrHom |
ZMod.prime_ne_zero | Mathlib.Data.ZMod.ValMinAbs | ∀ (p q : ℕ) [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)], p ≠ q → ↑q ≠ 0 |
CategoryTheory.ComposableArrows.Mk₁.obj | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} → C → C → Fin 2 → C |
String.Slice.splitInclusive | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
(s : String.Slice) → (pat : ρ) → [inst : String.Slice.Pattern.ToForwardSearcher pat σ] → Std.Iter String.Slice |
Std.Iterators.Types.Flatten.mk.inj | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type u_1} {it₁ : Std.IterM m (Std.IterM m β)} {it₂ : Option (Std.IterM m β)}
{it₁_1 : Std.IterM m (Std.IterM m β)} {it₂_1 : Option (Std.IterM m β)},
{ it₁ := it₁, it₂ := it₂ } = { it₁ := it₁_1, it₂ := it₂_1 } → it₁ = it₁_1 ∧ it₂ = it₂_1 |
IsPredArchimedean.findAtom | Mathlib.Order.SuccPred.Tree | {α : Type u_1} →
[inst : PartialOrder α] → [inst_1 : PredOrder α] → [IsPredArchimedean α] → [OrderBot α] → [DecidableEq α] → α → α |
Polynomial.leadingCoeffHom | Mathlib.Algebra.Polynomial.Degree.Operations | {R : Type u} → [inst : Semiring R] → [NoZeroDivisors R] → Polynomial R →* R |
WittVector.equiv._proof_1 | Mathlib.RingTheory.WittVector.Compare | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (x y : WittVector p (ZMod p)),
(WittVector.toPadicInt p) (x * y) = (WittVector.toPadicInt p) x * (WittVector.toPadicInt p) y |
list_sum_pow_char | Mathlib.Algebra.CharP.Lemmas | ∀ {R : Type u_3} [inst : CommSemiring R] (p : ℕ) [ExpChar R p] (l : List R),
l.sum ^ p = (List.map (fun x => x ^ p) l).sum |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_obj_g | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (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)),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C).obj F).g =
F.whiskerLeft CategoryTheory.ShortComplex.π₂Toπ₃ |
SSet.horn₃₂.desc._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | (SSet.horn 3 2).MulticoequalizerDiagram (fun j => SSet.stdSimplex.face {↑j}ᶜ) fun j k => SSet.stdSimplex.face {↑j, ↑k}ᶜ |
Submodule.annihilator_mono | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N P : Submodule R M}, N ≤ P → P.annihilator ≤ N.annihilator |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.