name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ArchimedeanClass.FiniteResidueField.ofArchimedean._proof_3 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {R : Type u_2}
[inst_3 : LinearOrder R] [inst_4 : CommRing R] [inst_5 : IsStrictOrderedRing R] [inst_6 : Archimedean R]
(f : R →+*o K) (x y : R),
ArchimedeanClass.FiniteResidueField.mk (ArchimedeanClass.FiniteElement.mk (f (x * y)) ⋯) =
ArchimedeanClass.FiniteResidueField.mk (ArchimedeanClass.FiniteElement.mk (f x) ⋯) *
ArchimedeanClass.FiniteResidueField.mk (ArchimedeanClass.FiniteElement.mk (f y) ⋯) |
CategoryTheory.SymmetricCategory.toBraidedCategory | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
[self : CategoryTheory.SymmetricCategory C] → CategoryTheory.BraidedCategory C |
WittVector.fromPadicInt | Mathlib.RingTheory.WittVector.Compare | (p : ℕ) → [hp : Fact (Nat.Prime p)] → ℤ_[p] →+* WittVector p (ZMod p) |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.Arg.inferType.match_1 | Lean.Compiler.LCNF.InferType | (motive : (pu : Lean.Compiler.LCNF.Purity) → Lean.Compiler.LCNF.Arg pu → Sort u_1) →
(pu : Lean.Compiler.LCNF.Purity) →
(arg : Lean.Compiler.LCNF.Arg pu) →
((arg : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) → motive Lean.Compiler.LCNF.Purity.pure arg) →
((arg : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure) →
motive Lean.Compiler.LCNF.Purity.impure arg) →
motive pu arg |
TypeVec.toSubtype'._sunfold | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u} n} →
(p : (α.prod α).Arrow (TypeVec.repeat n Prop)) →
TypeVec.Arrow (fun i => { x // TypeVec.ofRepeat (p i (TypeVec.prod.mk i x.1 x.2)) }) (TypeVec.Subtype_ p) |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.chi_not_in_q_aux | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_5 : H.IsCartanSubalgebra]
[inst_6 : LieAlgebra.IsKilling K L] [inst_7 : LieModule.IsTriangularizable K (↥H) L]
(q : Submodule K (Module.Dual K ↥H)),
(∀ (i : ↥LieSubalgebra.root), q ∈ Module.End.invtSubmodule ↑((LieAlgebra.IsKilling.rootSystem H).reflection i)) →
∀ (χ : LieModule.Weight K (↥H) L) (x_χ m_α : L),
x_χ ∈ LieModule.genWeightSpace L ⇑χ →
∀ (α : LieModule.Weight K (↥H) L),
LieModule.Weight.toLinear K (↥H) L α ∈ q →
α.IsNonZero →
LieModule.Weight.toLinear K (↥H) L χ + LieModule.Weight.toLinear K (↥H) L α ≠ 0 →
LieModule.Weight.toLinear K (↥H) L χ - LieModule.Weight.toLinear K (↥H) L α ≠ 0 →
LieModule.Weight.toLinear K (↥H) L χ ≠ 0 →
∀ (m_pos m_neg : L),
∀ y ∈ LieAlgebra.corootSpace ⇑α,
⁅x_χ, m_α⁆ = ⁅x_χ, m_pos⁆ + ⁅x_χ, m_neg⁆ + ⁅x_χ, ↑y⁆ →
⁅x_χ, m_pos⁆ ∈ LieModule.genWeightSpace L (⇑χ + ⇑α) →
⁅x_χ, m_neg⁆ ∈ LieModule.genWeightSpace L (⇑χ - ⇑α) →
LieModule.Weight.toLinear K (↥H) L χ ∉ q →
⁅x_χ, m_α⁆ ∈ ⨆ α, LieAlgebra.IsKilling.sl2SubmoduleOfRoot ⋯ |
Sum.LiftRel.isRight_right | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {y : γ ⊕ δ} {b : β},
Sum.LiftRel r s (Sum.inr b) y → y.isRight = true |
LinearMap.comap_prod_prod | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) (p : Submodule R M₂) (q : Submodule R M₃),
Submodule.comap (f.prod g) (p.prod q) = Submodule.comap f p ⊓ Submodule.comap g q |
Metric.thickening_thickening_subset | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (ε δ : ℝ) (s : Set α),
Metric.thickening ε (Metric.thickening δ s) ⊆ Metric.thickening (ε + δ) s |
ENNReal.inv_rpow | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (x : ENNReal) (y : ℝ), x⁻¹ ^ y = (x ^ y)⁻¹ |
_private.Lean.Elab.Tactic.Do.ProofMode.Exact.0.Lean.Elab.Tactic.Do.ProofMode.MGoal.exactPure._sparseCasesOn_1 | Lean.Elab.Tactic.Do.ProofMode.Exact | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
MvPowerSeries.instNontrivial | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [Nontrivial R], Nontrivial (MvPowerSeries σ R) |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.instCategory | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
(X : Type u₄) →
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] →
CategoryTheory.Category.{max (max u₄ v₃) v₁, max (max (max (max (max (max u₄ u₃) u₁) v₄) v₃) v₂) v₁}
(CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X) |
LieSubalgebra.coe_incl' | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L),
⇑L'.incl' = Subtype.val |
Lean.Grind.OrderConfig.funCC._inherited_default | Init.Grind.Config | Bool |
Option.instTransOrd | Init.Data.Order.Ord | ∀ {α : Type u_1} [inst : Ord α] [Std.TransOrd α], Std.TransOrd (Option α) |
HomologicalComplex.HomologySequence.snakeInput._proof_4 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} {ι : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i j : ι),
CategoryTheory.CategoryStruct.comp (S.mapNatTrans (HomologicalComplex.natTransOpCyclesToCycles C c i j))
(S.mapNatTrans (HomologicalComplex.natTransHomologyπ C c j)) =
0 |
Ring.instIsScalarTowerFractionRingSubtypeAlgebraicClosureMemIntermediateFieldNormalClosure | Mathlib.RingTheory.NormalClosure | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : IsDomain S]
[inst_4 : Algebra R S] [inst_5 : Module.IsTorsionFree R S],
IsScalarTower S (FractionRing S)
↥(IntermediateField.normalClosure (FractionRing R) (FractionRing S) (AlgebraicClosure (FractionRing S))) |
Fin.instSub | Init.Data.Fin.Basic | {n : ℕ} → Sub (Fin n) |
HolderOnWith.ediam_image_le_of_subset_of_le | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {C r : NNReal} {f : X → Y}
{s t : Set X},
HolderOnWith C r f s → t ⊆ s → ∀ {d : ENNReal}, Metric.ediam t ≤ d → Metric.ediam (f '' t) ≤ ↑C * d ^ ↑r |
Int64.reduceAdd._regBuiltin.Int64.reduceAdd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.4041591762._hygCtx._hyg.56 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit |
CategoryTheory.Pseudofunctor.DescentData'.descentDataEquivalence._proof_11 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Limits.ChosenPullback₃ (sq i₁ i₂) (sq i₂ i₃) (sq i₁ i₃))
(X_1 : F.DescentData' sq sq₃),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pseudofunctor.DescentData'.toDescentDataFunctor F sq sq₃).map
((CategoryTheory.NatIso.ofComponents
(fun D =>
CategoryTheory.Pseudofunctor.DescentData'.isoMk
(fun x =>
CategoryTheory.Iso.refl (((CategoryTheory.Functor.id (F.DescentData' sq sq₃)).obj D).obj x))
⋯)
⋯).hom.app
X_1))
((CategoryTheory.NatIso.ofComponents
(fun D =>
CategoryTheory.Pseudofunctor.DescentData.isoMk
(fun x =>
CategoryTheory.Iso.refl
((((CategoryTheory.Pseudofunctor.DescentData'.fromDescentDataFunctor F sq sq₃).comp
(CategoryTheory.Pseudofunctor.DescentData'.toDescentDataFunctor F sq sq₃)).obj
D).obj
x))
⋯)
⋯).hom.app
((CategoryTheory.Pseudofunctor.DescentData'.toDescentDataFunctor F sq sq₃).obj X_1)) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.Pseudofunctor.DescentData'.toDescentDataFunctor F sq sq₃).obj X_1) |
Matrix.separatingRight_toLinearMap₂'_iff_separatingRight_toLinearMap₂ | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {M₂ : Type u_7} {n : Type u_11} {m : Type u_12} [inst : CommRing R]
[inst_1 : DecidableEq m] [inst_2 : Fintype m] [inst_3 : DecidableEq n] [inst_4 : Fintype n] {M : Matrix m n R}
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module R M₂]
(b₁ : Module.Basis m R M₁) (b₂ : Module.Basis n R M₂),
((Matrix.toLinearMap₂' R) M).SeparatingRight ↔ ((Matrix.toLinearMap₂ b₁ b₂) M).SeparatingRight |
_private.Mathlib.Analysis.Complex.CanonicalDecomposition.0.Complex.meromorphicNFOn_canonicalFactor._proof_1_1 | Mathlib.Analysis.Complex.CanonicalDecomposition | -1 < 0 |
ZFSet.image.match_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (f : ZFSet.{u_1} → ZFSet.{u_1}) [inst : ZFSet.Definable₁ f] (x x_1 : PSet.{u_1})
(motive : (∃ z ∈ x, x_1.Equiv (ZFSet.Definable₁.out f z)) → Prop)
(x_2 : ∃ z ∈ x, x_1.Equiv (ZFSet.Definable₁.out f z)),
(∀ (w : PSet.{u_1}) (h1 : w ∈ x) (h2 : x_1.Equiv (ZFSet.Definable₁.out f w)), motive ⋯) → motive x_2 |
_private.Lean.Linter.ConstructorAsVariable.0.Lean.Linter.constructorNameAsVariable.match_16 | Lean.Linter.ConstructorAsVariable | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
((n : Lean.Name) →
(s : String) → (h : n = Lean.Name.anonymous.str s) → motive (namedPattern n (Lean.Name.anonymous.str s) h)) →
((x : Lean.Name) → motive x) → motive x |
_aux_Mathlib_Combinatorics_SimpleGraph_Basic___macroRules_aesop_graph_1 | Mathlib.Combinatorics.SimpleGraph.Basic | Lean.Macro |
_private.Mathlib.RingTheory.WittVector.InitTail.0.WittVector.init_sub._proof_1_6 | Mathlib.RingTheory.WittVector.InitTail | ∀ (n i : ℕ), i < n → ∀ k < i + 1, k < n |
_private.Lean.Elab.Inductive.0.Lean.Elab.Command.inductiveSyntaxToView | Lean.Elab.Inductive | Lean.Elab.Modifiers → Lean.Syntax → Bool → Lean.Elab.TermElabM Lean.Elab.Command.InductiveView |
PadicInt.unitCoeff_spec | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℤ_[p]} (hx : x ≠ 0), x = ↑(PadicInt.unitCoeff hx) * ↑p ^ x.valuation |
IsManifold.subset_maximalAtlas | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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} {n : WithTop ℕ∞}
{M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [IsManifold I n M],
atlas H M ⊆ IsManifold.maximalAtlas I n M |
ULift.instLinearOrder | Mathlib.Order.Lattice | {α : Type u} → [LinearOrder α] → LinearOrder (ULift.{v, u} α) |
CategoryTheory.Grp.forget₂Mon_map_hom | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : CategoryTheory.Grp C} (f : A ⟶ B), ((CategoryTheory.Grp.forget₂Mon C).map f).hom = f.hom.hom |
pos_of_right_mul_lt_le | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b c : R} [ExistsAddOfLE R] [PosMulMono R]
[AddRightMono R] [AddRightReflectLE R], a * b < a * c → b ≤ c → 0 < a |
_private.Mathlib.NumberTheory.BernoulliPolynomials.0.Polynomial.sum_bernoulli._simp_1_4 | Mathlib.NumberTheory.BernoulliPolynomials | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) |
_private.Mathlib.NumberTheory.Transcendental.Liouville.Residual.0.setOf_liouville_eq_iInter_iUnion._simp_1_1 | Mathlib.NumberTheory.Transcendental.Liouville.Residual | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i |
List.getElem_of_append | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α} {i : ℕ} {l : List α} (eq : l = l₁ ++ a :: l₂) (h : l₁.length = i),
l[i] = a |
ZMod.χ₈'._proof_1 | Mathlib.NumberTheory.LegendreSymbol.ZModChar | (match 1 with
| 0 => 0
| 2 => 0
| 4 => 0
| 6 => 0
| 1 => 1
| 3 => 1
| 5 => -1
| 7 => -1) =
match 1 with
| 0 => 0
| 2 => 0
| 4 => 0
| 6 => 0
| 1 => 1
| 3 => 1
| 5 => -1
| 7 => -1 |
AlgebraicGeometry.Scheme.affineOpenCoverOfSpanRangeEqTop | Mathlib.AlgebraicGeometry.Cover.Open | {R : CommRingCat} →
{ι : Type u_1} → (s : ι → ↑R) → Ideal.span (Set.range s) = ⊤ → (AlgebraicGeometry.Spec R).AffineOpenCover |
Lean.Meta.Grind.Arith.CommRing.SemiringM.Context.rec | Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM | {motive : Lean.Meta.Grind.Arith.CommRing.SemiringM.Context → Sort u} →
((semiringId : ℕ) → motive { semiringId := semiringId }) →
(t : Lean.Meta.Grind.Arith.CommRing.SemiringM.Context) → motive t |
Batteries.PairingHeapImp.Heap.toArray | Batteries.Data.PairingHeap | {α : Type u_1} → (α → α → Bool) → Batteries.PairingHeapImp.Heap α → Array α |
CategoryTheory.nerve.edgeMk_id | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : C),
CategoryTheory.nerve.edgeMk (CategoryTheory.CategoryStruct.id x) = SSet.Edge.id (CategoryTheory.nerveEquiv.symm x) |
Submodule.orthogonalProjection._proof_4 | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (x : E),
‖{ toFun := fun v => ⟨K.orthogonalProjectionFn v, ⋯⟩, map_add' := ⋯, map_smul' := ⋯ } x‖ ≤ 1 * ‖x‖ |
Lean.Lsp.WorkspaceEditClientCapabilities.noConfusion | Lean.Data.Lsp.Capabilities | {P : Sort u} →
{t t' : Lean.Lsp.WorkspaceEditClientCapabilities} →
t = t' → Lean.Lsp.WorkspaceEditClientCapabilities.noConfusionType P t t' |
_private.Mathlib.Algebra.Homology.ShortComplex.Homology.0.CategoryTheory.ShortComplex.isIso_homologyMap_of_isIso_cyclesMap_of_epi.match_1_2 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology]
(h₁ : CategoryTheory.IsIso (CategoryTheory.ShortComplex.cyclesMap φ))
(motive :
{ l //
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Cofork.π (CategoryTheory.Limits.CokernelCofork.ofπ S₂.homologyπ ⋯)) l =
CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (CategoryTheory.ShortComplex.cyclesMap φ))
S₁.homologyπ } →
Prop)
(x :
{ l //
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Cofork.π (CategoryTheory.Limits.CokernelCofork.ofπ S₂.homologyπ ⋯)) l =
CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (CategoryTheory.ShortComplex.cyclesMap φ))
S₁.homologyπ }),
(∀ (z : (CategoryTheory.Limits.CokernelCofork.ofπ S₂.homologyπ ⋯).pt ⟶ S₁.homology)
(hz :
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Cofork.π (CategoryTheory.Limits.CokernelCofork.ofπ S₂.homologyπ ⋯)) z =
CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (CategoryTheory.ShortComplex.cyclesMap φ))
S₁.homologyπ),
motive ⟨z, hz⟩) →
motive x |
CategoryTheory.MonoidalCategory.prodMonoidal._proof_21 | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C₁ : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C₁] [inst_1 : CategoryTheory.MonoidalCategory C₁]
(C₂ : Type u_2) [inst_2 : CategoryTheory.Category.{u_4, u_2} C₂] [inst_3 : CategoryTheory.MonoidalCategory C₂]
(X Y : C₁ × C₂),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategoryStruct.associator X.1
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C₁,
CategoryTheory.MonoidalCategoryStruct.tensorUnit C₂).1
Y.1).prod
(CategoryTheory.MonoidalCategoryStruct.associator X.2
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C₁, CategoryTheory.MonoidalCategoryStruct.tensorUnit C₂).2
Y.2)).hom
(CategoryTheory.Prod.mkHom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X.1
(match Y with
| (X₁, X₂) =>
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X₁).prod
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X₂)).hom.1)
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X.2
(match Y with
| (X₁, X₂) =>
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X₁).prod
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X₂)).hom.2)) =
CategoryTheory.Prod.mkHom
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(match X with
| (X₁, X₂) =>
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X₁).prod
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X₂)).hom.1
Y.1)
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(match X with
| (X₁, X₂) =>
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X₁).prod
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X₂)).hom.2
Y.2) |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_size_left_le_start._proof_1_2 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {i j : ℕ} {a b : Array α} (i_1 : ℕ),
i_1 + 1 ≤ (b.extract (i - a.size) (j - a.size)).size → i_1 < (b.extract (i - a.size) (j - a.size)).size |
CompletePartialOrder.noConfusionType | Mathlib.Order.CompletePartialOrder | Sort u → {α : Type u_4} → CompletePartialOrder α → {α' : Type u_4} → CompletePartialOrder α' → Sort u |
Option.pfilter_eq_some_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {p : (a : α) → o = some a → Bool} {a : α},
o.pfilter p = some a ↔ ∃ (ha : o = some a), p a ha = true |
Affine.Simplex.reflectionCircumcenterWeightsWithCircumcenter.eq_1 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {n : ℕ} (i₁ i₂ a : Fin (n + 1)),
Affine.Simplex.reflectionCircumcenterWeightsWithCircumcenter i₁ i₂
(Affine.Simplex.PointsWithCircumcenterIndex.pointIndex a) =
if a = i₁ ∨ a = i₂ then 1 else 0 |
_private.Init.Data.Range.Basic.0.Std.Legacy.Range.forIn'.loop._unary._proof_7 | Init.Data.Range.Basic | ∀ (range : Std.Legacy.Range) (i : ℕ),
autoParam (range.start ≤ i) Std.Legacy.Range.forIn'._auto_1✝ → 0 < range.step → range.start ≤ i + range.step |
Module.FaithfullyFlat.trans | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u_1) [inst : CommRing R] (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [IsScalarTower R S M]
[Module.FaithfullyFlat R S] [Module.FaithfullyFlat S M], Module.FaithfullyFlat R M |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.BoundedFormula.restrictFreeVar.match_1.eq_5 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u_3} {β : Type u_5} [inst : DecidableEq α]
(motive : (x : ℕ) → (x_1 : L.BoundedFormula α x) → (↥x_1.freeVarFinset → β) → Sort u_4) (_n : ℕ)
(φ : L.BoundedFormula α (_n + 1)) (f : ↥φ.all.freeVarFinset → β)
(h_1 :
(_n : ℕ) →
(_f : ↥FirstOrder.Language.BoundedFormula.falsum.freeVarFinset → β) →
motive _n FirstOrder.Language.BoundedFormula.falsum _f)
(h_2 :
(_n : ℕ) →
(t₁ t₂ : L.Term (α ⊕ Fin _n)) →
(f : ↥(FirstOrder.Language.BoundedFormula.equal t₁ t₂).freeVarFinset → β) →
motive _n (FirstOrder.Language.BoundedFormula.equal t₁ t₂) f)
(h_3 :
(_n l : ℕ) →
(R : L.Relations l) →
(ts : Fin l → L.Term (α ⊕ Fin _n)) →
(f : ↥(FirstOrder.Language.BoundedFormula.rel R ts).freeVarFinset → β) →
motive _n (FirstOrder.Language.BoundedFormula.rel R ts) f)
(h_4 : (_n : ℕ) → (φ₁ φ₂ : L.BoundedFormula α _n) → (f : ↥(φ₁.imp φ₂).freeVarFinset → β) → motive _n (φ₁.imp φ₂) f)
(h_5 : (_n : ℕ) → (φ : L.BoundedFormula α (_n + 1)) → (f : ↥φ.all.freeVarFinset → β) → motive _n φ.all f),
(match _n, φ.all, f with
| _n, FirstOrder.Language.BoundedFormula.falsum, _f => h_1 _n _f
| _n, FirstOrder.Language.BoundedFormula.equal t₁ t₂, f => h_2 _n t₁ t₂ f
| _n, FirstOrder.Language.BoundedFormula.rel R ts, f => h_3 _n l R ts f
| _n, φ₁.imp φ₂, f => h_4 _n φ₁ φ₂ f
| _n, φ.all, f => h_5 _n φ f) =
h_5 _n φ f |
ArchimedeanClass.mem_closedBallAddSubgroup_iff | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a : M}
{c : ArchimedeanClass M}, a ∈ c.closedBallAddSubgroup ↔ c ≤ ArchimedeanClass.mk a |
ZeroHom.instAddCommGroup | Mathlib.Algebra.Group.Hom.Instances | {M : Type uM} → {N : Type uN} → [inst : Zero M] → [inst_1 : AddCommGroup N] → AddCommGroup (ZeroHom M N) |
ExteriorAlgebra.ι_eq_algebraMap_iff._simp_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M) (r : R),
((ExteriorAlgebra.ι R) x = (algebraMap R (ExteriorAlgebra R M)) r) = (x = 0 ∧ r = 0) |
Lean.Elab.Tactic.Do.ProofMode.TypeList.mkType | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Level → Lean.Expr |
_private.Mathlib.Tactic.ErwQuestion.0.Mathlib.Tactic.Erw?._aux_Mathlib_Tactic_ErwQuestion___elabRules_Mathlib_Tactic_Erw?_erw?_1.match_3 | Mathlib.Tactic.ErwQuestion | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr) → ((tgt inferred : Lean.Expr) → motive (tgt, inferred)) → motive __discr |
Set.instLawfulMonad | Mathlib.Data.Set.Functor | LawfulMonad Set |
Std.TreeSet.instInsert | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → Insert α (Std.TreeSet α cmp) |
NonnegHomClass.casesOn | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : Zero β] →
[inst_1 : LE β] →
[inst_2 : FunLike F α β] →
{motive : NonnegHomClass F α β → Sort u} →
(t : NonnegHomClass F α β) → ((apply_nonneg : ∀ (f : F) (a : α), 0 ≤ f a) → motive ⋯) → motive t |
Subgroup.coe_toSubmonoid | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G), ↑K.toSubmonoid = ↑K |
Nat.primeFactorsList_sublist_of_dvd | Mathlib.Data.Nat.Factors | ∀ {n k : ℕ}, n ∣ k → k ≠ 0 → n.primeFactorsList.Sublist k.primeFactorsList |
Lean.Elab.Do.MonadInfo.noConfusion | Lean.Elab.Do.Basic | {P : Sort u} → {t t' : Lean.Elab.Do.MonadInfo} → t = t' → Lean.Elab.Do.MonadInfo.noConfusionType P t t' |
_private.Batteries.Data.List.Lemmas.0.List.findIdxs_take._proof_1_3 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {s : ℕ},
List.findIdxs p (List.take 0 (head :: tail)) s =
List.take (List.countP p (List.take 0 (head :: tail))) (List.findIdxs p (head :: tail) s) |
Mathlib.Meta.FunProp.Mor.getAppArgs | Mathlib.Tactic.FunProp.Mor | Lean.Expr → Lean.MetaM (Array Mathlib.Meta.FunProp.Mor.Arg) |
LinearOrderedAddCommGroup.isAddCyclic_iff_nonempty_equiv_int | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {A : Type u_4} [inst : AddCommGroup A] [inst_1 : LinearOrder A] [IsOrderedAddMonoid A] [Nontrivial A],
IsAddCyclic A ↔ Nonempty (A ≃+o ℤ) |
Set.InjOn.ne_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x y : α}, Set.InjOn f s → x ∈ s → y ∈ s → (f x ≠ f y ↔ x ≠ y) |
Polynomial.instEuclideanDomain | Mathlib.Algebra.Polynomial.FieldDivision | {R : Type u} → [inst : Field R] → EuclideanDomain (Polynomial R) |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0._regBuiltin.Nat.reduceAnd.declare_56._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.1489869653._hygCtx._hyg.19 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit |
Lean.Meta.RecursorUnivLevelPos.majorType.injEq | Lean.Meta.RecursorInfo | ∀ (idx idx_1 : ℕ),
(Lean.Meta.RecursorUnivLevelPos.majorType idx = Lean.Meta.RecursorUnivLevelPos.majorType idx_1) = (idx = idx_1) |
StarAlgHom.copy._proof_3 | 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) (f' : A → B),
f' = ⇑f → f' 0 = 0 |
Lean.Elab.Term.Do.Code.reassign.inj | Lean.Elab.Do.Legacy | ∀ {xs : Array Lean.Elab.Term.Do.Var} {doElem : Lean.Syntax} {k : Lean.Elab.Term.Do.Code}
{xs_1 : Array Lean.Elab.Term.Do.Var} {doElem_1 : Lean.Syntax} {k_1 : Lean.Elab.Term.Do.Code},
Lean.Elab.Term.Do.Code.reassign xs doElem k = Lean.Elab.Term.Do.Code.reassign xs_1 doElem_1 k_1 →
xs = xs_1 ∧ doElem = doElem_1 ∧ k = k_1 |
Std.DTreeMap.Internal.Impl.ExplorationStep.lt.injEq | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {k : α → Ordering} (a : α) (a_1 : k a = Ordering.lt) (a_2 : β a)
(a_3 : List ((a : α) × β a)) (a_4 : α) (a_5 : k a_4 = Ordering.lt) (a_6 : β a_4) (a_7 : List ((a : α) × β a)),
(Std.DTreeMap.Internal.Impl.ExplorationStep.lt a a_1 a_2 a_3 =
Std.DTreeMap.Internal.Impl.ExplorationStep.lt a_4 a_5 a_6 a_7) =
(a = a_4 ∧ a_2 ≍ a_6 ∧ a_3 = a_7) |
IsOrderedAddMonoid.toIsOrderedCancelAddMonoid | Mathlib.Algebra.Order.Group.Defs | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α], IsOrderedCancelAddMonoid α |
Std.Format.nest.elim | Init.Data.Format.Basic | {motive : Std.Format → Sort u} →
(t : Std.Format) → t.ctorIdx = 4 → ((indent : ℤ) → (f : Std.Format) → motive (Std.Format.nest indent f)) → motive t |
Denumerable.ofEncodableOfInfinite._proof_1 | Mathlib.Logic.Denumerable | ∀ (α : Type u_1) [inst : Encodable α] [Infinite α], Infinite ↑(Set.range Encodable.encode) |
Std.DTreeMap.Raw.partition.eq_1 | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (f : (a : α) → β a → Bool) (t : Std.DTreeMap.Raw α β cmp),
Std.DTreeMap.Raw.partition f t =
Std.DTreeMap.Raw.foldl
(fun x a b =>
match x with
| (l, r) => if f a b = true then (l.insert a b, r) else (l, r.insert a b))
(∅, ∅) t |
InnerProductSpace.gramSchmidt_ne_zero_coe | Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι] [inst_5 : WellFoundedLT ι] {f : ι → E}
(n : ι), LinearIndependent 𝕜 (f ∘ Subtype.val) → InnerProductSpace.gramSchmidt 𝕜 f n ≠ 0 |
Affine.Simplex.circumcenter_eq_affineCombination_of_pointsWithCircumcenter | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n),
s.circumcenter =
(Finset.affineCombination ℝ Finset.univ s.pointsWithCircumcenter)
(Affine.Simplex.circumcenterWeightsWithCircumcenter n) |
cfcₙ_neg | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommRing R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalRing R] [inst_5 : ContinuousStar R] [inst_6 : TopologicalSpace A]
[inst_7 : NonUnitalRing A] [inst_8 : StarRing A] [inst_9 : Module R A] [inst_10 : IsScalarTower R A A]
[inst_11 : SMulCommClass R A A] [inst_12 : NonUnitalContinuousFunctionalCalculus R A p] (f : R → R) (a : A),
cfcₙ (fun x => -f x) a = -cfcₙ f a |
Set.notMem_of_notMem_sUnion | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {x : α} {t : Set α} {S : Set (Set α)}, x ∉ ⋃₀ S → t ∈ S → x ∉ t |
CategoryTheory.Limits.HasCountableLimits.recOn | Mathlib.CategoryTheory.Limits.Shapes.Countable | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Limits.HasCountableLimits C → Sort u} →
(t : CategoryTheory.Limits.HasCountableLimits C) →
((out :
∀ (J : Type) [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.CountableCategory J],
CategoryTheory.Limits.HasLimitsOfShape J C) →
motive ⋯) →
motive t |
USize.and_le_left | Init.Data.UInt.Bitwise | ∀ {a b : USize}, a &&& b ≤ a |
Cycle.support_formPerm | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (s : Cycle α) (h : s.Nodup),
s.Nontrivial → (s.formPerm h).support = s.toFinset |
right_iff_ite_iff | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x y : Prop}, (y ↔ if p then x else y) ↔ p → y = x |
CategoryTheory.TwistShiftData.z_zero_right | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) (a : A), t.z a 0 = 1 |
exists_smooth_forall_mem_convex_of_local_const | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type uF} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {H : Type uH} [inst_4 : TopologicalSpace H] (I : ModelWithCorners ℝ E H) {M : Type uM}
[inst_5 : TopologicalSpace M] [inst_6 : ChartedSpace H M] [FiniteDimensional ℝ E] [IsManifold I (↑⊤) M]
[SigmaCompactSpace M] [T2Space M] {t : M → Set F} {n : ℕ∞},
(∀ (x : M), Convex ℝ (t x)) → (∀ (x : M), ∃ c, ∀ᶠ (y : M) in nhds x, c ∈ t y) → ∃ g, ∀ (x : M), g x ∈ t x |
isPreconnected_iff_subset_of_fully_disjoint_closed | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α},
IsClosed s → (IsPreconnected s ↔ ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → Disjoint u v → s ⊆ u ∨ s ⊆ v) |
Submodule.rank_quotient_add_rank | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_1} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_1} R] (N : Submodule R M), Module.rank R (M ⧸ N) + Module.rank R ↥N = Module.rank R M |
FundamentalGroup.map | Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → (f : C(X, Y)) → (x : X) → FundamentalGroup X x →* FundamentalGroup Y (f x) |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.eventually_notMem_cthickening_of_infEDist_pos._simp_1_2 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
Lean.Meta.Grind.MBTC.Context.mk.noConfusion | Lean.Meta.Tactic.Grind.MBTC | {P : Sort u} →
{isInterpreted hasTheoryVar : Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{eqAssignment : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{isInterpreted' hasTheoryVar' : Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{eqAssignment' : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{ isInterpreted := isInterpreted, hasTheoryVar := hasTheoryVar, eqAssignment := eqAssignment } =
{ isInterpreted := isInterpreted', hasTheoryVar := hasTheoryVar', eqAssignment := eqAssignment' } →
(isInterpreted = isInterpreted' → hasTheoryVar = hasTheoryVar' → eqAssignment = eqAssignment' → P) → P |
Submonoid.LocalizationMap.mk'_eq_zero_iff | Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoidWithZero N]
(f : S.LocalizationMap N) (m : M) (s : ↥S), f.mk' m s = 0 ↔ ∃ s, ↑s * m = 0 |
_private.Mathlib.RingTheory.Ideal.Operations.0.Submodule.smul_le_span._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] (s : Set R), Ideal.span s = s • ⊤ |
Encodable.chooseX.match_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {p : α → Prop} (motive : (∃ x, p x) → Prop) (h : ∃ x, p x), (∀ (w : α) (pw : p w), motive ⋯) → motive h |
_private.Mathlib.Combinatorics.SimpleGraph.Prod.0.SimpleGraph.reachable_boxProd.match_1_3 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {H : SimpleGraph β} {x y : α × β}
(motive : G.Reachable x.1 y.1 ∧ H.Reachable x.2 y.2 → Prop) (h : G.Reachable x.1 y.1 ∧ H.Reachable x.2 y.2),
(∀ (w₁ : G.Walk x.1 y.1) (w₂ : H.Walk x.2 y.2), motive ⋯) → motive h |
PrimeSpectrum.BasicConstructibleSetData.recOn | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} →
{motive : PrimeSpectrum.BasicConstructibleSetData R → Sort u} →
(t : PrimeSpectrum.BasicConstructibleSetData R) →
((f : R) → (n : ℕ) → (g : Fin n → R) → motive { f := f, n := n, g := g }) → motive t |
PolynomialLaw.toFun'_eq_of_inclusion | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {S : Type v} [inst_5 : CommSemiring S] [inst_6 : Algebra R S]
(f : M →ₚₗ[R] N) {A : Type u} [inst_7 : CommSemiring A] [inst_8 : Algebra R A] {φ : A →ₐ[R] S}
(p : TensorProduct R A M) {B : Type u} [inst_9 : CommSemiring B] [inst_10 : Algebra R B] (q : TensorProduct R B M)
{ψ : B →ₐ[R] S} (h : φ.range ≤ ψ.range),
(LinearMap.rTensor M ((Subalgebra.inclusion h).comp φ.rangeRestrict).toLinearMap) p =
(LinearMap.rTensor M ψ.rangeRestrict.toLinearMap) q →
(LinearMap.rTensor N φ.toLinearMap) (f.toFun' A p) = (LinearMap.rTensor N ψ.toLinearMap) (f.toFun' B q) |
List.SublistForall₂.recOn | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
{motive : (a : List α) → (a_1 : List β) → List.SublistForall₂ R a a_1 → Prop} {a : List α} {a_1 : List β}
(t : List.SublistForall₂ R a a_1),
(∀ {l : List β}, motive [] l ⋯) →
(∀ {a₁ : α} {a₂ : β} {l₁ : List α} {l₂ : List β} (a : R a₁ a₂) (a_2 : List.SublistForall₂ R l₁ l₂),
motive l₁ l₂ a_2 → motive (a₁ :: l₁) (a₂ :: l₂) ⋯) →
(∀ {a : β} {l₁ : List α} {l₂ : List β} (a_2 : List.SublistForall₂ R l₁ l₂),
motive l₁ l₂ a_2 → motive l₁ (a :: l₂) ⋯) →
motive a a_1 t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.