name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.Split.generalizeMatchPropDiscrs.match_3 | Lean.Meta.Tactic.Split | (motive : MProd (Array Lean.Expr) Lean.MVarId → Sort u_1) →
(r : MProd (Array Lean.Expr) Lean.MVarId) →
((discrs' : Array Lean.Expr) → (mvarId : Lean.MVarId) → motive ⟨discrs', mvarId⟩) → motive r |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic._aux_Batteries_Tactic_Trans___elabRules_Batteries_Tactic_tacticTrans____1.match_1 | Batteries.Tactic.Trans | (motive : Option (Lean.Expr × List Lean.MVarId) → Sort u_1) →
(t'? : Option (Lean.Expr × List Lean.MVarId)) →
((fst : Lean.Expr) → (gs' : List Lean.MVarId) → motive (some (fst, gs'))) →
((x : Option (Lean.Expr × List Lean.MVarId)) → motive x) → motive t'? |
Lean.Parser.ModuleParserState.noConfusionType | Lean.Parser.Module | Sort u → Lean.Parser.ModuleParserState → Lean.Parser.ModuleParserState → Sort u |
Submodule.mem_span_set' | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : M}
{s : Set M}, m ∈ Submodule.span R s ↔ ∃ n f g, ∑ i, f i • ↑(g i) = m |
Std.Do.Spec.pure | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps] {α : Type u} {a : α}
{Q : Std.Do.PostCond α ps}, ⦃Q.1 a⦄ pure a ⦃Q⦄ |
MulOpposite.instNatCast | Mathlib.Algebra.Ring.Opposite | {R : Type u_1} → [NatCast R] → NatCast Rᵐᵒᵖ |
Lean.Elab.DelabTermInfo.noConfusionType | Lean.Elab.InfoTree.Types | Sort u → Lean.Elab.DelabTermInfo → Lean.Elab.DelabTermInfo → Sort u |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq.0.Lean.Meta.Grind.Arith.Linear.updateDiseqs | Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq | ℤ →
Lean.Grind.Linarith.Var →
Lean.Meta.Grind.Arith.Linear.EqCnstr → Lean.Grind.Linarith.Var → Lean.Meta.Grind.Arith.Linear.LinearM Unit |
_private.Mathlib.Topology.Order.MonotoneContinuity.0.continuousWithinAt_left_of_monotoneOn_of_exists_between.match_1_1 | Mathlib.Topology.Order.MonotoneContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder β] {f : α → β} {s : Set α} {a : α} (b : βᵒᵈ)
(motive : (∃ c ∈ s, f c ∈ Set.Ioo b (f a)) → Prop) (x : ∃ c ∈ s, f c ∈ Set.Ioo b (f a)),
(∀ (c : α) (hcs : c ∈ s) (hcb : b < f c) (hca : f c < f a), motive ⋯) → motive x |
Batteries.BinomialHeap.Imp.Heap.merge._unary._proof_3 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} (s₁ : Batteries.BinomialHeap.Imp.Heap α) (r₁ : ℕ) (a₁ : α) (n₁ : Batteries.BinomialHeap.Imp.HeapNode α)
(t₁ : Batteries.BinomialHeap.Imp.Heap α) (h : s₁ = Batteries.BinomialHeap.Imp.Heap.cons r₁ a₁ n₁ t₁)
(s₂ : Batteries.BinomialHeap.Imp.Heap α) (r₂ : ℕ) (a₂ : α) (n₂ : Batteries.BinomialHeap.Imp.HeapNode α)
(t₂ : Batteries.BinomialHeap.Imp.Heap α) (h_1 : s₂ = Batteries.BinomialHeap.Imp.Heap.cons r₂ a₂ n₂ t₂),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun a a_1 => a.length + a_1.length) ⟨t₁, t₂⟩
⟨namedPattern s₁ (Batteries.BinomialHeap.Imp.Heap.cons r₁ a₁ n₁ t₁) h,
namedPattern s₂ (Batteries.BinomialHeap.Imp.Heap.cons r₂ a₂ n₂ t₂) h_1⟩ |
_private.Mathlib.Algebra.Ring.SumsOfSquares.0.Subsemiring.closure_isSquare._simp_1_1 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ {T : Type u_2} [inst : CommSemiring T], Subsemiring.closure {x | IsSquare x} = (Submonoid.square T).subsemiringClosure |
AffineEquiv.linearHom._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (x x_1 : P₁ ≃ᵃ[k] P₁), (x * x_1).linear = (x * x_1).linear |
Lean.AddErrorMessageContext.casesOn | Lean.Exception | {m : Type → Type} →
{motive : Lean.AddErrorMessageContext m → Sort u} →
(t : Lean.AddErrorMessageContext m) →
((add : Lean.Syntax → Lean.MessageData → m (Lean.Syntax × Lean.MessageData)) → motive { add := add }) → motive t |
Pi.constRingHom._proof_4 | Mathlib.Algebra.Ring.Pi | ∀ (α : Type u_1) (β : Type u_2) [inst : NonAssocSemiring β] (x y : β),
(↑↑(Pi.ringHom fun x => RingHom.id β)).toFun (x + y) =
(↑↑(Pi.ringHom fun x => RingHom.id β)).toFun x + (↑↑(Pi.ringHom fun x => RingHom.id β)).toFun y |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs.0.vectorSpan_add_self._proof_1_3 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_2) {V : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] (s : Set V) (x : V),
(∃ x_1 ∈ vectorSpan k s, ∃ y ∈ s, x_1 + y = x) ↔ ∃ p₁ ∈ s, ∃ v ∈ vectorSpan k s, x = v + p₁ |
InfHom.dual._proof_3 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : Min β] (f : SupHom αᵒᵈ βᵒᵈ) (a b : αᵒᵈ),
f.toFun (a ⊔ b) = f.toFun a ⊔ f.toFun b |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.ne_singleton_iff._simp_1_2 | Mathlib.Data.List.Nodup | ∀ {a b c : Prop}, (a ∧ (b ∨ c)) = (a ∧ b ∨ a ∧ c) |
CochainComplex.shiftEval_inv_app | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n i i' : ℤ)
(hi : n + i = i') (X : CochainComplex C ℤ),
(CochainComplex.shiftEval C n i i' hi).inv.app X = (HomologicalComplex.XIsoOfEq X ⋯).inv |
NonUnitalStarAlgHom.codRestrict._proof_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {F : Type u_4} {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R]
[inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : Module R B] [inst_6 : Star B] [inst_7 : FunLike F A B] [inst_8 : NonUnitalAlgHomClass F R A B]
[StarHomClass F A B] (f : F) (S : NonUnitalStarSubalgebra R B) (hf : ∀ (x : A), f x ∈ S) (a : A),
(NonUnitalAlgHom.codRestrict f S.toNonUnitalSubalgebra hf).toFun (star a) =
star ((NonUnitalAlgHom.codRestrict f S.toNonUnitalSubalgebra hf).toFun a) |
BitVec.ofNat_sub_ofNat_of_le | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : ℕ), y < 2 ^ w → y ≤ x → BitVec.ofNat w x - BitVec.ofNat w y = BitVec.ofNat w (x - y) |
Algebra.mem_adjoin_of_map_mul | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {s : Set A} {x : A} {f : A →ₗ[R] B},
(∀ (a₁ a₂ : A), f (a₁ * a₂) = f a₁ * f a₂) → x ∈ Algebra.adjoin R s → f x ∈ Algebra.adjoin R (⇑f '' (s ∪ {1})) |
Lean.Parser.Term.elabToSyntax.formatter | Lean.Elab.Term.TermElabM | Lean.PrettyPrinter.Formatter |
ContinuousMap.HomotopyWith.instFunLike | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} → {P : C(X, Y) → Prop} → FunLike (f₀.HomotopyWith f₁ P) (↑unitInterval × X) Y |
Matrix.replicateCol_zero | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {α : Type v} {ι : Type u_6} [inst : Zero α], Matrix.replicateCol ι 0 = 0 |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith.disjoint_iff_ne._simp_1_6 | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) |
FirstOrder.Language.Hom.homClass | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N],
L.HomClass (L.Hom M N) M N |
MonCat.Colimits.monoidColimitType._proof_1 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat)
(x : MonCat.Colimits.ColimitType F), npowRecAuto 0 x = 1 |
Thunk.fn | Init.Core | {α : Type u} → Thunk α → Unit → α |
_private.Mathlib.Combinatorics.Derangements.Finite.0.card_derangements_fin_eq_numDerangements._proof_1_1 | Mathlib.Combinatorics.Derangements.Finite | ∀ (n : ℕ), n + 1 < n + 1 + 1 |
PFunctor.W | Mathlib.Data.PFunctor.Univariate.Basic | PFunctor.{uA, uB} → Type (max uA uB) |
_private.Mathlib.Topology.Filter.0.Filter.sInter_nhds._simp_1_1 | Mathlib.Topology.Filter | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) |
CategoryTheory.LocalizerMorphism.LeftResolution.Hom.ext_iff | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C₁}
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{L L' : Φ.LeftResolution X₂} {x y : L.Hom L'}, x = y ↔ x.f = y.f |
BooleanRing.mul_one_add_self | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a : α), a * (1 + a) = 0 |
CategoryTheory.ComposableArrows.fourδ₃Toδ₂._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₂₃ : i₁ ⟶ i₃) (f₃₄ : i₂ ⟶ i₄),
CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃ →
CategoryTheory.CategoryStruct.comp f₃ f₄ = f₃₄ →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ComposableArrows.mk₃ f₁ f₂ f₃₄).map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4
_proof_290✝)
(CategoryTheory.CategoryStruct.id ((CategoryTheory.ComposableArrows.mk₃ f₁ f₂ f₃₄).obj' 1 _proof_290✝¹)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id ((CategoryTheory.ComposableArrows.mk₃ f₁ f₂ f₃₄).obj' 0 _proof_289✝))
((CategoryTheory.ComposableArrows.mk₃ f₁ f₂₃ f₄).map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4
_proof_290✝²) |
SimpleGraph.Walk.head_support._proof_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {a b : V} (p : G.Walk a b), p.support ≠ [] |
CategoryTheory.Functor.Monoidal.toUnit_ε | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit (F.obj X))
(CategoryTheory.Functor.LaxMonoidal.ε F) =
F.map (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X) |
Filter.rcomap'_sets | Mathlib.Order.Filter.Partial | ∀ {α : Type u} {β : Type v} (r : SetRel α β) (f : Filter β),
(Filter.rcomap' r f).sets = SetRel.image {(s, t) | r.preimage s ⊆ t} f.sets |
Set.image2_iInter_subset_right | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_5} (f : α → β → γ) (s : Set α) (t : ι → Set β),
Set.image2 f s (⋂ i, t i) ⊆ ⋂ i, Set.image2 f s (t i) |
Lean.Compiler.LCNF.Probe.filterByUnreach | Lean.Compiler.LCNF.Probing | (pu : Lean.Compiler.LCNF.Purity) →
(Lean.Expr → Lean.Compiler.LCNF.CompilerM Bool) →
Lean.Compiler.LCNF.Probe (Lean.Compiler.LCNF.Decl pu) (Lean.Compiler.LCNF.Decl pu) |
AddMonoidHom.mulRight₃._proof_2 | Mathlib.Algebra.Ring.Associator | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (x y : R),
AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft (x + y)) =
AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft x) + AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft y) |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.0.wrapped._proof_1._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.588747923._hygCtx._hyg.2 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | @definition✝ = @definition✝ |
SimpleGraph.Walk.getVert_comp_val_eq_get_support | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.getVert ∘ Fin.val = p.support.get |
UniformSpace.Completion.isDenseInducing_coe | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α], IsDenseInducing UniformSpace.Completion.coe' |
instFinitePresentationForall | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : Ring R] {ι : Type u_2} [Finite ι], Module.FinitePresentation R (ι → R) |
AffineIsometry.norm_map | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (self : P →ᵃⁱ[𝕜] P₂) (x : V), ‖self.linear x‖ = ‖x‖ |
Lean.IR.CollectMaps.collectDecl | Lean.Compiler.IR.EmitUtil | Lean.IR.Decl → Lean.IR.CollectMaps.Collector |
Finset.instGradeMinOrder_nat | Mathlib.Data.Finset.Grade | {α : Type u_1} → GradeMinOrder ℕ (Finset α) |
ZeroAtInftyContinuousMap.instFunLike | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : Zero β] → FunLike (ZeroAtInftyContinuousMap α β) α β |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.dvdTight.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c₁ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) (c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.dvdTight c₁ c₂) = 1 + sizeOf c₁ + sizeOf c₂ |
ValuationRing.commGroupWithZero._proof_9 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_1) [inst : CommRing A] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra A K]
(a b : ValuationRing.ValueGroup A K), a / b = a * b⁻¹ |
HOrElse.ctorIdx | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → HOrElse α β γ → ℕ |
AddCon.comap_eq | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {c : AddCon M} {f : N →+ M},
AddCon.comap ⇑f ⋯ c = AddCon.ker (c.mk'.comp f) |
Finmap.insert | Mathlib.Data.Finmap | {α : Type u} → {β : α → Type v} → [DecidableEq α] → (a : α) → β a → Finmap β → Finmap β |
TopologicalSpace.NonemptyCompacts.instSemilatticeSup._proof_4 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x x_1 : TopologicalSpace.NonemptyCompacts α), ↑(x ⊔ x_1) = ↑(x ⊔ x_1) |
Polynomial.fourierCoeff_toAddCircle | Mathlib.Analysis.Polynomial.Fourier | ∀ (p : Polynomial ℂ) (n : ℤ), fourierCoeff (⇑(Polynomial.toAddCircle p)) n = if 0 ≤ n then p.coeff n.natAbs else 0 |
Std.Internal.List.Const.getValueD_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {fallback : β} {f : α → β → Bool} {l : List ((_ : α) × β)},
Std.Internal.List.DistinctKeys l →
∀ {k : α},
Std.Internal.List.getValueD k (List.filter (fun p => f p.fst p.snd) l) fallback =
((Std.Internal.List.getValue? k l).pfilter fun v h => f (Std.Internal.List.getKey k l ⋯) v).getD fallback |
Matrix.nondegenerate_iff_det_ne_zero | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {n : Type u_1} [inst : Fintype n] {A : Type u_4} [inst_1 : DecidableEq n] [inst_2 : CommRing A] [IsDomain A]
{M : Matrix n n A}, M.Nondegenerate ↔ M.det ≠ 0 |
AlgebraicGeometry.StructureSheaf.const_mul | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R A : Type u} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] (f₁ f₂ : A) (g₁ g₂ : R)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (hu₁ : U ≤ PrimeSpectrum.basicOpen g₁)
(hu₂ : U ≤ PrimeSpectrum.basicOpen g₂),
AlgebraicGeometry.StructureSheaf.const f₁ g₁ U hu₁ * AlgebraicGeometry.StructureSheaf.const f₂ g₂ U hu₂ =
AlgebraicGeometry.StructureSheaf.const (f₁ * f₂) (g₁ * g₂) U ⋯ |
IsCoercive.continuousLinearEquivOfBilin | Mathlib.Analysis.InnerProductSpace.LaxMilgram | {V : Type u} →
[inst : NormedAddCommGroup V] →
[inst_1 : InnerProductSpace ℝ V] → [CompleteSpace V] → {B : V →L[ℝ] V →L[ℝ] ℝ} → IsCoercive B → V ≃L[ℝ] V |
Bundle.Pretrivialization.linearEquivAt | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_4} →
[inst : Semiring R] →
[inst_1 : TopologicalSpace F] →
[inst_2 : TopologicalSpace B] →
[inst_3 : AddCommMonoid F] →
[inst_4 : Module R F] →
[inst_5 : (x : B) → AddCommMonoid (E x)] →
[inst_6 : (x : B) → Module R (E x)] →
(e : Bundle.Pretrivialization F Bundle.TotalSpace.proj) →
[Bundle.Pretrivialization.IsLinear R e] → (b : B) → b ∈ e.baseSet → E b ≃ₗ[R] F |
HasSubset.Subset.trans | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] [IsTrans α fun x1 x2 => x1 ⊆ x2] {a b c : α}, a ⊆ b → b ⊆ c → a ⊆ c |
Units.mul_right_inj | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) {b c : α}, ↑a * b = ↑a * c ↔ b = c |
Derivation.liftOfSurjective.congr_simp | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : CommRing M]
[inst_3 : Algebra R A] [inst_4 : Algebra R M] {F : Type u_4} [inst_5 : FunLike F A M] [inst_6 : AlgHomClass F R A M]
{f f_1 : F} (e_f : f = f_1) (hf : Function.Surjective ⇑f) ⦃d d_1 : Derivation R A A⦄ (e_d : d = d_1)
(hd : ∀ (x : A), f x = 0 → f (d x) = 0), Derivation.liftOfSurjective hf hd = Derivation.liftOfSurjective ⋯ ⋯ |
RingTheory.LinearMap._aux_Mathlib_Algebra_Algebra_Bilinear___macroRules_RingTheory_LinearMap_termμ_1 | Mathlib.Algebra.Algebra.Bilinear | Lean.Macro |
ProbabilityTheory.Kernel.borelMarkovFromReal.congr_simp | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {mα : MeasurableSpace α} (Ω : Type u_5) [inst : Nonempty Ω] [inst_1 : MeasurableSpace Ω]
[inst_2 : StandardBorelSpace Ω] (η η_1 : ProbabilityTheory.Kernel α ℝ),
η = η_1 → ProbabilityTheory.Kernel.borelMarkovFromReal Ω η = ProbabilityTheory.Kernel.borelMarkovFromReal Ω η_1 |
Equiv.pemptyArrowEquivPUnit | Mathlib.Logic.Equiv.Defs | (α : Sort u_1) → (PEmpty.{u_2} → α) ≃ PUnit.{u} |
CategoryTheory.Cat.FreeRefl.lift | Mathlib.CategoryTheory.Category.ReflQuiv | {V : Type u_1} →
[inst : CategoryTheory.ReflQuiver V] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] →
V ⥤rq D → CategoryTheory.Functor (CategoryTheory.Cat.FreeRefl V) D |
PerfectClosure.instNeg | Mathlib.FieldTheory.PerfectClosure | (K : Type u) →
[inst : CommRing K] → (p : ℕ) → [inst_1 : Fact (Nat.Prime p)] → [inst_2 : CharP K p] → Neg (PerfectClosure K p) |
CategoryTheory.LocalizerMorphism.RightResolution._sizeOf_1 | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
{X₂ : C₂} →
[SizeOf C₁] →
[SizeOf C₂] →
[⦃X Y : C₁⦄ → (x : X ⟶ Y) → SizeOf (W₁ x)] →
[⦃X Y : C₂⦄ → (x : X ⟶ Y) → SizeOf (W₂ x)] → Φ.RightResolution X₂ → ℕ |
AddSubsemigroup.coe_op | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] (x : AddSubsemigroup M), ↑x.op = AddOpposite.unop ⁻¹' ↑x |
Polynomial.mapRingHom_comp_C | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
(Polynomial.mapRingHom f).comp Polynomial.C = Polynomial.C.comp f |
CategoryTheory.instBicategoryMonoidalSingleObj._proof_6 | Mathlib.CategoryTheory.Bicategory.SingleObj | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{a b : CategoryTheory.MonoidalSingleObj C} {f g : C} (η : f ⟶ g),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) η =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor f).hom
(CategoryTheory.CategoryStruct.comp η (CategoryTheory.MonoidalCategoryStruct.leftUnitor g).inv) |
_private.Init.Data.List.Basic.0.List.getLastD.match_1.eq_1 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → α → Sort u_2) (a₀ : α) (h_1 : (a₀ : α) → motive [] a₀)
(h_2 : (a : α) → (as : List α) → (x : α) → motive (a :: as) x),
(match [], a₀ with
| [], a₀ => h_1 a₀
| a :: as, x => h_2 a as x) =
h_1 a₀ |
Aesop.Script.Tactic.sTactic? | Aesop.Script.Tactic | Aesop.Script.Tactic → Option Aesop.Script.STactic |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.recommendedSpellingByNameExt.match_1 | Lean.Parser.Term.Doc | (motive : Lean.Parser.Term.Doc.RecommendedSpelling × Array Lean.Name → Sort u_1) →
(x : Lean.Parser.Term.Doc.RecommendedSpelling × Array Lean.Name) →
((rec : Lean.Parser.Term.Doc.RecommendedSpelling) → (xs : Array Lean.Name) → motive (rec, xs)) → motive x |
Real.convexOn_log_Gamma | Mathlib.Analysis.SpecialFunctions.Gamma.BohrMollerup | ConvexOn ℝ (Set.Ioi 0) (Real.log ∘ Real.Gamma) |
Array.beq_eq_decide | Init.Data.Array.DecidableEq | ∀ {α : Type u_1} [inst : BEq α] (xs ys : Array α),
(xs == ys) = if h : xs.size = ys.size then decide (∀ (i : ℕ) (h' : i < xs.size), (xs[i] == ys[i]) = true) else false |
CategoryTheory.Localization.Monoidal.functorCoreMonoidalOfComp | Mathlib.CategoryTheory.Localization.Monoidal.Functor | {C : Type u_1} →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
[inst_3 : CategoryTheory.MonoidalCategory C] →
[inst_4 : CategoryTheory.MonoidalCategory D] →
[inst_5 : CategoryTheory.MonoidalCategory E] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →
[L.Monoidal] →
(F : CategoryTheory.Functor D E) →
(G : CategoryTheory.Functor C E) →
[G.Monoidal] →
[W.ContainsIdentities] → [CategoryTheory.Localization.Lifting L W G F] → F.CoreMonoidal |
SimpleGraph.le_chromaticNumber_iff_coloring | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u} {G : SimpleGraph V} {n : ℕ}, ↑n ≤ G.chromaticNumber ↔ ∀ (m : ℕ) (a : G.Coloring (Fin m)), n ≤ m |
Subgroup.Commensurable.eq_1 | Mathlib.GroupTheory.Commensurable | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), H.Commensurable K = (H.relIndex K ≠ 0 ∧ K.relIndex H ≠ 0) |
Unitization.instNonAssocRing._proof_9 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_2} {A : Type u_1} [inst : CommRing R] [inst_1 : NonUnitalNonAssocRing A] [inst_2 : Module R A], ↑0 = 0 |
Std.Iter.toIter_toIterM | Init.Data.Iterators.Basic | ∀ {α β : Type w} (it : Std.Iter β), it.toIterM.toIter = it |
LinearIsometry.strictConvexSpace_range | Mathlib.Analysis.Convex.LinearIsometry | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedField 𝕜] [inst_1 : PartialOrder 𝕜]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜 F]
[StrictConvexSpace 𝕜 E] (e : E →ₗᵢ[𝕜] F), StrictConvexSpace 𝕜 ↥(↑e).range |
monotoneOn_of_le_add_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : One α]
[inst_4 : SuccAddOrder α] [IsSuccArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMax a → a ∈ s → a + 1 ∈ s → f a ≤ f (a + 1)) → MonotoneOn f s |
ContinuousAlternatingMap.ofSubsingleton_toAlternatingMap | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ (R : Type u_1) (M : Type u_2) (N : Type u_4) {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : Subsingleton ι] (i : ι) (f : M →L[R] N),
((ContinuousAlternatingMap.ofSubsingleton R M N i) f).toAlternatingMap = (AlternatingMap.ofSubsingleton R M N i) ↑f |
Filter.bliminf_or_le_inf_aux_right._simp_1 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β} {p q : β → Prop} {u : β → α},
((Filter.bliminf u f fun x => p x ∨ q x) ≤ Filter.bliminf u f q) = True |
definition._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | {ι : Type u_1} →
{𝕜 : Type u_3} →
[inst : RCLike 𝕜] →
{E : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[Fintype ι] →
[FiniteDimensional 𝕜 E] →
{n : ℕ} →
Module.finrank 𝕜 E = n →
[inst_5 : DecidableEq ι] →
{V : ι → Submodule 𝕜 E} →
DirectSum.IsInternal V →
(OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) →
(i : ι) × Fin (Module.finrank 𝕜 ↥(V i)) ≃ Fin n |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.EqCnstr.collectDecVars.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | (motive : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) →
((a zero : Lean.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core0 a zero)) →
((a b : Lean.Expr) →
(p₁ p₂ : Int.Linear.Poly) → motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core a b p₁ p₂)) →
((e : Lean.Expr) → (p : Int.Linear.Poly) → motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defn e p)) →
((h : Lean.Expr) →
(x : Int.Linear.Var) →
(e' : Int.Linear.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNat h x e')) →
((e : Lean.Expr) →
(p : Int.Linear.Poly) →
(re : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(rp : Lean.Grind.CommRing.Poly) →
(p' : Int.Linear.Poly) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnCommRing e p re rp p')) →
((h : Lean.Expr) →
(x : Int.Linear.Var) →
(e' : Int.Linear.Expr) →
(p : Int.Linear.Poly) →
(re : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(rp : Lean.Grind.CommRing.Poly) →
(p' : Int.Linear.Poly) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNatCommRing h x e' p re rp p')) →
((a b toIntThm : Lean.Expr) →
(lhs rhs : Int.Linear.Expr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.coreToInt a b toIntThm lhs rhs)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
(e : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(p : Lean.Grind.CommRing.Poly) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.commRingNorm c e p)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.reorder c)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.norm c)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.divCoeffs c)) →
((k : ℤ) →
(y? : Option Int.Linear.Var) →
(c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.div k y? c)) →
((k : ℤ) →
(y? : Option Int.Linear.Var) →
(c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod k y? c)) →
((x : Int.Linear.Var) →
(c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.subst x c₁ c₂)) →
((c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe c₁ c₂)) →
((a? : Option Lean.Expr) →
(cs : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mul a? cs)) →
((ka : ℤ) →
(ca? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
(kb : ℕ) →
(cb? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow ka ca? kb cb?)) →
motive x |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.Basic | {P : Sort u} →
{t t' : ProofWidgets.RpcEncodablePacket✝} →
t = t' →
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusionType P t t' |
Lean.guardMsgsPositions | Init.Notation | Lean.ParserDescr |
subset_tangentConeAt_prod_left | Mathlib.Analysis.Calculus.TangentCone.Prod | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] [ContinuousConstSMul 𝕜 E] [inst_6 : AddCommGroup F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [ContinuousAdd F] [ContinuousConstSMul 𝕜 F] {x : E} {s : Set E}
{y : F} {t : Set F}, y ∈ closure t → ⇑(LinearMap.inl 𝕜 E F) '' tangentConeAt 𝕜 s x ⊆ tangentConeAt 𝕜 (s ×ˢ t) (x, y) |
AlgebraicGeometry.Scheme.kerAdjunction_counit_app | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ (Y : AlgebraicGeometry.Scheme) (f : (CategoryTheory.Over Y)ᵒᵖ),
Y.kerAdjunction.counit.app f =
(CategoryTheory.Over.homMk (AlgebraicGeometry.Scheme.Hom.toImage (Opposite.unop f).hom) ⋯).op |
_private.Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop.0.Std.IterM.instForIn'.eq_1 | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type w'} {n : Type w → Type w''} {α β : Type w} [inst : Std.Iterator α m β]
[inst_1 : Std.IteratorLoop α m n] [inst_2 : Monad n] [inst_3 : MonadLiftT m n],
Std.IterM.instForIn' = Std.IteratorLoop.finiteForIn' fun x x_1 f x_2 => monadLift x_2 >>= f |
ZFSet.card_empty | Mathlib.SetTheory.ZFC.Cardinal | ∅.card = 0 |
_private.Mathlib.Topology.Spectral.ConstructibleTopology.0.compactSpace_withConstructibleTopology._proof_14 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X],
∀ s ∈ {P | P ⊆ constructibleTopologySubbasis X ∧ (∀ Q ⊆ P, Q.Finite → (⋂₀ Q).Nonempty) ∧ ⋂₀ P = ∅},
∀ (B : Set (Set X)) (Y₁ Y₂ : Set X),
⋂₀ {s | s ∈ B ∧ IsClosed s} ⊆ Y₁ ∪ Y₂ →
∀ x₁ ∈ ⋂₀ {s | s ∈ B ∧ IsClosed s} ∩ Y₁ᶜ,
∀ x₂ ∈ ⋂₀ {s | s ∈ B ∧ IsClosed s} ∩ Y₂ᶜ,
Y₁ ∩ ⋂₀ B = ∅ →
Y₂ ∩ ⋂₀ B = ∅ →
∀ (A₁ : Set (Set X)),
⋂₀ A₁ = ∅ →
∀ (A₂ : Set (Set X)), ⋂₀ A₂ = ∅ → ⋂₀ {s | s ∈ B ∧ IsClosed s} ∩ ⋂₀ (A₁ \ {Y₁} ∪ A₂ \ {Y₂}) = ∅ |
SeparatelyContinuousMul.rec | Mathlib.Topology.Algebra.Monoid.Defs | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : Mul M] →
{motive : SeparatelyContinuousMul M → Sort u} →
((continuous_const_mul : ∀ {a : M}, Continuous fun x => a * x) →
(continuous_mul_const : ∀ {a : M}, Continuous fun x => x * a) → motive ⋯) →
(t : SeparatelyContinuousMul M) → motive t |
Subring.mem_toSubsemiring._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : Ring R] {s : Subring R} {x : R}, (x ∈ s.toSubsemiring) = (x ∈ s) |
Lean.Syntax.ident.inj | Init.Core | ∀ {info : Lean.SourceInfo} {rawVal : Substring.Raw} {val : Lean.Name} {preresolved : List Lean.Syntax.Preresolved}
{info_1 : Lean.SourceInfo} {rawVal_1 : Substring.Raw} {val_1 : Lean.Name}
{preresolved_1 : List Lean.Syntax.Preresolved},
Lean.Syntax.ident info rawVal val preresolved = Lean.Syntax.ident info_1 rawVal_1 val_1 preresolved_1 →
info = info_1 ∧ rawVal = rawVal_1 ∧ val = val_1 ∧ preresolved = preresolved_1 |
CliffordAlgebra.reverse_mem_evenOdd_iff | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {x : CliffordAlgebra Q} {n : ZMod 2},
CliffordAlgebra.reverse x ∈ CliffordAlgebra.evenOdd Q n ↔ x ∈ CliffordAlgebra.evenOdd Q n |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.rec | Lean.Meta.LetToHave | {motive : Lean.Meta.LetToHave.State✝ → Sort u} →
((count : ℕ) →
(results : Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Result✝) →
motive { count := count, results := results }) →
(t : Lean.Meta.LetToHave.State✝¹) → motive t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.