From 5ef87c1d66050b29e6241430c1b08710910decf6 Mon Sep 17 00:00:00 2001
From: "downstream-lean4[bot]" <downstream-lean4[bot]@users.noreply.github.com>
Date: Fri, 24 Jul 2026 14:33:28 +0000
Subject: [PATCH 1/7] downstream: follow upstream PR

---
 lean-toolchain | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lean-toolchain b/lean-toolchain
index 728ce7a44..0bcee2854 100644
--- a/lean-toolchain
+++ b/lean-toolchain
@@ -1 +1 @@
-leanprover/lean4:nightly-2026-07-22
+leanprover/lean4-pr-releases:pr-release-14536-9dc2a3b

From ec5cefddfbcfe689be46656953ad847764548cbe Mon Sep 17 00:00:00 2001
From: Julia Markus Himmel <2065352+TwoFX@users.noreply.github.com>
Date: Tue, 26 May 2026 16:48:09 +0000
Subject: [PATCH 2/7] Adaptations for `respectTransparency.instances` and
 `respectTransparency.outParams`

---
 .../Mathlib/Algebra/AddConstMap/Basic.lean    |   6 +
 .../Mathlib/Algebra/Algebra/NonUnitalHom.lean |   4 +
 .../Algebra/Category/BialgCat/Basic.lean      |   1 +
 .../Algebra/Category/CommAlgCat/Monoidal.lean |   1 +
 .../Category/ContinuousCohomology/Basic.lean  | 220 ++++++++++++++++++
 .../Algebra/Category/FGModuleCat/Basic.lean   |   3 +
 .../Algebra/Category/Grp/Biproducts.lean      |   1 +
 .../Algebra/Category/Grp/FiniteGrp.lean       |   3 +
 .../Category/ModuleCat/Adjunctions.lean       |   1 +
 .../Category/ModuleCat/Biproducts.lean        |   1 +
 .../Category/ModuleCat/ChangeOfRings.lean     |   3 +
 .../ModuleCat/Differentials/Presheaf.lean     |   2 +
 .../Algebra/Category/ModuleCat/Presheaf.lean  |   5 +
 .../ModuleCat/Presheaf/ChangeOfRings.lean     |   2 +
 .../ModuleCat/Presheaf/ColimitFunctor.lean    |   1 +
 .../Category/ModuleCat/Presheaf/Monoidal.lean |   1 +
 .../ModuleCat/Presheaf/Pushforward.lean       |   2 +
 .../ModuleCat/ProjectiveDimension.lean        |   3 +
 .../Category/ModuleCat/Topology/Basic.lean    |   2 +
 .../Algebra/Category/Ring/Constructions.lean  |   1 +
 .../Category/Ring/EqualizerPushout.lean       |   2 +
 mathlib4/Mathlib/Algebra/Lie/Submodule.lean   |   7 +
 .../Mathlib/Algebra/Module/Injective.lean     |   1 +
 .../Mathlib/Algebra/Order/Hom/Monoid.lean     |  13 ++
 .../Mathlib/Algebra/Star/TensorProduct.lean   |   4 +
 .../AlgebraicGeometry/AffineScheme.lean       |   1 +
 .../AffineTransitionLimit.lean                |   1 +
 .../Mathlib/AlgebraicGeometry/Artinian.lean   |   1 +
 .../Mathlib/AlgebraicGeometry/Cover/Open.lean |   2 +
 .../Mathlib/AlgebraicGeometry/Cover/Over.lean |   4 +
 .../GammaSpecAdjunction.lean                  |   2 +
 .../AlgebraicGeometry/Group/Abelian.lean      |   1 +
 .../AlgebraicGeometry/IdealSheaf/Basic.lean   |   1 +
 .../AlgebraicGeometry/Morphisms/Basic.lean    |   1 +
 .../AlgebraicGeometry/Morphisms/Finite.lean   |   4 +
 .../Morphisms/FiniteType.lean                 |   1 +
 .../Morphisms/RingHomProperties.lean          |   1 +
 .../Morphisms/UniversallyClosed.lean          |   2 +
 .../Mathlib/AlgebraicGeometry/Noetherian.lean |   1 +
 .../AlgebraicGeometry/Normalization.lean      |   1 +
 .../AlgebraicGeometry/OpenImmersion.lean      |   3 +
 .../ProjectiveSpectrum/Scheme.lean            |   1 +
 .../ProjectiveSpectrum/StructureSheaf.lean    |   1 +
 .../Mathlib/AlgebraicGeometry/Pullbacks.lean  |   1 +
 .../Mathlib/AlgebraicGeometry/Restrict.lean   |   8 +
 .../Mathlib/AlgebraicGeometry/Scheme.lean     |   1 +
 mathlib4/Mathlib/AlgebraicGeometry/Spec.lean  |   3 +
 .../AlgebraicGeometry/StructureSheaf.lean     |   6 +
 .../SimplicialSet/Degenerate.lean             |   2 +
 .../SimplicialSet/TopAdj.lean                 |   2 +
 .../FiniteAbelian/PontryaginDuality.lean      |   2 +
 .../Analysis/InnerProductSpace/Adjoint.lean   |   4 +
 .../InnerProductSpace/LinearPMap.lean         |   2 +
 .../Matrix/HermitianFunctionalCalculus.lean   |   3 +
 .../Normed/Unbundled/SpectralNorm.lean        |   6 +-
 .../CategoryTheory/Action/Continuous.lean     |   1 +
 .../Mathlib/CategoryTheory/Category/TwoP.lean |   1 +
 .../CategoryTheory/EssentiallySmall.lean      |   3 +-
 .../Mathlib/CategoryTheory/Extensive.lean     |   1 +
 .../Mathlib/CategoryTheory/FintypeCat.lean    |  11 +-
 .../Functor/TypeValuedFlat.lean               |   3 +
 .../CategoryTheory/Galois/Equivalence.lean    |   1 +
 .../CategoryTheory/Limits/Shapes/Images.lean  |   7 +-
 .../Limits/Types/Coproducts.lean              |   1 +
 .../Localization/StructuredArrow.lean         |   2 +
 .../Monoidal/Cartesian/ShrinkYoneda.lean      |   2 +
 .../CategoryTheory/Presentable/Type.lean      |   1 +
 .../CategoryTheory/Shift/Adjunction.lean      |   2 +-
 mathlib4/Mathlib/CategoryTheory/Yoneda.lean   |   1 +
 .../Enumerative/IncidenceAlgebra.lean         |   2 +-
 .../Quiver/ConnectedComponent.lean            |   3 +
 .../Mathlib/Computability/RecursiveIn.lean    |   2 +-
 .../Mathlib/Condensed/Light/Functors.lean     |   1 +
 .../Mathlib/Condensed/Light/Sequence.lean     |   3 +
 mathlib4/Mathlib/Data/DFinsupp/Lex.lean       |  13 ++
 .../Mathlib/Data/DFinsupp/WellFounded.lean    |   3 +
 mathlib4/Mathlib/Data/Finset/Defs.lean        |   2 +
 mathlib4/Mathlib/Data/Finset/Image.lean       |   1 +
 mathlib4/Mathlib/Data/Matrix/Mul.lean         |   2 +-
 .../Mathlib/Data/Nat/Cast/SetInterval.lean    |   2 +-
 mathlib4/Mathlib/Data/PFun.lean               |   3 +
 mathlib4/Mathlib/Data/Vector3.lean            |   1 +
 .../FieldTheory/SeparablyGenerated.lean       |   1 +
 .../Geometry/Manifold/IsManifold/Basic.lean   |   2 +
 .../Geometry/Manifold/MFDeriv/Atlas.lean      |   2 +
 .../Geometry/Manifold/MFDeriv/Basic.lean      |   5 +
 .../Geometry/Manifold/MFDeriv/Defs.lean       |   2 +
 .../Manifold/MFDeriv/SpecificFunctions.lean   |   4 +
 .../Manifold/VectorBundle/Tangent.lean        |   1 +
 .../RingedSpace/LocallyRingedSpace.lean       |   4 +
 .../LocallyRingedSpace/ResidueField.lean      |   7 +
 .../Mathlib/GroupTheory/PresentedGroup.lean   |   3 +-
 .../GroupTheory/SpecificGroups/ZGroup.lean    |   5 +
 .../Constructions/BorelSpace/Order.lean       |   2 +
 .../NumberField/Units/DirichletTheorem.lean   |   2 +
 .../Mathlib/NumberTheory/Padics/WithVal.lean  |   1 +
 .../Mathlib/Order/Category/FinBoolAlg.lean    |   3 +
 .../Mathlib/Order/Category/FinPartOrd.lean    |   3 +
 .../Order/Category/NonemptyFinLinOrd.lean     |   3 +
 .../Mathlib/Order/CompleteLattice/PiLex.lean  |   7 +
 .../Mathlib/Order/Interval/Finset/Gaps.lean   |   3 +
 mathlib4/Mathlib/Order/Interval/Set/Defs.lean |   2 +-
 mathlib4/Mathlib/Order/KrullDimension.lean    |   2 +-
 mathlib4/Mathlib/Order/PiLex.lean             |   9 +
 mathlib4/Mathlib/Order/RelIso/Set.lean        |   3 +
 .../Distributions/Gaussian/CharFun.lean       |   4 +
 .../Probability/Moments/CovarianceBilin.lean  |   9 +
 .../Mathlib/RepresentationTheory/Basic.lean   |   1 +
 .../GroupCohomology/LowDegree.lean            |  16 ++
 .../GroupHomology/Functoriality.lean          |   1 +
 .../Homological/GroupHomology/LowDegree.lean  |   9 +
 .../Subrepresentation.lean                    |  18 +-
 .../RingTheory/Extension/Cotangent/Basis.lean |   5 +
 .../Extension/Cotangent/LocalizationAway.lean |   1 +
 .../FractionalIdeal/Operations.lean           |   5 +
 .../Mathlib/RingTheory/Ideal/Nonunits.lean    |   2 +-
 .../RingTheory/Ideal/Norm/AbsNorm.lean        |   2 +
 .../RingTheory/IdealFilter/Topology.lean      |   4 +
 .../RingTheory/Kaehler/JacobiZariski.lean     |   1 +
 .../RingTheory/LocalProperties/Injective.lean |   2 +
 .../LocalProperties/IntegrallyClosed.lean     |   2 +
 .../RingTheory/Localization/FractionRing.lean |   3 +
 .../MvPowerSeries/LinearTopology.lean         |   1 +
 .../RingTheory/Regular/RegularSequence.lean   |   1 +
 .../Smooth/StandardSmoothCotangent.lean       |   4 +
 .../RingTheory/Spectrum/Prime/FreeLocus.lean  |   2 +
 .../RingTheory/Spectrum/Prime/Polynomial.lean |   1 +
 .../RingTheory/Valuation/LocalSubring.lean    |   2 +
 .../Mathlib/RingTheory/Valuation/RankOne.lean |   3 +
 .../RingTheory/WittVector/Isocrystal.lean     |   5 +
 mathlib4/Mathlib/SetTheory/Ordinal/Basic.lean |   2 +-
 mathlib4/Mathlib/SetTheory/ZFC/Class.lean     |   4 +-
 .../ComputeAsymptotics/Multiseries/Defs.lean  |   1 +
 .../Mathlib/Tactic/Simproc/ExistsAndEq.lean   |   2 +-
 .../Algebra/Category/ProfiniteGrp/Limits.lean |   4 +
 .../Algebra/Module/UniformConvergence.lean    |   5 +
 .../Topology/Algebra/StarSubalgebra.lean      |   1 +
 .../Topology/Category/CompHausLike/Basic.lean |   3 +
 .../Category/CompHausLike/Cartesian.lean      |   3 +
 .../Topology/Category/CompactlyGenerated.lean |   3 +
 .../Mathlib/Topology/Category/FinTopCat.lean  |   3 +
 .../Category/LightProfinite/Basic.lean        |   3 +
 .../Topology/Category/Profinite/Product.lean  |   1 +
 .../Mathlib/Topology/Category/Sequential.lean |   3 +
 .../Category/TopCat/Limits/Products.lean      |   5 +
 .../Topology/Category/TopCat/ULift.lean       |   1 +
 .../Topology/Category/UniformSpace.lean       |   1 +
 .../Mathlib/Topology/ContinuousMap/Basic.lean |   2 +-
 .../EMetricSpace/BoundedVariation.lean        |   2 +
 .../Topology/EMetricSpace/PairReduction.lean  |   1 +
 .../Topology/Homotopy/TopCat/Path.lean        |   3 +
 .../Homotopy/TopCat/ZerothHomotopy.lean       |   1 +
 mathlib4/Mathlib/Topology/Instances/Rat.lean  |   3 +
 .../Topology/Order/Category/AlexDisc.lean     |   3 +
 mathlib4/Mathlib/Topology/Order/IsLUB.lean    |   2 +
 .../Topology/Order/MonotoneConvergence.lean   |   6 +
 156 files changed, 655 insertions(+), 27 deletions(-)
 create mode 100644 mathlib4/Mathlib/Algebra/Category/ContinuousCohomology/Basic.lean

diff --git a/mathlib4/Mathlib/Algebra/AddConstMap/Basic.lean b/mathlib4/Mathlib/Algebra/AddConstMap/Basic.lean
index 4e52663a0..234b7d5b2 100644
--- a/mathlib4/Mathlib/Algebra/AddConstMap/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/AddConstMap/Basic.lean
@@ -289,6 +289,9 @@ theorem monotone_iff_Icc [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G]
   ⟨(Monotone.monotoneOn · _), fun hf ↦ monotone_iff_forall_lt.2 <|
     AddConstMapClass.rel_map_of_Icc ha fun _x hx _y hy hxy ↦ hf hx hy hxy.le⟩
 
+-- Defeq abuse: there is no `AddConstMapClass _ _ Hᵒᵈ _ _`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem antitone_iff_Icc [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Archimedean G]
     [AddCommGroup H] [PartialOrder H] [IsOrderedAddMonoid H]
     [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
@@ -301,6 +304,9 @@ theorem strictMono_iff_Icc [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid
     StrictMono f ↔ StrictMonoOn f (Icc l (l + a)) :=
   ⟨(StrictMono.strictMonoOn · _), AddConstMapClass.rel_map_of_Icc ha⟩
 
+-- Defeq abuse: there is no `AddConstMapClass _ _ Hᵒᵈ _ _`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem strictAnti_iff_Icc [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Archimedean G]
     [AddCommGroup H] [PartialOrder H] [IsOrderedAddMonoid H]
     [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
diff --git a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
index 5ddd9c839..c5e4ecadc 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
@@ -100,6 +100,10 @@ variable [Semiring R] [Semiring S] {φ : R →+* S}
   {A B : Type*} [NonUnitalNonAssocSemiring A] [Module R A]
   [NonUnitalNonAssocSemiring B] [Module S B]
 
+-- This needs `DFunLike.coe φ = DFunLike.coe (φ : R →* S)` to hold at `instances` transparency,
+-- which seems reasonable but isn't true at the moment.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 -- see Note [lower instance priority]
 instance (priority := 100) {F R S A B : Type*}
     {_ : Semiring R} {_ : Semiring S} {φ : R →+* S}
diff --git a/mathlib4/Mathlib/Algebra/Category/BialgCat/Basic.lean b/mathlib4/Mathlib/Algebra/Category/BialgCat/Basic.lean
index f23b36200..94e56a8f9 100644
--- a/mathlib4/Mathlib/Algebra/Category/BialgCat/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Category/BialgCat/Basic.lean
@@ -147,6 +147,7 @@ variable {X Y Z : Type v}
 variable [Ring X] [Ring Y] [Ring Z]
 variable [Bialgebra R X] [Bialgebra R Y] [Bialgebra R Z]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Build an isomorphism in the category `BialgCat R` from a
 `BialgEquiv`. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Algebra/Category/CommAlgCat/Monoidal.lean b/mathlib4/Mathlib/Algebra/Category/CommAlgCat/Monoidal.lean
index 008f859d5..937c48161 100644
--- a/mathlib4/Mathlib/Algebra/Category/CommAlgCat/Monoidal.lean
+++ b/mathlib4/Mathlib/Algebra/Category/CommAlgCat/Monoidal.lean
@@ -95,6 +95,7 @@ variable (A B) in
 variable (A B) in
 @[simp] lemma braiding_inv_hom : (β_ A B).inv.hom = (comm R B A).toAlgHom := rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
 attribute [local ext] Quiver.Hom.unop_inj in
 instance : CartesianMonoidalCategory (CommAlgCat.{u} R)ᵒᵖ where
   isTerminalTensorUnit := terminalOpOfInitial isInitialSelf
diff --git a/mathlib4/Mathlib/Algebra/Category/ContinuousCohomology/Basic.lean b/mathlib4/Mathlib/Algebra/Category/ContinuousCohomology/Basic.lean
new file mode 100644
index 000000000..fcd3c6a73
--- /dev/null
+++ b/mathlib4/Mathlib/Algebra/Category/ContinuousCohomology/Basic.lean
@@ -0,0 +1,220 @@
+/-
+Copyright (c) 2025 Richard Hill. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Richard Hill, Andrew Yang
+-/
+module
+
+public import Mathlib.Algebra.Category.ModuleCat.Topology.Homology
+public import Mathlib.Algebra.Homology.Embedding.Restriction
+public import Mathlib.Algebra.Homology.Functor
+public import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
+public import Mathlib.CategoryTheory.Action.Limits
+public import Mathlib.Topology.ContinuousMap.Algebra
+
+/-!
+
+# Continuous cohomology
+
+We define continuous cohomology as the homology of homogeneous cochains.
+
+## Implementation details
+
+We define homogeneous cochains as `g`-invariant continuous function in `C(G, C(G,...,C(G, M)))`
+instead of the usual `C(Gⁿ, M)` to allow more general topological groups other than locally compact
+ones. For this to work, we also work in `Action (TopModuleCat R) G`, where the `G` action on `M`
+is only continuous on `M`, and not necessarily continuous in both variables, because the `G` action
+on `C(G, M)` might not be continuous on both variables even if it is on `M`.
+
+For the differential map, instead of a finite sum we use the inductive definition
+`d₋₁ : M → C(G, M) := const : m ↦ g ↦ m` and
+`dₙ₊₁ : C(G, _) → C(G, C(G, _)) := const - C(G, dₙ) : f ↦ g ↦ f - dₙ (f (g))`
+See `ContinuousCohomology.MultiInd.d`.
+
+## Main definition
+- `ContinuousCohomology.homogeneousCochains`:
+  The functor taking an `R`-linear `G`-representation to the complex of homogeneous cochains.
+- `continuousCohomology`:
+  The functor taking an `R`-linear `G`-representation to its `n`-th continuous cohomology.
+
+## TODO
+- Show that it coincides with `groupCohomology` for discrete groups.
+- Give the usual description of cochains in terms of `n`-ary functions for locally compact groups.
+- Show that short exact sequences induce long exact sequences in certain scenarios.
+-/
+
+set_option backward.defeqAttrib.useBackward true
+
+@[expose] public section
+
+open CategoryTheory Functor ContinuousMap
+
+variable (R G : Type*) [CommRing R] [Group G] [TopologicalSpace R]
+
+namespace ContinuousCohomology
+
+variable [TopologicalSpace G] [IsTopologicalGroup G]
+
+variable {R G} in
+/-- The `G` representation `C(G, rep)` given a representation `rep`.
+The `G` action is defined by `g • f := x ↦ g • f (g⁻¹ * x)`. -/
+abbrev Iobj (rep : Action (TopModuleCat R) G) : Action (TopModuleCat R) G where
+  V := .of R C(G, rep.V)
+  ρ :=
+  { toFun g := TopModuleCat.ofHom
+      { toFun f := .comp (rep.ρ g).hom (f.comp (Homeomorph.mulLeft g⁻¹))
+        map_add' _ _ := by ext; simp
+        map_smul' _ _ := by ext; simp
+        cont := (continuous_postcomp _).comp (continuous_precomp _) }
+    map_one' := ConcreteCategory.ext (by ext; simp)
+    map_mul' _ _ := ConcreteCategory.ext (by ext; simp [mul_assoc]) }
+
+lemma Iobj_ρ_apply (rep : Action (TopModuleCat R) G) (g f x) :
+    ((Iobj rep).ρ g).hom f x = (rep.ρ g).hom (f (g⁻¹ * x)) := rfl
+
+/-- The functor taking a representation `rep` to the representation `C(G, rep)`. -/
+@[simps]
+def I : Action (TopModuleCat R) G ⥤ Action (TopModuleCat R) G where
+  obj := Iobj
+  map {M N} φ :=
+  { hom := TopModuleCat.ofHom (ContinuousLinearMap.compLeftContinuous _ _ φ.hom.hom)
+    comm g := by
+      ext f g'
+      change (M.ρ g ≫ φ.hom).hom (f (g⁻¹ * g')) = (φ.hom ≫ N.ρ g).hom (f (g⁻¹ * g'))
+      rw [φ.comm] }
+  map_id _ := rfl
+  map_comp _ _ := rfl
+
+instance : (I R G).Additive where
+instance : (I R G).Linear R where
+
+/-- The constant function `rep ⟶ C(G, rep)` as a natural transformation. -/
+@[simps]
+def const : 𝟭 _ ⟶ I R G where
+  app _ := { hom := TopModuleCat.ofHom (.const _ _), comm _ := rfl }
+  naturality _ _ _ := rfl
+
+namespace MultiInd
+
+set_option linter.style.whitespace false in -- manual alignment is not recognised
+/-- The n-th functor taking `M` to `C(G, C(G,...,C(G, M)))` (with n `G`s).
+These functors form a complex, see `MultiInd.complex`. -/
+def functor : ℕ → Action (TopModuleCat R) G ⥤ Action (TopModuleCat R) G
+  | 0     => 𝟭 _
+  | n + 1 => functor n ⋙ I R G
+
+set_option linter.style.whitespace false in -- manual alignment is not recognised
+set_option backward.isDefEq.respectTransparency.instances false in
+/-- The differential map in `MultiInd.complex`. -/
+def d : ∀ n : ℕ, functor R G n ⟶ functor R G (n + 1)
+  | 0     => const R G
+  | n + 1 => whiskerLeft (functor R G (n + 1)) (const R G) - (by exact whiskerRight (d n) (I R G))
+
+lemma d_zero : d R G 0 = const R G := rfl
+
+set_option backward.isDefEq.respectTransparency.instances false in
+lemma d_succ (n : ℕ) :
+    d R G (n + 1) = whiskerLeft (functor R G (n + 1)) (const R G) -
+      (by exact whiskerRight (d R G n) (I R G)) := rfl
+
+set_option backward.isDefEq.respectTransparency false in
+@[reassoc (attr := simp)]
+lemma d_comp_d (n : ℕ) :
+    d R G n ≫ d R G (n + 1) = 0 := by
+  induction n with
+  | zero =>
+    rw [d_succ, Preadditive.comp_sub, sub_eq_zero]
+    rfl
+  | succ n ih =>
+    rw [d_succ R G (n + 1), Preadditive.comp_sub]
+    nth_rw 2 [d_succ]
+    rw [Preadditive.sub_comp, ← whiskerRight_comp, ih,
+      Functor.whiskerRight_zero, sub_zero, sub_eq_zero]
+    rfl
+
+/-- The complex of functors whose behaviour pointwise takes an `R`-linear `G`-representation `M`
+to the complex `M → C(G, M) → ⋯ → C(G, C(G,...,C(G, M))) → ⋯`
+The `G`-invariant submodules of it is the homogeneous cochains (shifted by one). -/
+def complex : CochainComplex (Action (TopModuleCat R) G ⥤ Action (TopModuleCat R) G) ℕ :=
+  CochainComplex.of (functor R G) (d R G) (d_comp_d R G)
+
+end MultiInd
+
+/-- The functor taking an `R`-linear `G`-representation to its `G`-invariant submodule. -/
+def invariants : Action (TopModuleCat R) G ⥤ TopModuleCat R where
+  obj M := .of R
+    { carrier := { x | ∀ g : G, (M.ρ g).hom x = x }
+      add_mem' hx hy g := by simp [hx g, hy g]
+      zero_mem' := by simp
+      smul_mem' r x hx g := by simp [hx g] : Submodule R M.V }
+  map f := TopModuleCat.ofHom
+    { toLinearMap := f.hom.hom.restrict fun x hx g ↦
+        congr($(f.comm g) x).symm.trans congr(f.hom.hom $(hx g))
+      cont := continuous_induced_rng.mpr (f.hom.hom.2.comp continuous_subtype_val) }
+
+instance : (invariants R G).Linear R where
+instance : (invariants R G).Additive where
+
+/-- `homogeneousCochains R G` is the functor taking
+an `R`-linear `G`-representation to the complex of homogeneous cochains. -/
+def homogeneousCochains : Action (TopModuleCat R) G ⥤ CochainComplex (TopModuleCat R) ℕ :=
+  (MultiInd.complex R G).asFunctor ⋙ (invariants R G).mapHomologicalComplex _ ⋙
+    (ComplexShape.embeddingUp'Add 1 1).restrictionFunctor _
+
+/-- `continuousCohomology R G n` is the functor taking
+an `R`-linear `G`-representation to its `n`-th continuous cohomology. -/
+noncomputable
+def _root_.continuousCohomology (n : ℕ) : Action (TopModuleCat R) G ⥤ TopModuleCat R :=
+  homogeneousCochains R G ⋙ HomologicalComplex.homologyFunctor _ _ n
+
+set_option backward.isDefEq.respectTransparency false in
+/-- The `0`-homogeneous cochains are isomorphic to `Xᴳ`. -/
+def kerHomogeneousCochainsZeroEquiv
+    (X : Action (TopModuleCat R) G) (n : ℕ) (hn : n = 1) :
+    (((homogeneousCochains R G).obj X).d 0 n).hom.ker ≃L[R] (invariants R G).obj X where
+  toFun x :=
+  { val := DFunLike.coe (F := C(G, _)) x.1.1 1
+    property g := by
+      subst hn
+      obtain ⟨⟨x : C(G, _), hx⟩, hx'⟩ := x
+      have : (X.ρ g).hom (x (g⁻¹ * 1)) = x 1 := congr(DFunLike.coe (F := C(G, _)) $(hx g) 1)
+      have hx' : x (g⁻¹ * 1) - x 1 = 0 :=
+        congr(DFunLike.coe (F := C(G, _)) (DFunLike.coe (F := C(G, _)) ($hx').1 1) (g⁻¹ * 1))
+      rw [sub_eq_zero] at hx'
+      exact congr((X.ρ g).hom $hx').symm.trans this }
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+  invFun x := by
+    refine ⟨⟨ContinuousLinearMap.const R _ x.1, fun g ↦ ContinuousMap.ext fun a ↦
+      by subst hn; exact x.2 g⟩, ?_⟩
+    subst hn
+    exact Subtype.ext (ContinuousMap.ext fun a ↦
+      ContinuousMap.ext fun b ↦ show x.1 - x.1 = (0 : X.V) by simp)
+  left_inv x := by
+    subst hn
+    obtain ⟨⟨x : C(G, _), hx⟩, hx'⟩ := x
+    refine Subtype.ext (Subtype.ext <| ContinuousMap.ext fun a ↦ ?_)
+    have hx' : x 1 - x a = 0 :=
+      congr(DFunLike.coe (F := C(G, _)) (DFunLike.coe (F := C(G, _)) ($hx').1 a) 1)
+    rwa [sub_eq_zero] at hx'
+  right_inv _ := rfl
+  continuous_toFun := continuous_induced_rng.mpr ((continuous_eval_const (F := C(G, _)) 1).comp
+      (continuous_subtype_val.comp continuous_subtype_val))
+  continuous_invFun := continuous_induced_rng.mpr
+    (continuous_induced_rng.mpr ((ContinuousLinearMap.const R G).cont.comp continuous_subtype_val))
+
+set_option backward.isDefEq.respectTransparency false in
+open ShortComplex HomologyData in
+/-- `H⁰_cont(G, X) ≅ Xᴳ`. -/
+noncomputable
+def continuousCohomologyZeroIso : (continuousCohomology R G 0) ≅ invariants R G :=
+  NatIso.ofComponents (fun X ↦ (ofIsLimitKernelFork _ (by simp) _
+    (TopModuleCat.isLimitKer _)).left.homologyIso ≪≫ TopModuleCat.ofIso
+      (kerHomogeneousCochainsZeroEquiv R G X _ (by simp))) fun {X Y} f ↦ by
+  dsimp [continuousCohomology, HomologicalComplex.homologyMap]
+  rw [Category.assoc, ← Iso.inv_comp_eq]
+  rw [LeftHomologyData.leftHomologyIso_inv_naturality_assoc, Iso.inv_hom_id_assoc,
+    ← cancel_epi (LeftHomologyData.π _), leftHomologyπ_naturality'_assoc]
+  rfl
+
+end ContinuousCohomology
diff --git a/mathlib4/Mathlib/Algebra/Category/FGModuleCat/Basic.lean b/mathlib4/Mathlib/Algebra/Category/FGModuleCat/Basic.lean
index 1de129acf..47f679079 100644
--- a/mathlib4/Mathlib/Algebra/Category/FGModuleCat/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@@ -110,6 +110,8 @@ variable {R} in
 instance (V : FGModuleCat.{v} R) : Module.Finite R V :=
   V.property
 
+-- Needs to unfold the `forget₂` at `instances` transparency.
+set_option backward.isDefEq.respectTransparency.instances false in
 instance : (forget₂ (FGModuleCat.{v} R) (ModuleCat.{v} R)).Full where
   map_surjective f := ⟨ofHom f.hom, rfl⟩
 
@@ -227,6 +229,7 @@ theorem FGModuleCatEvaluation_apply (f : FGModuleCatDual K V) (x : V) :
   contractLeft_apply f x
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `@[simp]`-normal form of `FGModuleCatEvaluation_apply`, where the carriers have been unfolded.
 -/
 @[simp]
diff --git a/mathlib4/Mathlib/Algebra/Category/Grp/Biproducts.lean b/mathlib4/Mathlib/Algebra/Category/Grp/Biproducts.lean
index c51250a62..0b63e6a5c 100644
--- a/mathlib4/Mathlib/Algebra/Category/Grp/Biproducts.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Grp/Biproducts.lean
@@ -79,6 +79,7 @@ namespace HasLimit
 variable {J : Type w} (f : J → AddCommGrpCat.{max w u})
 
 set_option backward.defeqAttrib.useBackward true in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The map from an arbitrary cone over an indexed family of abelian groups
 to the Cartesian product of those groups.
 -/
diff --git a/mathlib4/Mathlib/Algebra/Category/Grp/FiniteGrp.lean b/mathlib4/Mathlib/Algebra/Category/Grp/FiniteGrp.lean
index 9773380df..5e50ec220 100644
--- a/mathlib4/Mathlib/Algebra/Category/Grp/FiniteGrp.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Grp/FiniteGrp.lean
@@ -48,6 +48,9 @@ instance : CoeSort FiniteGrp.{u} (Type u) where
 instance : Category FiniteGrp :=
   inferInstanceAs <| Category (InducedCategory _ FiniteGrp.toGrp)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 instance : ConcreteCategory FiniteGrp (· →* ·) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toGrp) _
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
index 97710a7ea..a183e359c 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
@@ -373,6 +373,7 @@ def embeddingLiftIso (F : C ⥤ D) : embedding R C ⋙ lift R F ≅ F :=
   NatIso.ofComponents fun _ => Iso.refl _
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Two `R`-linear functors out of the `R`-linear completion are isomorphic iff their
 compositions with the embedding functor are isomorphic.
 -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Biproducts.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Biproducts.lean
index a28562386..660f2f48b 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Biproducts.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Biproducts.lean
@@ -85,6 +85,7 @@ namespace HasLimit
 variable {J : Type w} (f : J → ModuleCat.{max w v} R)
 
 set_option backward.defeqAttrib.useBackward true in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The map from an arbitrary cone over an indexed family of abelian groups
 to the Cartesian product of those groups.
 -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
index ecd029ee9..ff1c2858a 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
@@ -98,6 +98,8 @@ lemma forget₂_map_restrictScalars {R : Type u₁} {S : Type u₂} [Ring R] [Ri
     (forget₂ _ Ab).map ((ModuleCat.restrictScalars f).map g) = (forget₂ _ Ab).map g :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) :
     (restrictScalars.{v} f).Faithful where
   map_injective h := by
@@ -757,6 +759,7 @@ def HomEquiv.fromExtendScalars {X : ModuleCat R} {Y : ModuleCat S}
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given `R`-module X and `S`-module Y, `S`-linear maps `(extendScalars f).obj X ⟶ Y`
 bijectively correspond to `R`-linear maps `X ⟶ (restrictScalars f).obj Y`.
 -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
index 63b60eb1d..d7e431bdf 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
@@ -201,6 +201,8 @@ noncomputable def relativeDifferentials' :
 
 attribute [simp] relativeDifferentials'_obj
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma relativeDifferentials'_map_d {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : R.obj X) :
     DFunLike.coe (α := CommRingCat.KaehlerDifferential (φ'.app X))
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
index fa7349e10..df74bc193 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
@@ -149,6 +149,8 @@ noncomputable def presheaf : Cᵒᵖ ⥤ Ab where
 lemma presheaf_obj_coe (X : Cᵒᵖ) :
     (M.presheaf.obj X : Type _) = M.obj X := rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma presheaf_map_apply_coe {X Y : Cᵒᵖ} (f : X ⟶ Y) (x : M.obj X) :
     DFunLike.coe (α := M.obj X) (β := fun _ ↦ M.obj Y) (M.presheaf.map f).hom x = M.map f x := rfl
@@ -176,6 +178,8 @@ noncomputable def toPresheaf : PresheafOfModules.{v} R ⥤ Cᵒᵖ ⥤ Ab where
 lemma toPresheaf_obj_coe (X : Cᵒᵖ) :
     (((toPresheaf R).obj M).obj X : Type _) = M.obj X := rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma toPresheaf_map_app_apply (f : M₁ ⟶ M₂) (X : Cᵒᵖ) (x : M₁.obj X) :
     DFunLike.coe (α := M₁.obj X) (β := fun _ ↦ M₂.obj X)
@@ -214,6 +218,7 @@ lemma ofPresheaf_presheaf : (ofPresheaf M map_smul).presheaf = M := rfl
 end
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The morphism of presheaves of modules `M₁ ⟶ M₂` given by a morphism
 of abelian presheaves `M₁.presheaf ⟶ M₂.presheaf`
 which satisfy a suitable linearity condition. -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean
index 424ada441..8758f1cf6 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean
@@ -27,6 +27,8 @@ namespace PresheafOfModules
 
 variable {C : Type u'} [Category.{v'} C] {R R' : Cᵒᵖ ⥤ RingCat.{u}}
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The restriction of scalars of presheaves of modules, on objects. -/
 @[simps]
 noncomputable def restrictScalarsObj (M' : PresheafOfModules.{v} R') (α : R ⟶ R') :
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
index 226ca2785..fb2c51cee 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
@@ -290,6 +290,7 @@ variable {M' : PresheafOfModules.{w} R} {cM' : Cocone M'.presheaf}
 
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The linear map between the colimit modules induced by a morphism of modules. -/
 noncomputable def map (f : M ⟶ M') :
     ModuleColimit hcR hcM →ₗ[cR.pt] ModuleColimit hcR hcM' where
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
index e7f98beb3..1fe00e832 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
@@ -76,6 +76,7 @@ noncomputable def tensorObj : PresheafOfModules (R ⋙ forget₂ _ _) where
 variable {M₁ M₂ M₃ M₄}
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma tensorObj_map_tmul {X Y : Cᵒᵖ} (f : X ⟶ Y) (m₁ : M₁.obj X) (m₂ : M₂.obj X) :
     DFunLike.coe (α := (M₁.obj X ⊗ M₂.obj X :))
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
index 7f42f3237..468e6d78c 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
@@ -109,6 +109,7 @@ lemma pushforward_obj_map_apply (M : PresheafOfModules.{v} R) {X Y : Cᵒᵖ} (f
       (((pushforward φ).obj M).map f).hom m = M.map (F.map f.unop).op m := rfl
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `@[simp]`-normal form of `pushforward_obj_map_apply`. -/
 @[simp]
 lemma pushforward_obj_map_apply' (M : PresheafOfModules.{v} R) {X Y : Cᵒᵖ} (f : X ⟶ Y)
@@ -123,6 +124,7 @@ lemma pushforward_map_app_apply {M N : PresheafOfModules.{v} R} (α : M ⟶ N) (
     (((pushforward φ).map α).app X).hom m = α.app (Opposite.op (F.obj X.unop)) m := rfl
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `@[simp]`-normal form of `pushforward_map_app_apply`. -/
 @[simp]
 lemma pushforward_map_app_apply' {M N : PresheafOfModules.{v} R} (α : M ⟶ N) (X : Cᵒᵖ)
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ProjectiveDimension.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ProjectiveDimension.lean
index de496361c..a60ca6f2e 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ProjectiveDimension.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ProjectiveDimension.lean
@@ -53,6 +53,7 @@ variable [Small.{v} R] {R' : Type u'} [Ring R'] [Small.{v'} R'] (e : R ≃+* R')
 variable {M : ModuleCat.{v} R} {N : ModuleCat.{v'} R'}
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 lemma hasProjectiveDimensionLE_of_semiLinearEquiv (e' : M ≃ₛₗ[RingHomClass.toRingHom e] N)
     (n : ℕ) [HasProjectiveDimensionLE M n] : HasProjectiveDimensionLE N n := by
@@ -86,6 +87,8 @@ lemma hasProjectiveDimensionLE_of_semiLinearEquiv (e' : M ≃ₛₗ[RingHomClass
 alias _root_.CategoryTheory.hasProjectiveDimensionLE_of_semiLinearEquiv :=
   hasProjectiveDimensionLE_of_semiLinearEquiv
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 lemma projectiveDimension_eq_of_semiLinearEquiv (e' : M ≃ₛₗ[RingHomClass.toRingHom e] N) :
     projectiveDimension M = projectiveDimension N := by
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
index 71a5dfc5d..2ddca8bbb 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
@@ -228,6 +228,7 @@ def ofCocone {J : Type*} [Category* J] {F : J ⥤ TopModuleCat R}
     naturality {X Y} f := by ext x; exact congr($(c.ι.naturality f).hom x) }
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a colimit cocone over the underlying modules, equipping the cocone point with
 the coinduced topology gives a colimit cocone in `TopModuleCat R`. -/
 def isColimit {J : Type*} [Category* J] {F : J ⥤ TopModuleCat R}
@@ -423,6 +424,7 @@ def freeMap {X Y : TopCat.{v}} (f : X ⟶ Y) : freeObj R X ⟶ freeObj R Y :=
 lemma freeMap_map {X Y : TopCat.{v}} (f : X ⟶ Y) (v : X →₀ R) :
     (freeMap R f : (X →₀ R) → (Y →₀ R)) v = Finsupp.mapDomain f.hom v := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The free topological module over a topological space as a functor.
 This is left adjoint to the forgetful functor. -/
 @[simps] noncomputable
diff --git a/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean b/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
index 309ddebc0..cdb2705b7 100644
--- a/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
@@ -315,6 +315,7 @@ The categorical product of rings is the Cartesian product of rings. This is its
 def piFan : Fan R :=
   Fan.mk (CommRingCat.of ((i : ι) → R i)) (fun i ↦ ofHom <| Pi.evalRingHom _ i)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The categorical product of rings is the Cartesian product of rings.
 -/
diff --git a/mathlib4/Mathlib/Algebra/Category/Ring/EqualizerPushout.lean b/mathlib4/Mathlib/Algebra/Category/Ring/EqualizerPushout.lean
index 3a05fba09..e1935a4a9 100644
--- a/mathlib4/Mathlib/Algebra/Category/Ring/EqualizerPushout.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Ring/EqualizerPushout.lean
@@ -33,6 +33,8 @@ section Fork
 
 variable {R S : CommRingCat.{u}} (f : R ⟶ S)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `f : R ⟶ S` is a faithfully flat map in `CommRingCat`, then the fork
 ```
         S ---inl---> pushout f f
diff --git a/mathlib4/Mathlib/Algebra/Lie/Submodule.lean b/mathlib4/Mathlib/Algebra/Lie/Submodule.lean
index c7d9b6bfb..7cf72d82e 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Submodule.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Submodule.lean
@@ -518,6 +518,10 @@ variable (R L M)
     inj' := toSubmodule_injective
     map_rel_iff' := Iff.rfl }
 
+-- Defeq abuse: need `FunLike _ (LieSubmodule R L M) (Submodule R M)ᵒᵈ`, get
+-- `FunLike _ (LieSubmodule R L M)ᵒᵈ (Submodule R M)ᵒᵈ`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance wellFoundedGT_of_noetherian [IsNoetherian R M] : WellFoundedGT (LieSubmodule R L M) :=
   RelHomClass.isWellFounded (toSubmodule_orderEmbedding R L M).dual.ltEmbedding
 
@@ -727,6 +731,9 @@ variable (f : M →ₗ⁅R,L⁆ M') (N N₂ : LieSubmodule R L M) (N' : LieSubmo
 
 /-- A morphism of Lie modules `f : M → M'` pushes forward Lie submodules of `M` to Lie submodules
 of `M'`. -/
+-- Later we will want to know that `LieSubmodule.map` and `Submodule.map` are related in order for`
+-- the `FunLike` instances to be compatible.
+@[instance_reducible]
 def map : LieSubmodule R L M' :=
   { (N : Submodule R M).map (f : M →ₗ[R] M') with
     lie_mem := fun {x m'} h ↦ by
diff --git a/mathlib4/Mathlib/Algebra/Module/Injective.lean b/mathlib4/Mathlib/Algebra/Module/Injective.lean
index 79a3d21da..516e1c4d4 100644
--- a/mathlib4/Mathlib/Algebra/Module/Injective.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Injective.lean
@@ -474,6 +474,7 @@ instance Module.Injective.pi
     exact DFunLike.congr_fun (hl i) x⟩
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 universe u' in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 theorem Module.Injective.of_ringEquiv {R : Type u} [Ring R] [Small.{v} R] {S : Type u'} [Ring S]
diff --git a/mathlib4/Mathlib/Algebra/Order/Hom/Monoid.lean b/mathlib4/Mathlib/Algebra/Order/Hom/Monoid.lean
index e9156ad8f..2e43af442 100644
--- a/mathlib4/Mathlib/Algebra/Order/Hom/Monoid.lean
+++ b/mathlib4/Mathlib/Algebra/Order/Hom/Monoid.lean
@@ -232,12 +232,19 @@ theorem monotone_iff_map_nonneg [iamhc : AddMonoidHomClass F α β] :
 
 variable [iamhc : AddMonoidHomClass F α β]
 
+-- Defeq abuse: `iamhc` is not an instance about `βᵒᵈ`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem antitone_iff_map_nonpos : Antitone (f : α → β) ↔ ∀ a, 0 ≤ a → f a ≤ 0 :=
   monotone_toDual_comp_iff.symm.trans <| monotone_iff_map_nonneg (β := βᵒᵈ) (iamhc := iamhc) _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem monotone_iff_map_nonpos : Monotone (f : α → β) ↔ ∀ a ≤ 0, f a ≤ 0 :=
   antitone_comp_ofDual_iff.symm.trans <| antitone_iff_map_nonpos (α := αᵒᵈ) (iamhc := iamhc) _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem antitone_iff_map_nonneg : Antitone (f : α → β) ↔ ∀ a ≤ 0, 0 ≤ f a :=
   monotone_comp_ofDual_iff.symm.trans <| monotone_iff_map_nonneg (α := αᵒᵈ) (iamhc := iamhc) _
 
@@ -249,12 +256,18 @@ theorem strictMono_iff_map_pos :
   · rw [← sub_add_cancel b a, map_add f]
     exact lt_add_of_pos_left _ (h _ <| sub_pos.2 hl)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem strictAnti_iff_map_neg : StrictAnti (f : α → β) ↔ ∀ a, 0 < a → f a < 0 :=
   strictMono_toDual_comp_iff.symm.trans <| strictMono_iff_map_pos (β := βᵒᵈ) (iamhc := iamhc) _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem strictMono_iff_map_neg : StrictMono (f : α → β) ↔ ∀ a < 0, f a < 0 :=
   strictAnti_comp_ofDual_iff.symm.trans <| strictAnti_iff_map_neg (α := αᵒᵈ) (iamhc := iamhc) _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem strictAnti_iff_map_pos : StrictAnti (f : α → β) ↔ ∀ a < 0, 0 < f a :=
   strictMono_comp_ofDual_iff.symm.trans <| strictMono_iff_map_pos (α := αᵒᵈ) (iamhc := iamhc) _
 
diff --git a/mathlib4/Mathlib/Algebra/Star/TensorProduct.lean b/mathlib4/Mathlib/Algebra/Star/TensorProduct.lean
index 2ba906bc0..85e04d469 100644
--- a/mathlib4/Mathlib/Algebra/Star/TensorProduct.lean
+++ b/mathlib4/Mathlib/Algebra/Star/TensorProduct.lean
@@ -40,6 +40,10 @@ noncomputable instance : InvolutiveStar (A ⊗[R] B) where
 noncomputable instance : StarAddMonoid (A ⊗[R] B) where
   star_add := map_add _
 
+-- Would require `DFunLike.coe (starRingEnd R) = star` at `instances` transparency, which sounds
+-- reasonable but does not hold at the moment.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : StarModule R (A ⊗[R] B) where
   star_smul := map_smulₛₗ _
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/AffineScheme.lean b/mathlib4/Mathlib/AlgebraicGeometry/AffineScheme.lean
index 1204020a0..a97e22b24 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/AffineScheme.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/AffineScheme.lean
@@ -628,6 +628,7 @@ theorem ι_basicOpen_preimage (r : Γ(X, ⊤)) :
   exact hU.basicOpen _
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hU in
 theorem exists_basicOpen_le {V : X.Opens} (x : V) (h : ↑x ∈ U) :
     ∃ f : Γ(X, U), X.basicOpen f ≤ V ∧ ↑x ∈ X.basicOpen f := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean b/mathlib4/Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
index 9c81bfdff..7a2c0050a 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
@@ -979,6 +979,7 @@ end sections
 section IsAffine
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hc in
 /-- Suppose `{ Xᵢ }` is an inverse system of qcqs schemes with affine transition maps.
 If `lim Xᵢ` is quasi-affine, then some `Xᵢ` is quasi-affine. -/
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Artinian.lean b/mathlib4/Mathlib/AlgebraicGeometry/Artinian.lean
index f465a94b5..91de55b17 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Artinian.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Artinian.lean
@@ -143,6 +143,7 @@ theorem isLocallyArtinian_iff_of_isOpenCover {ι : Type*} {U : ι → X.Opens}
 instance (priority := low) {X : Scheme} [IsEmpty X] : IsLocallyArtinian X where
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := low) {X : Scheme} [DiscreteTopology X] [IsReduced X] :
     IsLocallyArtinian X := by
   wlog hX : Subsingleton X generalizing X
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Cover/Open.lean b/mathlib4/Mathlib/AlgebraicGeometry/Cover/Open.lean
index f776366f9..8812e5201 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Cover/Open.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Cover/Open.lean
@@ -200,6 +200,8 @@ lemma OpenCover.pullbackCoverAffineRefinementObjIso_inv_pullbackHom
   convert! pullbackSymmetry_inv_comp_fst ((𝒰.X i.1).affineCover.f i.2) (pullback.fst _ _)
   exact pullbackRightPullbackFstIso_hom_fst _ _ _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A family of elements spanning the unit ideal of `R` gives an affine open cover of `Spec R`. -/
 @[simps]
 noncomputable
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Cover/Over.lean b/mathlib4/Mathlib/AlgebraicGeometry/Cover/Over.lean
index 12498f903..84e753b43 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Cover/Over.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Cover/Over.lean
@@ -90,6 +90,7 @@ instance (j : 𝒰.I₀) : ((𝒰.pullbackCoverOver S f).X j).Over S where
   hom := (pullback (f.asOver S) ((𝒰.f j).asOver S)).hom
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (𝒰.pullbackCoverOver S f).Over S where
   isOver_map j := { comp_over := by exact Over.w (pullback.fst (f.asOver S) ((𝒰.f j).asOver S)) }
 
@@ -117,6 +118,7 @@ instance (j : 𝒰.I₀) : ((𝒰.pullbackCoverOver' S f).X j).Over S where
   hom := (pullback ((𝒰.f j).asOver S) (f.asOver S)).hom
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (𝒰.pullbackCoverOver' S f).Over S where
   isOver_map j := { comp_over := by exact Over.w (pullback.snd ((𝒰.f j).asOver S) (f.asOver S)) }
 
@@ -156,6 +158,7 @@ instance (j : 𝒰.I₀) : ((𝒰.pullbackCoverOverProp S f hX hW hQ).X j).Over
     ((𝒰.f j).asOverProp (hX := hQ j) (hY := hX) S)).hom
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (𝒰.pullbackCoverOverProp S f hX hW hQ).Over S where
   isOver_map j :=
     { comp_over := by exact (pullback.fst (f.asOverProp S) ((𝒰.f j).asOverProp S)).w }
@@ -189,6 +192,7 @@ instance (j : 𝒰.I₀) : ((𝒰.pullbackCoverOverProp' S f hX hW hQ).X j).Over
     (f.asOverProp (hX := hW) (hY := hX) S)).hom
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (𝒰.pullbackCoverOverProp' S f hX hW hQ).Over S where
   isOver_map j :=
     { comp_over := by exact (pullback.snd ((𝒰.f j).asOverProp S) (f.asOverProp S)).w }
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean b/mathlib4/Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
index aa0d42e7e..e129a1375 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
@@ -213,6 +213,7 @@ theorem toStalk_stalkMap_toΓSpec (x : X) :
   exact (X.toΓSpecBase _* X.presheaf).germ_res le_top.hom _ _
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The canonical morphism from `X` to the spectrum of its global sections. -/
 @[simps! base]
 def toΓSpec : X ⟶ Spec.locallyRingedSpaceObj (Γ.obj (op X)) :=
@@ -236,6 +237,7 @@ def toΓSpec : X ⟶ Spec.locallyRingedSpaceObj (Γ.obj (op X)) :=
     exact ht.mul <| (IsLocalization.map_units (R := Γ.obj (op X)) S s).map _)
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- On a locally ringed space `X`, the preimage of the zero locus of the prime spectrum
 of `Γ(X, ⊤)` under `toΓSpec` agrees with the associated zero locus on `X`. -/
 lemma toΓSpec_preimage_zeroLocus_eq {X : LocallyRingedSpace.{u}}
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Group/Abelian.lean b/mathlib4/Mathlib/AlgebraicGeometry/Group/Abelian.lean
index 289cd1c38..133229a84 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Group/Abelian.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Group/Abelian.lean
@@ -37,6 +37,7 @@ instance (G : Over (Spec (.of K))) [GrpObj G] : IsClosedImmersion η[G].left :=
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCommMonObj_of_isProper_of_isIntegral_tensorObj_of_isAlgClosed [IsAlgClosed K]
     (G : Over (Spec (.of K))) [IsProper G.hom] [IsIntegral (G ⊗ G).left] [GrpObj G] :
     IsCommMonObj G := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/IdealSheaf/Basic.lean b/mathlib4/Mathlib/AlgebraicGeometry/IdealSheaf/Basic.lean
index f8b70f468..261d002ad 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/IdealSheaf/Basic.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/IdealSheaf/Basic.lean
@@ -558,6 +558,7 @@ lemma radical_mul {I J : IdealSheafData X} :
   simp only [radical_ideal, ideal_mul, Pi.mul_apply, Ideal.radical_mul, ideal_inf, Pi.inf_apply]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The vanishing ideal sheaf of a closed set,
 which is the largest ideal sheaf whose support is equal to it.
 The reduced induced scheme structure on the closed set is the quotient of this ideal. -/
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Basic.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
index c6b523966..00b6856ac 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
@@ -585,6 +585,7 @@ theorem iff_of_isAffine [IsAffine Y] : P f ↔ Q f := by
     Q.cancel_left_of_respectsIso]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 900) : IsZariskiLocalAtTarget P := by
   let := isLocal_affineProperty P
   apply IsZariskiLocalAtTarget.mk'
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Finite.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Finite.lean
index cf6826b55..8eb5382fc 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Finite.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Finite.lean
@@ -52,16 +52,19 @@ instance : HasAffineProperty @IsFinite
   simp [isFinite_iff]
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : IsStableUnderComposition @IsFinite :=
   HasAffineProperty.affineAnd_isStableUnderComposition inferInstance
     RingHom.finite_stableUnderComposition
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : IsStableUnderBaseChange @IsFinite :=
   HasAffineProperty.affineAnd_isStableUnderBaseChange inferInstance
     RingHom.finite_respectsIso RingHom.finite_isStableUnderBaseChange
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ContainsIdentities @IsFinite :=
   HasAffineProperty.affineAnd_containsIdentities inferInstance
     RingHom.finite_respectsIso RingHom.finite_containsIdentities
@@ -156,6 +159,7 @@ lemma comp_iff {f : X ⟶ Y} {g : Y ⟶ Z} [IsFinite g] :
   ⟨fun _ ↦ .of_comp f g, fun _ ↦ inferInstance⟩
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance {U V X : Scheme.{u}} (f : U ⟶ X) (g : V ⟶ X) [IsFinite f] [IsFinite g] :
     IsFinite (Limits.coprod.desc f g) := by
   refine HasAffineProperty.coprodDesc_affineAnd inferInstance RingHom.finite_respectsIso
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean
index b4babad01..9c61f604c 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean
@@ -144,6 +144,7 @@ nonrec lemma LocallyOfFiniteType.jacobsonSpace
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The category of affine schemes locally of finite type over a fixed base scheme is essentially small.
 TODO: extend this to (relatively) quasi-compact schemes.
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
index 072da1940..b9279235a 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
@@ -379,6 +379,7 @@ theorem iff_of_iSup_eq_top [IsAffine Y] {ι : Type*}
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : IsZariskiLocalAtSource P := by
   apply HasAffineProperty.isZariskiLocalAtSource
   intro X Y f _ 𝒰
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
index bee804f02..c3ff3d749 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
@@ -111,6 +111,8 @@ instance universallyClosed_isZariskiLocalAtTarget : IsZariskiLocalAtTarget @Univ
 instance (f : X ⟶ Y) (V : Y.Opens) [UniversallyClosed f] : UniversallyClosed (f ∣_ V) :=
   IsZariskiLocalAtTarget.restrict ‹_› V
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 open Scheme.Pullback _root_.PrimeSpectrum MvPolynomial in
 /-- If `X` is universally closed over a field, then `X` is quasi-compact. -/
 lemma compactSpace_of_universallyClosed
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Noetherian.lean b/mathlib4/Mathlib/AlgebraicGeometry/Noetherian.lean
index 69e87d817..5dc0dd940 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Noetherian.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Noetherian.lean
@@ -162,6 +162,7 @@ instance {U : X.OpenCover} (i) [IsLocallyNoetherian X] : IsLocallyNoetherian (U.
   isLocallyNoetherian_of_isOpenImmersion (U.f i)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `𝒰` is an open cover of a scheme `X`, then `X` is locally Noetherian if and only if
 `𝒰.X i` are all locally Noetherian. -/
 theorem isLocallyNoetherian_iff_openCover (𝒰 : Scheme.OpenCover X) :
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Normalization.lean b/mathlib4/Mathlib/AlgebraicGeometry/Normalization.lean
index 8cc726c24..878bbd2fa 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Normalization.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Normalization.lean
@@ -344,6 +344,7 @@ instance : IsDominant f.toNormalization := by
   exact ⟨dense_iff_closure_eq.mpr this⟩
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 @[stacks 0AXN]
 instance [IsReduced X] : IsReduced f.normalization :=
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/OpenImmersion.lean b/mathlib4/Mathlib/AlgebraicGeometry/OpenImmersion.lean
index bfe8038c5..8b9209a0d 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/OpenImmersion.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/OpenImmersion.lean
@@ -44,6 +44,8 @@ instance IsOpenImmersion.comp {X Y Z : Scheme.{u}} (f : X ⟶ Y) (g : Y ⟶ Z)
 
 namespace LocallyRingedSpace.IsOpenImmersion
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- To show that a locally ringed space is a scheme, it suffices to show that it has a jointly
 surjective family of open immersions from affine schemes. -/
 protected def scheme (X : LocallyRingedSpace.{u})
@@ -359,6 +361,7 @@ lemma _root_.AlgebraicGeometry.IsOpenImmersion.of_isLocalization {R S} [CommRing
   infer_instance
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem exists_affine_mem_range_and_range_subset
     {X : Scheme.{u}} {x : X} {U : X.Opens} (hxU : x ∈ U) :
     ∃ R, ∃ (f : Spec R ⟶ X), IsOpenImmersion f ∧ x ∈ Set.range f ∧ Set.range f ⊆ U := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean b/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
index 86ddc9903..d10f52c75 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
@@ -827,6 +827,7 @@ lemma stalkMap_toSpec (f) (x : pbo f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
   rw [awayToΓ_ΓToStalk, ← toStalk_specStalkEquiv, Category.assoc]; rfl
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma isIso_toSpec (f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
     IsIso (toSpec 𝒜 f) := by
   have : IsIso (toSpec 𝒜 f).base := toSpec_base_isIso 𝒜 f_deg hm
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean b/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
index af6d17878..24c17d4b4 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
@@ -279,6 +279,7 @@ theorem stalkToFiberRingHom_germ (U : Opens (ProjectiveSpectrum.top 𝒜))
   RingHom.ext_iff.1 (CommRingCat.hom_ext_iff.mp (germ_comp_stalkToFiberRingHom 𝒜 U x hx)) s
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mem_basicOpen_den (x : ProjectiveSpectrum.top 𝒜)
     (f : HomogeneousLocalization.NumDenSameDeg 𝒜 x.asHomogeneousIdeal.toIdeal.primeCompl) :
     x ∈ ProjectiveSpectrum.basicOpen 𝒜 f.den := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Pullbacks.lean b/mathlib4/Mathlib/AlgebraicGeometry/Pullbacks.lean
index 2f852a88c..c83b2f0fd 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Pullbacks.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Pullbacks.lean
@@ -479,6 +479,7 @@ instance left_affine_comp_pullback_hasPullback {X Y Z : Scheme} (f : X ⟶ Z) (g
     hasPullback_assoc_symm f (Z.affineCover.f i) (Z.affineCover.f i) g
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance {X Y Z : Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) : HasPullback f g :=
   hasPullback_of_cover (Z.affineCover.pullback₁ f) f g
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Restrict.lean b/mathlib4/Mathlib/AlgebraicGeometry/Restrict.lean
index 8c0d8521d..d03e96e00 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Restrict.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Restrict.lean
@@ -119,6 +119,8 @@ lemma ι_image_le (W : U.toScheme.Opens) : U.ι ''ᵁ W ≤ U := by
 lemma ι_preimage_self : U.ι ⁻¹ᵁ U = ⊤ :=
   Opens.inclusion'_map_eq_top _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_ι_image_iff {x : U} {V : Opens U} : (x : X) ∈ U.ι ''ᵁ V ↔ x ∈ V :=
   U.ι.apply_mem_image_iff
@@ -151,6 +153,8 @@ def stalkIso {X : Scheme.{u}} (U : X.Opens) (x : U) :
     U.toScheme.presheaf.stalk x ≅ X.presheaf.stalk x.1 :=
   X.restrictStalkIso (Opens.isOpenEmbedding _) _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp)]
 lemma germ_stalkIso_hom {X : Scheme.{u}} (U : X.Opens)
     {V : U.toScheme.Opens} (x : U) (hx : x ∈ V) :
@@ -158,6 +162,8 @@ lemma germ_stalkIso_hom {X : Scheme.{u}} (U : X.Opens)
         X.presheaf.germ (U.ι ''ᵁ V) x.1 ⟨x, hx, rfl⟩ :=
     PresheafedSpace.restrictStalkIso_hom_eq_germ _ U.isOpenEmbedding _ _ _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc]
 lemma germ_stalkIso_inv {X : Scheme.{u}} (U : X.Opens) (V : U.toScheme.Opens) (x : U)
     (hx : x ∈ V) : X.presheaf.germ (U.ι ''ᵁ V) x ⟨x, hx, rfl⟩ ≫
@@ -230,6 +236,8 @@ lemma Scheme.Opens.ι_image_basicOpen_topIso_inv (r : Γ(X, U)) :
   simp only [Scheme.Opens.toScheme_presheaf_obj]
   rw [ι_image_basicOpen', basicOpen_res_eq, topIso_inv, basicOpen_res_eq X]
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma Scheme.Opens.mem_basicOpen_toScheme {U : X.Opens} {V : Scheme.Opens U} {r : Γ(U, V)} {x : U} :
     x ∈ U.toScheme.basicOpen r ↔ (x : X) ∈ X.basicOpen r := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Scheme.lean b/mathlib4/Mathlib/AlgebraicGeometry/Scheme.lean
index f93f889c2..1f43f76ac 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Scheme.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Scheme.lean
@@ -890,6 +890,7 @@ lemma Scheme.inv_hom_apply {X Y : Scheme.{u}} (e : X ≅ Y) (y : Y) :
   simp
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Spec_zeroLocus_eq_zeroLocus {R : CommRingCat} (s : Set R) :
     (Spec R).zeroLocus ((Scheme.ΓSpecIso R).inv '' s) = PrimeSpectrum.zeroLocus s := by
   ext x
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Spec.lean b/mathlib4/Mathlib/AlgebraicGeometry/Spec.lean
index 6d84a46dc..4dc2f26ed 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Spec.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Spec.lean
@@ -238,6 +238,7 @@ theorem localRingHom_comp_stalkIso {R S : CommRingCat.{u}} (f : R ⟶ S) (p : Pr
   exact stalkMap_toStalk_apply f p x
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The induced map of a ring homomorphism on the prime spectra, as a morphism of locally ringed spaces.
 -/
@@ -369,6 +370,7 @@ def toPushforwardStalkAlgHom :
     commutes' := fun _ => rfl }
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isLocalizedModule_toPushforwardStalkAlgHom_aux (y) :
     ∃ x : S × p.asIdeal.primeCompl, x.2 • y = toPushforwardStalkAlgHom R S p x.1 := by
   obtain ⟨U, hp, s, e⟩ := TopCat.Presheaf.exists_germ_eq _ y
@@ -402,6 +404,7 @@ theorem isLocalizedModule_toPushforwardStalkAlgHom_aux (y) :
   congr 1
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance isLocalizedModule_toPushforwardStalkAlgHom :
     IsLocalizedModule p.asIdeal.primeCompl (toPushforwardStalkAlgHom R S p).toLinearMap := by
   apply IsLocalizedModule.mkOfAlgebra
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean b/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
index 9cded7882..da4223d70 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
@@ -66,6 +66,7 @@ namespace AlgebraicGeometry
 
 variable (R) in
 /-- The prime spectrum as an object of `TopCat`. -/
+@[instance_reducible]
 public def PrimeSpectrum.Top : TopCat := TopCat.of (PrimeSpectrum R)
 
 namespace StructureSheaf
@@ -653,6 +654,8 @@ theorem toOpenₗ_germ (U : Opens (PrimeSpectrum.Top R)) (x : PrimeSpectrum.Top
   rw [toStalkₗ', ← Presheaf.germ_res _ (homOfLE le_top) _ hx, ← Category.assoc]
   rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isUnit_toStalk (x : PrimeSpectrum.Top R) (f : R) (hf : x ∈ basicOpen f) :
     IsUnit (toStalk R x f) := by
   convert! (isUnit_basicOpen f).map ((structurePresheafInCommRingCat R).germ _ x hf).hom
@@ -831,6 +834,7 @@ instance (x : PrimeSpectrum.Top R) : IsLocalizedModule x.asIdeal.primeCompl (toS
   exact congr($this _)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R) in
 /-- The stalk of `Spec R` at `x` is isomorphic to the stalk of `R^~` at `x`. -/
 @[expose] public
@@ -958,6 +962,8 @@ instance to_basicOpen_epi (r : R) :
   ⟨fun _ _ h => CommRingCat.hom_ext (IsLocalization.ringHom_ext (Submonoid.powers r)
     (CommRingCat.hom_ext_iff.mp h))⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The ring isomorphism between the ring `R` and the global sections `Γ(X, 𝒪ₓ)`. -/
 @[simps! inv]
 def globalSectionsIso : CommRingCat.of R ≅ (structureSheaf R).1.obj (op ⊤) :=
diff --git a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/Degenerate.lean b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/Degenerate.lean
index e87c92954..57804626b 100644
--- a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/Degenerate.lean
+++ b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/Degenerate.lean
@@ -264,6 +264,7 @@ variable {X} (A : X.Subcomplex)
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma mem_degenerate_iff {n : ℕ} (x : A.obj (op ⦋n⦌)) :
     dsimp% x ∈ degenerate A n ↔ x.val ∈ X.degenerate n := by
   rw [SSet.mem_degenerate_iff, SSet.mem_degenerate_iff]
@@ -279,6 +280,7 @@ lemma mem_degenerate_iff {n : ℕ} (x : A.obj (op ⦋n⦌)) :
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma mem_nonDegenerate_iff {n : ℕ} (x : A.obj (op ⦋n⦌)) :
     dsimp% x ∈ nonDegenerate A n ↔ x.val ∈ X.nonDegenerate n := by
   rw [mem_nonDegenerate_iff_notMem_degenerate,
diff --git a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/TopAdj.lean b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/TopAdj.lean
index b54bd10e8..b112f6b40 100644
--- a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/TopAdj.lean
+++ b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/TopAdj.lean
@@ -35,6 +35,8 @@ namespace SimplexCategory
 
 open SSet
 
+-- Needs to unfold `toTop` at `instances` transparency
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- The homeomorphism between the topological realization of a standard simplex
 in `SSet` and the corresponding topological standard simplex. -/
 noncomputable def toTopHomeo (n : SimplexCategory) :
diff --git a/mathlib4/Mathlib/Analysis/Fourier/FiniteAbelian/PontryaginDuality.lean b/mathlib4/Mathlib/Analysis/Fourier/FiniteAbelian/PontryaginDuality.lean
index 3918dfeac..e67983bd6 100644
--- a/mathlib4/Mathlib/Analysis/Fourier/FiniteAbelian/PontryaginDuality.lean
+++ b/mathlib4/Mathlib/Analysis/Fourier/FiniteAbelian/PontryaginDuality.lean
@@ -151,6 +151,8 @@ lemma exists_apply_ne_zero : (∃ ψ : AddChar α ℂ, ψ a ≠ 1) ↔ a ≠ 0 :
 lemma forall_apply_eq_zero : (∀ ψ : AddChar α ℂ, ψ a = 1) ↔ a = 0 := by
   simpa using exists_apply_ne_zero.not
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma doubleDualEmb_injective : Injective (doubleDualEmb : α → AddChar (AddChar α ℂ) ℂ) :=
   doubleDualEmb.ker_eq_bot_iff.1 <| eq_bot_iff.2 fun a ha ↦
     forall_apply_eq_zero.1 fun ψ ↦ by simpa using! DFunLike.congr_fun ha (Additive.ofMul ψ)
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
index d9ed9660d..85b20977a 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
@@ -251,6 +251,8 @@ instance : StarMul (E →L[𝕜] E) :=
 instance : StarRing (E →L[𝕜] E) :=
   ⟨map_add adjoint⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : StarModule 𝕜 (E →L[𝕜] E) :=
   ⟨map_smulₛₗ adjoint⟩
 
@@ -697,6 +699,8 @@ instance : StarMul (E →ₗ[𝕜] E) :=
 instance : StarRing (E →ₗ[𝕜] E) :=
   ⟨map_add adjoint⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : StarModule 𝕜 (E →ₗ[𝕜] E) :=
   ⟨map_smulₛₗ adjoint⟩
 
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearPMap.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
index 601755168..63d369a09 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
@@ -234,6 +234,8 @@ variable {A : E →ₗ.[𝕜] E}
 
 theorem isSelfAdjoint_def : IsSelfAdjoint A ↔ A† = A := Iff.rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Every self-adjoint `LinearPMap` has dense domain.
 
 This is not true by definition since we define the adjoint without the assumption that the
diff --git a/mathlib4/Mathlib/Analysis/Matrix/HermitianFunctionalCalculus.lean b/mathlib4/Mathlib/Analysis/Matrix/HermitianFunctionalCalculus.lean
index 4db359d9b..7321b6bd9 100644
--- a/mathlib4/Mathlib/Analysis/Matrix/HermitianFunctionalCalculus.lean
+++ b/mathlib4/Mathlib/Analysis/Matrix/HermitianFunctionalCalculus.lean
@@ -132,6 +132,9 @@ should prefer the generic API, especially because it will make rewriting easier.
 protected noncomputable def cfc (f : ℝ → ℝ) : Matrix n n 𝕜 :=
   conjStarAlgAut 𝕜 _ hA.eigenvectorUnitary (diagonal (RCLike.ofReal ∘ f ∘ hA.eigenvalues))
 
+-- Abuses the `defeq` that `IsSelfAdjoint` and `IsHermitian` coincide.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cfcHom_eq_cfcAux : cfcHom hA.isSelfAdjoint = hA.cfcAux :=
   cfcHom_eq_of_continuous_of_map_id hA hA.cfcAux
     hA.isClosedEmbedding_cfcAux.continuous hA.cfcAux_id
diff --git a/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean b/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
index 0c1f2dffc..10767576a 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
@@ -691,7 +691,9 @@ universe u v
 variable {K : Type u} [NontriviallyNormedField K] {L : Type v} [Field L] [Algebra K L]
   [Algebra.IsAlgebraic K L] [hu : IsUltrametricDist K]
 
-set_option allowUnsafeReducibility true
+@[implicit_reducible]
+private def myId {α : Sort u} (a : α) : α :=
+  a
 
 /-- If `K` is a field complete with respect to a nontrivial nonarchimedean multiplicative norm and
   `L/K` is an algebraic extension, then any power-multiplicative `K`-algebra norm on `L` coincides
@@ -700,7 +702,7 @@ theorem spectralNorm_unique [CompleteSpace K] {f : AlgebraNorm K L} (hf_pm : IsP
     f = spectralAlgNorm K L := by
   apply eq_of_powMul_faithful f hf_pm _ spectralAlgNorm_isPowMul
   intro x
-  let E : Type v := id K⟮x⟯
+  let E : Type v := myId K⟮x⟯
   let : Field E := id <| show Field K⟮x⟯ by infer_instance
   let : Module K E := id <| show Module K K⟮x⟯ by infer_instance
   let id1 : K⟮x⟯ →ₗ[K] E := LinearMap.id
diff --git a/mathlib4/Mathlib/CategoryTheory/Action/Continuous.lean b/mathlib4/Mathlib/CategoryTheory/Action/Continuous.lean
index cf638edfc..941de082e 100644
--- a/mathlib4/Mathlib/CategoryTheory/Action/Continuous.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Action/Continuous.lean
@@ -151,6 +151,7 @@ namespace DiscreteContAction
 
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : HasForget₂ (DiscreteContAction V G) (ContAction V G) :=
   inferInstanceAs <| HasForget₂ (ObjectProperty.FullSubcategory _) _
 
diff --git a/mathlib4/Mathlib/CategoryTheory/Category/TwoP.lean b/mathlib4/Mathlib/CategoryTheory/Category/TwoP.lean
index 4dafafe70..1b328369f 100644
--- a/mathlib4/Mathlib/CategoryTheory/Category/TwoP.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Category/TwoP.lean
@@ -66,6 +66,7 @@ noncomputable instance largeCategory : LargeCategory TwoP :=
   inferInstanceAs <| Category (InducedCategory _ toBipointed)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance concreteCategory : ConcreteCategory TwoP
     (fun X Y => Bipointed.HomSubtype X.toBipointed Y.toBipointed) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toBipointed) _
diff --git a/mathlib4/Mathlib/CategoryTheory/EssentiallySmall.lean b/mathlib4/Mathlib/CategoryTheory/EssentiallySmall.lean
index 6dd489241..8a54e4db4 100644
--- a/mathlib4/Mathlib/CategoryTheory/EssentiallySmall.lean
+++ b/mathlib4/Mathlib/CategoryTheory/EssentiallySmall.lean
@@ -200,7 +200,8 @@ instance {T : Type u} [Unique T] : Unique (ShrinkHoms.{u} T) where
 
 instance {T : Type u} [Category.{v} T] [IsDiscrete T] : IsDiscrete (ShrinkHoms.{u} T) where
   subsingleton _ _ := { allEq _ _ := Shrink.ext (Subsingleton.elim _ _) }
-  eq_of_hom f := IsDiscrete.eq_of_hom (C := T) ((equivShrink _).symm f)
+  eq_of_hom {X Y} f := IsDiscrete.eq_of_hom (C := T)
+    ((equivShrink (fromShrinkHoms X ⟶ fromShrinkHoms Y)).symm f)
 
 end ShrinkHoms
 
diff --git a/mathlib4/Mathlib/CategoryTheory/Extensive.lean b/mathlib4/Mathlib/CategoryTheory/Extensive.lean
index e1d2ab847..ee10fa7f2 100644
--- a/mathlib4/Mathlib/CategoryTheory/Extensive.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Extensive.lean
@@ -404,6 +404,7 @@ instance {C} [Category* C] {D} [Category* D] (F : C ⥤ D)
   preservesPullback_symmetry _ _ _
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem finitaryExtensive_of_preserves_and_reflects (F : C ⥤ D) [FinitaryExtensive D]
     [HasFiniteCoproducts C] [HasPullbacksOfInclusions C]
     [PreservesPullbacksOfInclusions F]
diff --git a/mathlib4/Mathlib/CategoryTheory/FintypeCat.lean b/mathlib4/Mathlib/CategoryTheory/FintypeCat.lean
index 4fa0b1cc0..2fdeb827b 100644
--- a/mathlib4/Mathlib/CategoryTheory/FintypeCat.lean
+++ b/mathlib4/Mathlib/CategoryTheory/FintypeCat.lean
@@ -235,9 +235,14 @@ attribute [local instance] FintypeCat.fintype in
 @[simp]
 theorem incl_mk_nat_card (n : ℕ) :
     Fintype.card (incl.obj (mk n)) = n := by
-  convert! Finset.card_fin n
-  dsimp [incl, mk, len]
-  convert! (Fintype.ofEquiv_card Equiv.ulift).symm
+  -- Use `unfold` rather than `simp only` to keep instances in sync.
+  unfold incl mk len at *
+  dsimp only
+  conv_rhs => rw [← Fintype.card_fin n]
+  -- This `convert` would not be necessary if `Fintype.card_congr'` and `Fintype.ofEquiv_card` had
+  -- the `Fintype` instances as implicit arguments, which would make more sense for this and many
+  -- other lemmas in that file.
+  convert! Eq.trans (Fintype.ofEquiv_card Equiv.ulift).symm (@Fintype.card_congr' _ _ _ _ rfl)
 
 end Skeleton
 
diff --git a/mathlib4/Mathlib/CategoryTheory/Functor/TypeValuedFlat.lean b/mathlib4/Mathlib/CategoryTheory/Functor/TypeValuedFlat.lean
index 889298a51..6c92dcf20 100644
--- a/mathlib4/Mathlib/CategoryTheory/Functor/TypeValuedFlat.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Functor/TypeValuedFlat.lean
@@ -73,6 +73,9 @@ def fromOverSubfunctor : Subfunctor (Over.forget X ⋙ F) where
   obj U := F.map U.hom ⁻¹' {x}
   map _ _ _ := by simpa [← comp_apply, ← Functor.map_comp]
 
+-- Would need `(Over.forget X ⋙ F).obj U = F.obj U.left` at `instances` transparency.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_fromOverSubfunctor_iff {U : Over X} (u : F.obj U.left) :
     u ∈ (fromOverSubfunctor F x).obj U ↔ F.map U.hom u = x := Iff.rfl
diff --git a/mathlib4/Mathlib/CategoryTheory/Galois/Equivalence.lean b/mathlib4/Mathlib/CategoryTheory/Galois/Equivalence.lean
index b9a933908..a1cb6f6e2 100644
--- a/mathlib4/Mathlib/CategoryTheory/Galois/Equivalence.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Galois/Equivalence.lean
@@ -54,6 +54,7 @@ instance {F : C ⥤ FintypeCat.{u₁}} [FiberFunctor F] : (functorToContAction F
     obtain ⟨A, ⟨i⟩⟩ := exists_lift_of_continuous (F := F) X
     exact ⟨A, ⟨ObjectProperty.isoMk _ i⟩⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
 instance : (functorToContAction F).EssSurj := by
   let F' : C ⥤ FintypeCat.{u₁} := F ⋙ FintypeCat.uSwitch.{w, u₁}
   let : FiberFunctor F' := FiberFunctor.comp_right _
diff --git a/mathlib4/Mathlib/CategoryTheory/Limits/Shapes/Images.lean b/mathlib4/Mathlib/CategoryTheory/Limits/Shapes/Images.lean
index 6723da2e5..246b9f177 100644
--- a/mathlib4/Mathlib/CategoryTheory/Limits/Shapes/Images.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Limits/Shapes/Images.lean
@@ -148,7 +148,7 @@ def ofIsoComp {X' : C} (g : X' ⟶ X) [IsIso g] (F : MonoFactorisation (g ≫ f)
 
 /-- If `f` and `g` are isomorphic arrows, then a mono factorisation of `f`
 gives a mono factorisation of `g` -/
-@[simps]
+@[implicit_reducible, simps]
 def ofArrowIso {f g : Arrow C} (F : MonoFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
     MonoFactorisation g.hom where
   I := F.I
@@ -742,10 +742,7 @@ instance (priority := 100) hasImageMapOfIsIso {f g : Arrow C} [HasImage f.hom] [
     (sq : f ⟶ g) [IsIso sq] : HasImageMap sq :=
   HasImageMap.mk
     { map := image.lift ((Image.monoFactorisation g.hom).ofArrowIso (inv sq))
-      map_ι := by
-        erw [← cancel_mono (inv sq).right, Category.assoc, ← MonoFactorisation.ofArrowIso_m,
-          image.lift_fac, Category.assoc, ← Comma.comp_right, IsIso.hom_inv_id, Comma.id_right,
-          Category.comp_id] }
+      map_ι := by simp [ ← image.lift_fac ((Image.monoFactorisation g.hom).ofArrowIso (inv sq))] }
 
 instance HasImageMap.comp {f g h : Arrow C} [HasImage f.hom] [HasImage g.hom] [HasImage h.hom]
     (sq1 : f ⟶ g) (sq2 : g ⟶ h) [HasImageMap sq1] [HasImageMap sq2] : HasImageMap (sq1 ≫ sq2) :=
diff --git a/mathlib4/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean b/mathlib4/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean
index b59fcf287..598e49b26 100644
--- a/mathlib4/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean
@@ -274,6 +274,7 @@ open Function (Injective)
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem binaryCofan_isColimit_iff {X Y : Type u} (c : BinaryCofan X Y) :
     Nonempty (IsColimit c) ↔
       Injective c.inl ∧ Injective c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr) := by
diff --git a/mathlib4/Mathlib/CategoryTheory/Localization/StructuredArrow.lean b/mathlib4/Mathlib/CategoryTheory/Localization/StructuredArrow.lean
index 427184c48..45fa9fcb0 100644
--- a/mathlib4/Mathlib/CategoryTheory/Localization/StructuredArrow.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Localization/StructuredArrow.lean
@@ -63,6 +63,8 @@ section
 variable (W : MorphismProperty C) {X : C}
   (P : StructuredArrow (W.Q.obj X) W.Q → Prop)
 
+-- The new goal given in the `suffices` clause is not type-correct
+set_option backward.isDefEq.respectTransparency.instances false in
 open Construction in
 private lemma induction_structuredArrow'
     (hP₀ : P (StructuredArrow.mk (𝟙 (W.Q.obj X))))
diff --git a/mathlib4/Mathlib/CategoryTheory/Monoidal/Cartesian/ShrinkYoneda.lean b/mathlib4/Mathlib/CategoryTheory/Monoidal/Cartesian/ShrinkYoneda.lean
index 1c85a0fd1..b1efd3549 100644
--- a/mathlib4/Mathlib/CategoryTheory/Monoidal/Cartesian/ShrinkYoneda.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Monoidal/Cartesian/ShrinkYoneda.lean
@@ -48,6 +48,7 @@ noncomputable def shrinkYonedaMon :
 
 open MonObj
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- The type `(shrinkYonedaMon.obj M).obj Y` is equivalent to `Y.unop ⟶ M.X`. -/
 noncomputable def shrinkYonedaMonObjObjEquiv {M : Mon C} {Y : Cᵒᵖ} :
     (shrinkYonedaMon.{w}.obj M).obj Y ≃* (Y.unop ⟶ M.X) :=
@@ -83,6 +84,7 @@ noncomputable def shrinkYonedaGrp :
   obj X := GrpCat.shrinkFunctor (yonedaGrp.obj X)
   map f := GrpCat.shrinkFunctorMap (yonedaGrp.map f)
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- The type `(shrinkYonedaGrp.obj M).obj Y` is equivalent to `Y.unop ⟶ M.X`. -/
 noncomputable def shrinkYonedaGrpObjObjEquiv {M : Grp C} {Y : Cᵒᵖ} :
     (shrinkYonedaGrp.{w}.obj M).obj Y ≃* (Y.unop ⟶ M.X) :=
diff --git a/mathlib4/Mathlib/CategoryTheory/Presentable/Type.lean b/mathlib4/Mathlib/CategoryTheory/Presentable/Type.lean
index ed0a4b7f7..42cf93e8b 100644
--- a/mathlib4/Mathlib/CategoryTheory/Presentable/Type.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Presentable/Type.lean
@@ -99,6 +99,7 @@ def cocone : Cocone (Set.functor X κ) where
   ι.app _ := ↾(Subtype.val)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 /-- Any type `X` is the (filtered) colimit of its subsets of cardinality `< κ`
 when `κ` is an infinite cardinal. (This colimit is `κ`-filtered when `κ` is
diff --git a/mathlib4/Mathlib/CategoryTheory/Shift/Adjunction.lean b/mathlib4/Mathlib/CategoryTheory/Shift/Adjunction.lean
index 1628ddc03..a7108080b 100644
--- a/mathlib4/Mathlib/CategoryTheory/Shift/Adjunction.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Shift/Adjunction.lean
@@ -551,7 +551,7 @@ instance : (Equivalence.refl (C := C)).inverse.CommShift A :=
 The identity equivalence is compatible with shifts.
 -/
 instance : (Equivalence.refl (C := C)).CommShift A :=
-  inferInstanceAs <| Adjunction.id.CommShift A
+  inferInstanceAs <| (Adjunction.id (C := C)).CommShift A
 
 /--
 If an equivalence `E : C ≌ D` is compatible with shifts, so is `E.symm`.
diff --git a/mathlib4/Mathlib/CategoryTheory/Yoneda.lean b/mathlib4/Mathlib/CategoryTheory/Yoneda.lean
index 43e3c2454..e41f52d11 100644
--- a/mathlib4/Mathlib/CategoryTheory/Yoneda.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Yoneda.lean
@@ -1192,6 +1192,7 @@ lemma uliftCoyonedaEquiv_symm_map {X Y : C} (f : X ⟶ Y) {F : C ⥤ Type (max w
   simp
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma uliftCoyonedaEquiv_uliftCoyoneda_map {X Y : Cᵒᵖ} (f : X ⟶ Y) :
     DFunLike.coe (β := fun _ ↦ ULift.{w} (Y.unop ⟶ X.unop))
diff --git a/mathlib4/Mathlib/Combinatorics/Enumerative/IncidenceAlgebra.lean b/mathlib4/Mathlib/Combinatorics/Enumerative/IncidenceAlgebra.lean
index 22b6f2466..9e43b76b0 100644
--- a/mathlib4/Mathlib/Combinatorics/Enumerative/IncidenceAlgebra.lean
+++ b/mathlib4/Mathlib/Combinatorics/Enumerative/IncidenceAlgebra.lean
@@ -573,7 +573,7 @@ O'Donnell. -/
 lemma moebius_inversion_bot (f g : α → 𝕜) (h : ∀ x, g x = ∑ y ∈ Iic x, f y) (x : α) :
     f x = ∑ y ∈ Iic x, mu 𝕜 y x * g y := by
   convert! moebius_inversion_top (α := αᵒᵈ) f g h x using 3
-  rw [← mu_toDual]; rfl
+  · rw [← mu_toDual]; rfl
 
 end InversionBot
 
diff --git a/mathlib4/Mathlib/Combinatorics/Quiver/ConnectedComponent.lean b/mathlib4/Mathlib/Combinatorics/Quiver/ConnectedComponent.lean
index 3653855a3..e3f0e624e 100644
--- a/mathlib4/Mathlib/Combinatorics/Quiver/ConnectedComponent.lean
+++ b/mathlib4/Mathlib/Combinatorics/Quiver/ConnectedComponent.lean
@@ -181,6 +181,9 @@ lemma stronglyConnectedComponent_singleton_iff (v : V) :
       exists_path_of_stronglyConnectedComponent_eq (a := w) (b := v) h_same_scc
     exact (h_no_bidir w hw_ne) ⟨hba, hab⟩
 
+-- Defeq abuse: `h` does not apply to `a` and `b`, as `a b : Symmetrify V` and this leaks into
+-- `p`, which has type `@Path V inst✝ a b` which makes no sense at `instances` transparency.
+set_option backward.isDefEq.respectTransparency.instances false in
 lemma IsStronglyConnected.isStronglyConnected_symmetrify (h : IsStronglyConnected V) :
     IsStronglyConnected (Symmetrify V) := by
   intro a b
diff --git a/mathlib4/Mathlib/Computability/RecursiveIn.lean b/mathlib4/Mathlib/Computability/RecursiveIn.lean
index 7acac8fe8..0302b00c6 100644
--- a/mathlib4/Mathlib/Computability/RecursiveIn.lean
+++ b/mathlib4/Mathlib/Computability/RecursiveIn.lean
@@ -219,7 +219,7 @@ theorem partrec_of_oracle
   Nat.RecursiveIn.partrec_of_oracle (by simpa only [Partrec.nat_iff] using hO) hf
 
 /-- If a function is recursive in a constant partial function, then it is partial recursive. -/
-lemma partrec_of_const {s} (hf : RecursiveIn {fun _ => s} f) : Partrec f :=
+lemma partrec_of_const {s} (hf : RecursiveIn {(fun _ => s : ℕ →. ℕ)} f) : Partrec f :=
   hf.partrec_of_oracle
     (fun g hg => by rw [Set.mem_singleton_iff.mp hg]; exact .const' s)
 
diff --git a/mathlib4/Mathlib/Condensed/Light/Functors.lean b/mathlib4/Mathlib/Condensed/Light/Functors.lean
index 33e8b2d44..d281d6e8f 100644
--- a/mathlib4/Mathlib/Condensed/Light/Functors.lean
+++ b/mathlib4/Mathlib/Condensed/Light/Functors.lean
@@ -49,6 +49,7 @@ instance : lightProfiniteToLightCondSet.Faithful :=
   inferInstanceAs ((coherentTopology LightProfinite).yoneda).Faithful
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The functor from `LightProfinite` to `LightCondSet` factors through `TopCat`.
 -/
diff --git a/mathlib4/Mathlib/Condensed/Light/Sequence.lean b/mathlib4/Mathlib/Condensed/Light/Sequence.lean
index 3b9d812f0..e23032248 100644
--- a/mathlib4/Mathlib/Condensed/Light/Sequence.lean
+++ b/mathlib4/Mathlib/Condensed/Light/Sequence.lean
@@ -53,6 +53,7 @@ lemma mem_fibres_iff (π : T → S × Option X) (σ : Option X → S → T) (t :
   simp [fibres]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma fibres_compl_eq_iUnion (π : T → S × Option X) (σ : Option X → S → T)
     (hσ' : ∀ (x : Option X) (s : S), (π (σ x s)).2 = x) :
     (fibres π σ)ᶜ =
@@ -183,6 +184,7 @@ lemma S'_compactSpace [TopologicalSpace S] [T2Space S] [TopologicalSpace T]
 
 end
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- This object is used to show that a certain map `T ⟶ X` descends
 to a map `S ⊗ N∪{∞} → X`. Because epimorphisms in `LightProfinite`
 are effective, it does so if the two maps `pullback π π → T → S ⊗ N∪{∞}`
@@ -243,6 +245,7 @@ noncomputable def cocone {X : LightCondMod R} {S T : LightProfinite} (π : T ⟶
     simp [pullback.condition]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a surjective map of light profinite spaces `T ⟶ S ⊗ ℕ∪{∞}`,
 construct a (non-cartesian) commutative square
 ```
diff --git a/mathlib4/Mathlib/Data/DFinsupp/Lex.lean b/mathlib4/Mathlib/Data/DFinsupp/Lex.lean
index 3f40309df..b25ca1ab9 100644
--- a/mathlib4/Mathlib/Data/DFinsupp/Lex.lean
+++ b/mathlib4/Mathlib/Data/DFinsupp/Lex.lean
@@ -96,6 +96,7 @@ instance Lex.isStrictOrder [∀ i, PartialOrder (α i)] :
   trans _ _ _ := lt_trans (α := Lex (∀ i, α i))
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.isStrictOrder [∀ i, PartialOrder (α i)] :
     IsStrictOrder (Colex (Π₀ i, α i)) (· < ·) :=
   Lex.isStrictOrder (ι := ιᵒᵈ)
@@ -122,6 +123,7 @@ theorem Lex.le_iff_of_unique [Unique ι] [∀ i, PartialOrder (α i)] {x y : Lex
   Pi.lex_le_iff_of_unique
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Colex.le_iff_of_unique [Unique ι] [∀ i, PartialOrder (α i)] {x y : Colex (Π₀ i, α i)} :
     x ≤ y ↔ x default ≤ y default :=
   Lex.le_iff_of_unique (ι := ιᵒᵈ)
@@ -149,6 +151,7 @@ instance Lex.total_le : @Std.Total (Lex (Π₀ i, α i)) (· ≤ ·) where
   total := lt_trichotomy_rec (fun h ↦ Or.inl h.le) (fun h ↦ Or.inl h.le) fun h ↦ Or.inr h.le
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.total_le : @Std.Total (Colex (Π₀ i, α i)) (· ≤ ·) :=
   Lex.total_le (ι := ιᵒᵈ)
 
@@ -161,6 +164,7 @@ instance Lex.decidableLE : DecidableLE (Lex (Π₀ i, α i)) :=
     fun h ↦ isFalse fun h' ↦ lt_irrefl _ (h.trans_le h')
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The less-or-equal relation for the colexicographic ordering is decidable. -/
 instance Colex.decidableLE : DecidableLE (Colex (Π₀ i, α i)) :=
   Lex.decidableLE (ι := ιᵒᵈ)
@@ -172,6 +176,7 @@ instance Lex.decidableLT : DecidableLT (Lex (Π₀ i, α i)) :=
   lt_trichotomy_rec (fun h ↦ isTrue h) (fun h ↦ isFalse h.not_lt) fun h ↦ isFalse h.asymm
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The less-than relation for the colexicographic ordering is decidable. -/
 instance Colex.decidableLT : DecidableLT (Colex (Π₀ i, α i)) :=
   Lex.decidableLT (ι := ιᵒᵈ)
@@ -201,6 +206,7 @@ theorem toLex_monotone : Monotone (@toLex (Π₀ i, α i)) := by
     (h _).lt_of_ne (mem_neLocus.1 <| Finset.min'_mem _ _)⟩
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toColex_monotone : Monotone (@toColex (Π₀ i, α i)) :=
   toLex_monotone (ι := ιᵒᵈ)
 
@@ -224,6 +230,7 @@ instance Lex.addLeftStrictMono : AddLeftStrictMono (Lex (Π₀ i, α i)) :=
   ⟨fun _ _ _ ⟨a, lta, ha⟩ ↦ ⟨a, fun j ja ↦ congr_arg _ (lta j ja), by dsimp; gcongr⟩⟩
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.addLeftStrictMono : AddLeftStrictMono (Colex (Π₀ i, α i)) :=
   Lex.addLeftStrictMono (ι := ιᵒᵈ)
 
@@ -232,6 +239,7 @@ instance Lex.addLeftMono : AddLeftMono (Lex (Π₀ i, α i)) :=
   addLeftMono_of_addLeftStrictMono _
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.addLeftMono : AddLeftMono (Colex (Π₀ i, α i)) :=
   Lex.addLeftMono (ι := ιᵒᵈ)
 
@@ -247,14 +255,17 @@ instance Lex.addRightStrictMono : AddRightStrictMono (Lex (Π₀ i, α i)) :=
     ⟨a, fun j ja ↦ congr_arg (· + ofLex f j) (lta j ja), by dsimp; gcongr⟩⟩
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.addRightStrictMono : AddRightStrictMono (Colex (Π₀ i, α i)) :=
   Lex.addRightStrictMono (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Lex.addRightMono : AddRightMono (Lex (Π₀ i, α i)) :=
   addRightMono_of_addRightStrictMono _
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.addRightMono : AddRightMono (Colex (Π₀ i, α i)) :=
   Lex.addRightMono (ι := ιᵒᵈ)
 
@@ -295,6 +306,7 @@ instance Lex.isOrderedCancelAddMonoid [∀ i, AddCommMonoid (α i)] [∀ i, Part
   le_of_add_le_add_left _ _ _ := le_of_add_le_add_left (α := Lex (∀ i, α i))
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.isOrderedCancelAddMonoid [∀ i, AddCommMonoid (α i)] [∀ i, PartialOrder (α i)]
     [∀ i, IsOrderedCancelAddMonoid (α i)] :
     IsOrderedCancelAddMonoid (Colex (Π₀ i, α i)) :=
@@ -306,6 +318,7 @@ instance Lex.isOrderedAddMonoid [∀ i, AddCommGroup (α i)] [∀ i, PartialOrde
   add_le_add_left _ _ := add_le_add_left
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.isOrderedAddMonoid [∀ i, AddCommGroup (α i)] [∀ i, PartialOrder (α i)]
     [∀ i, IsOrderedAddMonoid (α i)] :
     IsOrderedAddMonoid (Colex (Π₀ i, α i)) :=
diff --git a/mathlib4/Mathlib/Data/DFinsupp/WellFounded.lean b/mathlib4/Mathlib/Data/DFinsupp/WellFounded.lean
index 343b3729c..5393d2397 100644
--- a/mathlib4/Mathlib/Data/DFinsupp/WellFounded.lean
+++ b/mathlib4/Mathlib/Data/DFinsupp/WellFounded.lean
@@ -175,6 +175,7 @@ instance Lex.wellFoundedLT [LT ι] [@Std.Trichotomous ι (· < ·)] [hι : WellF
   ⟨Lex.wellFounded' (fun _ _ => not_lt_zero) (fun i => (hα i).wf) hι.wf⟩
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.wellFoundedLT [LT ι] [@Std.Trichotomous ι (· < ·)] [WellFoundedLT ι]
     [∀ i, AddMonoid (α i)] [∀ i, PartialOrder (α i)] [∀ i, IsBotZeroClass (α i)]
     [∀ i, WellFoundedLT (α i)] :
@@ -201,6 +202,7 @@ instance Pi.Lex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
   ⟨Pi.Lex.wellFounded (· < ·) fun i => (hwf i).1⟩
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Pi.Colex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Colex (∀ i, α i)) :=
   Pi.Lex.wellFoundedLT (ι := ιᵒᵈ)
@@ -219,6 +221,7 @@ instance DFinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀
   ⟨DFinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance DFinsupp.Colex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
     [∀ i, LT (α i)] [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Colex (Π₀ i, α i)) :=
   DFinsupp.Lex.wellFoundedLT_of_finite (ι := ιᵒᵈ)
diff --git a/mathlib4/Mathlib/Data/Finset/Defs.lean b/mathlib4/Mathlib/Data/Finset/Defs.lean
index e231d7f8b..f8b08ffd5 100644
--- a/mathlib4/Mathlib/Data/Finset/Defs.lean
+++ b/mathlib4/Mathlib/Data/Finset/Defs.lean
@@ -318,6 +318,7 @@ section DecidablePiExists
 variable {s : Finset α}
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance decidableDforallFinset {p : ∀ a ∈ s, Prop} [_hp : ∀ (a) (h : a ∈ s), Decidable (p a h)] :
     Decidable (∀ (a) (h : a ∈ s), p a h) :=
   Multiset.decidableDforallMultiset
@@ -335,6 +336,7 @@ instance instDecidableLT [DecidableEq α] : DecidableLT (Finset α) :=
   instDecidableRelSSubset
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance decidableDExistsFinset {p : ∀ a ∈ s, Prop} [_hp : ∀ (a) (h : a ∈ s), Decidable (p a h)] :
     Decidable (∃ (a : _) (h : a ∈ s), p a h) :=
   Multiset.decidableDexistsMultiset
diff --git a/mathlib4/Mathlib/Data/Finset/Image.lean b/mathlib4/Mathlib/Data/Finset/Image.lean
index 1d13014ff..b8beabb28 100644
--- a/mathlib4/Mathlib/Data/Finset/Image.lean
+++ b/mathlib4/Mathlib/Data/Finset/Image.lean
@@ -179,6 +179,7 @@ lemma map_filter' (p : α → Prop) [DecidablePred p] (f : α ↪ β) (s : Finse
   simp [filter_map]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma filter_attach' [DecidableEq α] (s : Finset α) (p : s → Prop) [DecidablePred p] :
     s.attach.filter p =
       (s.filter fun x => ∃ h, p ⟨x, h⟩).attach.map
diff --git a/mathlib4/Mathlib/Data/Matrix/Mul.lean b/mathlib4/Mathlib/Data/Matrix/Mul.lean
index 35e734e21..9092607f7 100644
--- a/mathlib4/Mathlib/Data/Matrix/Mul.lean
+++ b/mathlib4/Mathlib/Data/Matrix/Mul.lean
@@ -602,7 +602,7 @@ theorem RingEquiv.isStablyFiniteRing_iff [EquivLike F R S] [RingEquivClass F R S
 
 instance (priority := low) [SetLike F R] [SubsemiringClass F R] (S : F) [IsStablyFiniteRing R] :
     IsStablyFiniteRing S :=
-  .of_injective _ (Subsemiring.subtype_injective <| .ofClass S)
+  .of_injective _ (SubsemiringClass.subtype_injective S)
 
 end IsStablyFiniteRing
 
diff --git a/mathlib4/Mathlib/Data/Nat/Cast/SetInterval.lean b/mathlib4/Mathlib/Data/Nat/Cast/SetInterval.lean
index fa1e67e5c..960524a45 100644
--- a/mathlib4/Mathlib/Data/Nat/Cast/SetInterval.lean
+++ b/mathlib4/Mathlib/Data/Nat/Cast/SetInterval.lean
@@ -26,7 +26,7 @@ namespace Nat
 
 @[simp]
 theorem range_cast_int : range ((↑) : ℕ → ℤ) = Ici 0 :=
-  Subset.antisymm (range_subset_iff.2 Int.natCast_nonneg) CanLift.prf
+  Subset.antisymm (range_subset_iff.2 Int.natCast_nonneg) (by intro x; simpa using CanLift.prf x)
 
 theorem image_cast_int_Icc (a b : ℕ) : (↑) '' Icc a b = Icc (a : ℤ) b :=
   (castOrderEmbedding (α := ℤ)).image_Icc (by simp [ordConnected_Ici]) a b
diff --git a/mathlib4/Mathlib/Data/PFun.lean b/mathlib4/Mathlib/Data/PFun.lean
index aa1790226..42be7fb7e 100644
--- a/mathlib4/Mathlib/Data/PFun.lean
+++ b/mathlib4/Mathlib/Data/PFun.lean
@@ -58,6 +58,9 @@ open Function
 
 /-- `PFun α β`, or `α →. β`, is the type of partial functions from
   `α` to `β`. It is defined as `α → Part β`. -/
+-- `#check (fun _ => 1 : ℕ →. ℕ)` yields `ℕ → Part ℕ` and this leads to trouble down the line with
+--  `({fun _ => 1} : Set (ℕ →. ℕ))` if `PFun` is not sufficiently reducible.
+@[instance_reducible]
 def PFun (α β : Type*) :=
   α → Part β
 
diff --git a/mathlib4/Mathlib/Data/Vector3.lean b/mathlib4/Mathlib/Data/Vector3.lean
index 3447f55f9..e60524ecf 100644
--- a/mathlib4/Mathlib/Data/Vector3.lean
+++ b/mathlib4/Mathlib/Data/Vector3.lean
@@ -26,6 +26,7 @@ universe u
 variable {α : Type*} {m n : ℕ}
 
 /-- Alternate definition of `Vector` based on `Fin2`. -/
+@[instance_reducible]
 def Vector3 (α : Type u) (n : ℕ) : Type u :=
   Fin2 n → α
 
diff --git a/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean b/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
index 50417b47d..66f801461 100644
--- a/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
+++ b/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
@@ -63,6 +63,7 @@ theorem aeval_toPolynomialAdjoinImageCompl_eq_zero
   simp_rw [toPolynomialAdjoinImageCompl, ← AlgEquiv.coe_toAlgHom, ← AlgHom.comp_apply]
   congr; ext; aesop (add simp optionEquivLeft_X_some) (add simp optionEquivLeft_X_none)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem irreducible_toPolynomialAdjoinImageCompl {F : MvPolynomial ι k} (hF : Irreducible F) (i : ι)
     (H : AlgebraicIndependent k fun x : {j | j ≠ i} ↦ a x) :
     Irreducible (toPolynomialAdjoinImageCompl F a i) := by
diff --git a/mathlib4/Mathlib/Geometry/Manifold/IsManifold/Basic.lean b/mathlib4/Mathlib/Geometry/Manifold/IsManifold/Basic.lean
index 8e1ea40bb..ed7d8f76d 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/IsManifold/Basic.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/IsManifold/Basic.lean
@@ -741,6 +741,7 @@ theorem symm_trans_mem_contDiffGroupoid (e : OpenPartialHomeomorph M H) :
 variable {E' H' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E'] [TopologicalSpace H']
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The product of two `C^n` open partial homeomorphisms is `C^n`. -/
 theorem contDiffGroupoid_prod {I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'}
     {e : OpenPartialHomeomorph H H} {e' : OpenPartialHomeomorph H' H'}
@@ -945,6 +946,7 @@ variable {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E'] {H' : Type*}
   {M' : Type*} [TopologicalSpace M'] [ChartedSpace H' M']
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma mem_maximalAtlas_prod [IsManifold I n M] [IsManifold I' n M']
     {e : OpenPartialHomeomorph M H} (he : e ∈ maximalAtlas I n M)
     {e' : OpenPartialHomeomorph M' H'} (he' : e' ∈ maximalAtlas I' n M') :
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
index adef040c3..5fb73f38e 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
@@ -53,6 +53,7 @@ variable (I)
 
 /-! #### Model with corners -/
 
+set_option backward.isDefEq.respectTransparency.types false in
 protected theorem hasMFDerivAt {x} : HasMFDerivAt I 𝓘(𝕜, E) I x (ContinuousLinearMap.id _ _) :=
   ⟨I.continuousAt, (hasFDerivWithinAt_id _ _).congr' I.rightInvOn (mem_range_self _)⟩
 
@@ -71,6 +72,7 @@ protected theorem mdifferentiableOn {s} : MDiff[s] I := fun _ _ =>
 
 protected theorem mdifferentiable : MDiff I := fun _ => I.mdifferentiableAt
 
+set_option backward.isDefEq.respectTransparency.types false in
 theorem hasMFDerivWithinAt_symm {x} (hx : x ∈ range I) :
     HasMFDerivWithinAt 𝓘(𝕜, E) I I.symm (range I) x (ContinuousLinearMap.id _ _) :=
   ⟨I.continuousWithinAt_symm,
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Basic.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
index fd47f4d3d..20d7bc0c9 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
@@ -561,11 +561,13 @@ theorem mdifferentiableAt_of_isInvertible_mfderiv (hf : (mfderiv% f x).IsInverti
     MDiffAt f x :=
   mdifferentiableAt_of_mfderiv_injective hf.injective
 
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem HasMFDerivWithinAt.mono (h : HasMFDerivAt[t] f x f') (hst : s ⊆ t) :
     HasMFDerivAt[s] f x f' :=
   ⟨ContinuousWithinAt.mono h.1 hst,
     HasFDerivWithinAt.mono h.2 (inter_subset_inter (preimage_mono hst) (Subset.refl _))⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem HasMFDerivAt.hasMFDerivWithinAt (h : HasMFDerivAt% f x f') : HasMFDerivAt[s] f x f' :=
   ⟨ContinuousAt.continuousWithinAt h.1, HasFDerivWithinAt.mono h.2 inter_subset_right⟩
 
@@ -599,6 +601,7 @@ theorem hasMFDerivWithinAt_inter (h : t ∈ 𝓝 x) :
     continuousWithinAt_inter h]
   exact extChartAt_preimage_mem_nhds h
 
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem HasMFDerivWithinAt.union (hs : HasMFDerivAt[s] f x f') (ht : HasMFDerivAt[t] f x f') :
     HasMFDerivAt[s ∪ t] f x f' := by
   constructor
@@ -858,6 +861,7 @@ theorem preimage_extChartAt_eventuallyEq_compl_singleton (y : M) (h : s =ᶠ[
 
 /-! ### Congruence lemmas for derivatives on manifolds -/
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- If two sets coincide locally, except maybe at a point, then it is equivalent to have a manifold
 derivative within one or the other. -/
 theorem hasMFDerivWithinAt_congr_set' (y : M) (h : s =ᶠ[𝓝[{y}ᶜ] x] t) :
@@ -918,6 +922,7 @@ theorem HasMFDerivWithinAt.congr_mfderiv (h : HasMFDerivAt[s] f x f') (h' : f' =
     HasMFDerivAt[s] f x f₁' :=
   h' ▸ h
 
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem HasMFDerivWithinAt.congr_of_eventuallyEq
     (h : HasMFDerivAt[s] f x f') (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) :
     HasMFDerivAt[s] f₁ x f' := by
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Defs.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Defs.lean
index 8ff76e4c1..bee59ca37 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Defs.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Defs.lean
@@ -283,6 +283,7 @@ variable (I I') in
 def OpenPartialHomeomorph.MDifferentiable (f : OpenPartialHomeomorph M M') :=
   MDifferentiableOn I I' f f.source ∧ MDifferentiableOn I' I f.symm f.target
 
+set_option backward.isDefEq.respectTransparency.instances false in
 variable (I I') in
 /-- `HasMFDerivWithinAt I I' f s x f'` indicates that the function `f` between manifolds
 has, at the point `x` and within the set `s`, the derivative `f'`. Here, `f'` is a continuous linear
@@ -301,6 +302,7 @@ def HasMFDerivWithinAt (f : M → M') (s : Set M) (x : M)
     HasFDerivWithinAt (writtenInExtChartAt I I' x f : E → E') f'
       ((extChartAt I x).symm ⁻¹' s ∩ range I) ((extChartAt I x) x)
 
+set_option backward.isDefEq.respectTransparency.instances false in
 variable (I I') in
 /-- `HasMFDerivAt I I' f x f'` indicates that the function `f` between manifolds
 has, at the point `x`, the derivative `f'`. Here, `f'` is a continuous linear
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
index a3ba6c2a7..2bb7d248c 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
@@ -125,6 +125,7 @@ section id
 
 /-! #### Identity -/
 
+set_option backward.isDefEq.respectTransparency.types false in
 theorem hasMFDerivAt_id (x : M) :
     HasMFDerivAt% (@id M) x (ContinuousLinearMap.id 𝕜 (TangentSpace% x)) := by
   refine ⟨continuousAt_id, ?_⟩
@@ -662,6 +663,7 @@ lemma writtenInExtChartAt_sumSwap_eventuallyEq_id :
       refine ⟨I.continuousWithinAt_symm.preimage_mem_nhdsWithin ?_, self_mem_nhdsWithin⟩
       exact (chartAt H x).open_target.mem_nhds (by simp)
 
+set_option backward.isDefEq.respectTransparency.types false in
 theorem hasMFDerivAt_sumSwap :
     HasMFDerivAt% (@Sum.swap M M') p (ContinuousLinearMap.id 𝕜 (TangentSpace% p)) := by
   refine ⟨by fun_prop, ?_⟩
@@ -706,6 +708,7 @@ lemma writtenInExtChartAt_sumInr_eventuallyEq_id :
     Sum.inr_injective.extend_apply <| chartAt H q',
     (chartAt H q').right_inv (by simpa [Set.mem_preimage, I.left_inv] using hyT)]
 
+set_option backward.isDefEq.respectTransparency.types false in
 theorem hasMFDerivWithinAt_inl :
     HasMFDerivAt[s] (@Sum.inl M M') q (ContinuousLinearMap.id 𝕜 (TangentSpace% q)) := by
   refine ⟨by fun_prop, ?_⟩
@@ -720,6 +723,7 @@ theorem hasMFDerivAt_inl :
     HasMFDerivAt% (@Sum.inl M M') q (ContinuousLinearMap.id 𝕜 (TangentSpace% p)) := by
   simpa [HasMFDerivAt, hasMFDerivWithinAt_univ] using! hasMFDerivWithinAt_inl (s := Set.univ)
 
+set_option backward.isDefEq.respectTransparency.types false in
 theorem hasMFDerivWithinAt_inr {t : Set M'} :
     HasMFDerivAt[t] (@Sum.inr M M') q' (ContinuousLinearMap.id 𝕜 (TangentSpace% q')) := by
   refine ⟨by fun_prop, ?_⟩
diff --git a/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean b/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
index 1d2881f43..569932730 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
@@ -240,6 +240,7 @@ theorem mem_chart_source_iff (p q : TM) :
   simp only [FiberBundle.chartedSpace_chartAt, mfld_simps]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp, mfld_simps]
 theorem mem_chart_target_iff (p : H × E) (q : TM) :
     p ∈ (chartAt (ModelProd H E) q).target ↔ p.1 ∈ (chartAt H q.1).target := by
diff --git a/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean b/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
index 745a3c0c6..220472da0 100644
--- a/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
+++ b/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@@ -440,12 +440,16 @@ lemma stalkMap_inv_hom_apply (e : X ≅ Y) (x : X) (y) :
       X.presheaf.stalkSpecializes (specializes_of_eq <| by simp) y :=
   DFunLike.congr_fun (CommRingCat.hom_ext_iff.mp (stalkMap_inv_hom e x)) y
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp)]
 lemma stalkMap_germ (U : Opens Y) (x : X) (hx : f.base x ∈ U) :
     Y.presheaf.germ U (f.base x) hx ≫ f.stalkMap x =
       f.c.app (op U) ≫ X.presheaf.germ ((Opens.map f.base).obj U) x hx :=
   PresheafedSpace.stalkMap_germ f.toHom U x hx
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma stalkMap_germ_apply (U : Opens Y) (x : X) (hx : f.base x ∈ U) (y) :
     f.stalkMap x (Y.presheaf.germ U (f.base x) hx y) =
       X.presheaf.germ ((Opens.map f.base).obj U) x hx (f.c.app (op U) y) :=
diff --git a/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean b/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
index c013865e9..aecece40c 100644
--- a/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
+++ b/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
@@ -73,12 +73,15 @@ def Γevaluation (x : X) : X.presheaf.obj (op ⊤) ⟶ X.residueField x :=
   X.evaluation ⟨x, show x ∈ ⊤ from trivial⟩
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma evaluation_eq_zero_iff_notMem_basicOpen (x : U) (f : X.presheaf.obj (op U)) :
     X.evaluation x f = 0 ↔ x.val ∉ X.toRingedSpace.basicOpen f := by
   rw [X.toRingedSpace.mem_basicOpen f x.1 x.2, ← not_iff_not, not_not]
   exact (IsLocalRing.residue_ne_zero_iff_isUnit _)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma evaluation_ne_zero_iff_mem_basicOpen (x : U) (f : X.presheaf.obj (op U)) :
     X.evaluation x f ≠ 0 ↔ x.val ∈ X.toRingedSpace.basicOpen f := by
   simp
@@ -89,11 +92,15 @@ lemma basicOpen_eq_bot_iff_forall_evaluation_eq_zero (f : X.presheaf.obj (op U))
   exact ⟨fun h ↦ h ▸ fun a _ hc ↦ hc,
     fun h ↦ eq_bot_iff.mpr <| fun a ha ↦ h a (X.toRingedSpace.basicOpen_le f ha) ha⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma Γevaluation_eq_zero_iff_notMem_basicOpen (x : X) (f : X.presheaf.obj (op ⊤)) :
     X.Γevaluation x f = 0 ↔ x ∉ X.toRingedSpace.basicOpen f :=
   evaluation_eq_zero_iff_notMem_basicOpen X ⟨x, show x ∈ ⊤ by trivial⟩ f
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Γevaluation_ne_zero_iff_mem_basicOpen (x : X) (f : X.presheaf.obj (op ⊤)) :
     X.Γevaluation x f ≠ 0 ↔ x ∈ X.toRingedSpace.basicOpen f :=
   evaluation_ne_zero_iff_mem_basicOpen X ⟨x, show x ∈ ⊤ by trivial⟩ f
diff --git a/mathlib4/Mathlib/GroupTheory/PresentedGroup.lean b/mathlib4/Mathlib/GroupTheory/PresentedGroup.lean
index f02de660f..ddb70af74 100644
--- a/mathlib4/Mathlib/GroupTheory/PresentedGroup.lean
+++ b/mathlib4/Mathlib/GroupTheory/PresentedGroup.lean
@@ -107,8 +107,7 @@ theorem generated_by (rels : Set (FreeGroup α)) (H : Subgroup (PresentedGroup r
   · exact h _
   · exact (Subgroup.inv_mem_iff H).mpr (by assumption)
   rename_i h1 h2
-  change QuotientGroup.mk _ ∈ H.carrier
-  rw [QuotientGroup.mk_mul]
+  -- This is defeq abuse.
   exact Subgroup.mul_mem _ h1 h2
 
 section ToGroup
diff --git a/mathlib4/Mathlib/GroupTheory/SpecificGroups/ZGroup.lean b/mathlib4/Mathlib/GroupTheory/SpecificGroups/ZGroup.lean
index cf1257ee3..d8be11bc7 100644
--- a/mathlib4/Mathlib/GroupTheory/SpecificGroups/ZGroup.lean
+++ b/mathlib4/Mathlib/GroupTheory/SpecificGroups/ZGroup.lean
@@ -72,6 +72,9 @@ theorem of_injective [hG' : IsZGroup G'] (hf : Function.Injective f) : IsZGroup
 
 instance [IsZGroup G] (H : Subgroup G) : IsZGroup H := of_injective H.subtype_injective
 
+-- Needs to unfold `Sylow.mapSurjective`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem of_surjective [Finite G] [hG : IsZGroup G] (hf : Function.Surjective f) : IsZGroup G' := by
   rw [isZGroup_iff] at hG ⊢
   intro p hp P
@@ -246,6 +249,8 @@ theorem le_center_or_le_commutator [P.Normal] : P ≤ Subgroup.center G ∨ P 
   · rw [← h, commutator_def]
     exact Subgroup.commutator_mono le_top le_top
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A cyclic Sylow subgroup is either central in its normalizer or contained in the commutator
   subgroup. -/
 theorem normalizer_le_centralizer_or_le_commutator :
diff --git a/mathlib4/Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean b/mathlib4/Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
index 62d08038e..bed184bc7 100644
--- a/mathlib4/Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@@ -74,6 +74,8 @@ theorem borel_eq_generateFrom_Iio : borel α = .generateFrom (range Iio) := by
     intro a
     exact GenerateMeasurable.basic _ isOpen_Iio
 
+-- Applying an instance about `α` to `αᵒᵈ`.
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem borel_eq_generateFrom_Ioi : borel α = .generateFrom (range Ioi) :=
   @borel_eq_generateFrom_Iio αᵒᵈ _ (by infer_instance : SecondCountableTopology α) _ _
 
diff --git a/mathlib4/Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean b/mathlib4/Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
index 9e37588ae..0d10dc6af 100644
--- a/mathlib4/Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
+++ b/mathlib4/Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
@@ -402,6 +402,8 @@ theorem logEmbeddingQuot_apply (x : (𝓞 K)ˣ) :
     logEmbeddingQuot K (Additive.ofMul (QuotientGroup.mk x)) =
       logEmbedding K (Additive.ofMul x) := rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem logEmbeddingQuot_injective :
     Function.Injective (logEmbeddingQuot K) := by
   unfold logEmbeddingQuot
diff --git a/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean b/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
index 641d6ab71..cdd182a69 100644
--- a/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
+++ b/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
@@ -36,6 +36,7 @@ variable {p : ℕ} [Fact p.Prime]
 open NNReal WithZero UniformSpace
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 open MonoidWithZeroHom.ValueGroup₀ in
 lemma isUniformInducing_cast_withVal : IsUniformInducing ((Rat.castHom ℚ_[p]).comp
     (WithVal.equiv (Rat.padicValuation p)).toRingHom) := by
diff --git a/mathlib4/Mathlib/Order/Category/FinBoolAlg.lean b/mathlib4/Mathlib/Order/Category/FinBoolAlg.lean
index 92082732f..63fed931b 100644
--- a/mathlib4/Mathlib/Order/Category/FinBoolAlg.lean
+++ b/mathlib4/Mathlib/Order/Category/FinBoolAlg.lean
@@ -59,6 +59,9 @@ instance : Inhabited FinBoolAlg :=
 instance largeCategory : LargeCategory FinBoolAlg :=
   inferInstanceAs <| Category (InducedCategory _ toBoolAlg)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance concreteCategory : ConcreteCategory FinBoolAlg (BoundedLatticeHom · ·) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toBoolAlg) _
 
diff --git a/mathlib4/Mathlib/Order/Category/FinPartOrd.lean b/mathlib4/Mathlib/Order/Category/FinPartOrd.lean
index f44f1fe62..56ad860a3 100644
--- a/mathlib4/Mathlib/Order/Category/FinPartOrd.lean
+++ b/mathlib4/Mathlib/Order/Category/FinPartOrd.lean
@@ -53,6 +53,9 @@ instance : Inhabited FinPartOrd :=
 instance largeCategory : LargeCategory FinPartOrd :=
   inferInstanceAs <| Category (InducedCategory _ toPartOrd)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance concreteCategory : ConcreteCategory FinPartOrd (· →o ·) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toPartOrd) _
 
diff --git a/mathlib4/Mathlib/Order/Category/NonemptyFinLinOrd.lean b/mathlib4/Mathlib/Order/Category/NonemptyFinLinOrd.lean
index 060941774..c3ffd8859 100644
--- a/mathlib4/Mathlib/Order/Category/NonemptyFinLinOrd.lean
+++ b/mathlib4/Mathlib/Order/Category/NonemptyFinLinOrd.lean
@@ -44,6 +44,9 @@ instance : CoeSort NonemptyFinLinOrd (Type _) where
 instance : LargeCategory NonemptyFinLinOrd :=
   inferInstanceAs <| Category (InducedCategory _ toLinOrd)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ConcreteCategory NonemptyFinLinOrd (· →o ·) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toLinOrd) _
 
diff --git a/mathlib4/Mathlib/Order/CompleteLattice/PiLex.lean b/mathlib4/Mathlib/Order/CompleteLattice/PiLex.lean
index df0503f30..85761d47c 100644
--- a/mathlib4/Mathlib/Order/CompleteLattice/PiLex.lean
+++ b/mathlib4/Mathlib/Order/CompleteLattice/PiLex.lean
@@ -111,16 +111,19 @@ instance : InfSet (Colex ((i : ι) → α i)) where
   sInf s := sInf (α := Πₗ i : ιᵒᵈ, α i) s
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem sInf_apply (s : Set (Colex ((i : ι) → α i))) (i : ι) :
     sInf s i = ⨅ e : {e ∈ s | ∀ j > i, e j = sInf s j}, e.1 i :=
   Lex.sInf_apply (ι := ιᵒᵈ) s i
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem sInf_apply_le {s : Set (Colex ((i : ι) → α i))} {i : ι} {e : Colex ((i : ι) → α i)}
     (he : e ∈ s) (h : ∀ j > i, e j = sInf s j) : sInf s i ≤ e i :=
   Lex.sInf_apply_le (ι := ιᵒᵈ) he h
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem le_sInf_apply {s : Set (Colex ((i : ι) → α i))} {i : ι} {e : Colex ((i : ι) → α i)}
     (h : ∀ f ∈ s, (∀ j > i, f j = sInf s j) → e i ≤ f i) : e i ≤ sInf s i :=
   Lex.le_sInf_apply (ι := ιᵒᵈ) h
@@ -133,21 +136,25 @@ instance : SupSet (Colex ((i : ι) → α i)) where
   sSup s := sSup (α := Πₗ i : ιᵒᵈ, α i) s
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem sSup_apply (s : Set (Colex ((i : ι) → α i))) (i : ι) :
     sSup s i = ⨆ e : {e ∈ s | ∀ j > i, e j = sSup s j}, e.1 i :=
   Lex.sSup_apply (ι := ιᵒᵈ) s i
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem le_sSup_apply {s : Set (Colex ((i : ι) → α i))} {i : ι} {e : Colex ((i : ι) → α i)}
     (he : e ∈ s) (h : ∀ j > i, e j = sSup s j) : e i ≤ sSup s i :=
   Lex.le_sSup_apply (ι := ιᵒᵈ) he h
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem sSup_apply_le {s : Set (Colex ((i : ι) → α i))} {i : ι} {e : Colex ((i : ι) → α i)}
     (h : ∀ f ∈ s, (∀ j > i, f j = sSup s j) → f i ≤ e i) : sSup s i ≤ e i :=
   Lex.sSup_apply_le (ι := ιᵒᵈ) h
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance completeLattice : CompleteLattice (Colex ((i : ι) → α i)) where
   isLUB_sSup _ := by exact Lex.isLUB_sSup (ι := ιᵒᵈ)
   isGLB_sInf _ := by exact Lex.isGLB_sInf (ι := ιᵒᵈ)
diff --git a/mathlib4/Mathlib/Order/Interval/Finset/Gaps.lean b/mathlib4/Mathlib/Order/Interval/Finset/Gaps.lean
index b08c7057f..16cdb7a16 100644
--- a/mathlib4/Mathlib/Order/Interval/Finset/Gaps.lean
+++ b/mathlib4/Mathlib/Order/Interval/Finset/Gaps.lean
@@ -94,6 +94,9 @@ theorem intervalGapsWithin_snd_of_lt (hj : j < k) :
   simp only [coe_castPred, val_natCast, Nat.mod_succ_eq_iff_lt]
   lia
 
+-- Defeq abuse: `F.orderEmbOfFin_mem` infers the `LinearOrder (Lex (α × α))` as
+-- `LinearOrder (α × α)`.
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem intervalGapsWithin_mapsTo : (Set.Iio k).MapsTo
     (fun (j : ℕ) ↦ ((F.intervalGapsWithin h a b j).2, (F.intervalGapsWithin h a b j.succ).1))
     F := by
diff --git a/mathlib4/Mathlib/Order/Interval/Set/Defs.lean b/mathlib4/Mathlib/Order/Interval/Set/Defs.lean
index 068a14411..5f91d92c7 100644
--- a/mathlib4/Mathlib/Order/Interval/Set/Defs.lean
+++ b/mathlib4/Mathlib/Order/Interval/Set/Defs.lean
@@ -47,7 +47,7 @@ def Iic (b : α) := { x | x ≤ b }
 @[to_dual] theorem Iic_def (b : α) : { x | x ≤ b } = Iic b := rfl
 
 /-- `Ioo a b` is the left-open right-open interval $(a, b)$. -/
-@[to_dual self (reorder := a b)]
+@[instance_reducible, to_dual self (reorder := a b)]
 def Ioo (a b : α) := { x | a < x ∧ x < b }
 
 to_dual_insert_cast Ioo := by simp only [and_comm]
diff --git a/mathlib4/Mathlib/Order/KrullDimension.lean b/mathlib4/Mathlib/Order/KrullDimension.lean
index 5d637a67b..c6cafd48a 100644
--- a/mathlib4/Mathlib/Order/KrullDimension.lean
+++ b/mathlib4/Mathlib/Order/KrullDimension.lean
@@ -1138,7 +1138,7 @@ lemma coheight_le_of_krullDim_preimage_le (x : α) :
     Order.coheight x ≤ (m + 1) * Order.coheight (f x) + m := by
   rw [Order.coheight, Order.coheight]
   apply height_le_of_krullDim_preimage_le (f := f.dual)
-  exact fun x ↦ le_of_eq_of_le (krullDim_orderDual (α := f ⁻¹' {x})) (h x)
+  exact fun x ↦ le_of_eq_of_le (krullDim_orderDual (α := f ⁻¹' {OrderDual.ofDual x})) (h x)
 
 include f h in
 lemma krullDim_le_of_krullDim_preimage_le :
diff --git a/mathlib4/Mathlib/Order/PiLex.lean b/mathlib4/Mathlib/Order/PiLex.lean
index 1d2a72aec..f952c3280 100644
--- a/mathlib4/Mathlib/Order/PiLex.lean
+++ b/mathlib4/Mathlib/Order/PiLex.lean
@@ -121,6 +121,7 @@ instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
       ⟨N₂, fun j hj => (lt_N₁ _ (hj.trans H)).trans (lt_N₂ _ hj), (lt_N₁ _ H).symm ▸ b_lt_c⟩]
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
     IsStrictOrder (Colex (∀ i, β i)) (· < ·) :=
   Lex.isStrictOrder (ι := ιᵒᵈ)
@@ -138,6 +139,7 @@ noncomputable instance Lex.linearOrder [LinearOrder ι] [WellFoundedLT ι]
     { trichotomous := (trichotomous_lex _ _ IsWellFounded.wf).1 } (Classical.decRel _)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `Colex (∀ i, α i)` is a linear order if the original order has well-founded `>`. -/
 noncomputable instance Colex.linearOrder [LinearOrder ι] [WellFoundedGT ι]
     [∀ a, LinearOrder (β a)] : LinearOrder (Colex (∀ i, β i)) :=
@@ -216,29 +218,35 @@ section Colex
 variable [WellFoundedGT ι]
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toColex_monotone : Monotone (@toColex (∀ i, β i)) :=
   toLex_monotone (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toColex_strictMono : StrictMono (@toColex (∀ i, β i)) :=
   toLex_strictMono (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem lt_toColex_update_self_iff : toColex x < toColex (update x i a) ↔ x i < a :=
   lt_toLex_update_self_iff (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toColex_update_lt_self_iff : toColex (update x i a) < toColex x ↔ a < x i :=
   toLex_update_lt_self_iff (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem le_toColex_update_self_iff : toColex x ≤ toColex (update x i a) ↔ x i ≤ a :=
   le_toLex_update_self_iff (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toColex_update_le_self_iff : toColex (update x i a) ≤ toColex x ↔ a ≤ x i :=
   toLex_update_le_self_iff (ι := ιᵒᵈ)
@@ -328,6 +336,7 @@ theorem Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (
       (Function.update_of_ne hj.ne b a).symm, by rwa [Function.update_self i b]⟩⟩
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Colex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
     NoMaxOrder (Colex (∀ i, β i)) :=
   Lex.noMaxOrder' (ι := ιᵒᵈ) i
diff --git a/mathlib4/Mathlib/Order/RelIso/Set.lean b/mathlib4/Mathlib/Order/RelIso/Set.lean
index 69aea6ed9..14c1110ec 100644
--- a/mathlib4/Mathlib/Order/RelIso/Set.lean
+++ b/mathlib4/Mathlib/Order/RelIso/Set.lean
@@ -35,6 +35,9 @@ theorem map_inf [SemilatticeInf α] [LinearOrder β] [FunLike F β α]
     a (m ⊓ n) = a m ⊓ a n :=
   (StrictMono.monotone fun _ _ => map_rel a).map_inf m n
 
+-- Defeq abuse: should mediate between `β` and `βᵒᵈ` explicitly
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem map_sup [SemilatticeSup α] [LinearOrder β] [FunLike F β α]
     [RelHomClass F (· > ·) (· > ·)] (a : F) (m n : β) :
     a (m ⊔ n) = a m ⊔ a n :=
diff --git a/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean b/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
index 82d54b8d6..6215a8180 100644
--- a/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
+++ b/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
@@ -141,7 +141,9 @@ lemma IsGaussian.charFun_eq' [IsGaussian μ] (t : E) :
   · exact IsGaussian.integrable_id
   · exact IsGaussian.memLp_two_id
 
+-- See comment on `ProbabilityTheory.covarianceBilin`.
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The measure `μ` is Gaussian if and only if there
 exist `m : E` and `f : E →L[ℝ]  E →L[ℝ] ℝ`
 satisfying `f.toBilinForm.IsPosSemidef` and `charFun μ t = exp (⟪t, m⟫ * I - f t t / 2)`. -/
@@ -163,7 +165,9 @@ lemma isGaussian_iff_gaussian_charFun [IsFiniteMeasure μ] :
   · simp [charFun_eq_charFunDual_toDualMap, h, -InnerProductSpace.toContinuousLinearMap_toDualMap]
   · simp [← charFun_toDual_symm_eq_charFunDual, h]
 
+-- See comment on `ProbabilityTheory.covarianceBilin`.
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If the characteristic function of `μ` takes the form of a gaussian characteristic function,
 then the parameters have to be the expectation and the covariance bilinear form. -/
 lemma gaussian_charFun_congr [IsFiniteMeasure μ] (m : E) (f : E →L[ℝ] E →L[ℝ] ℝ)
diff --git a/mathlib4/Mathlib/Probability/Moments/CovarianceBilin.lean b/mathlib4/Mathlib/Probability/Moments/CovarianceBilin.lean
index a3271bda1..4bd5aa894 100644
--- a/mathlib4/Mathlib/Probability/Moments/CovarianceBilin.lean
+++ b/mathlib4/Mathlib/Probability/Moments/CovarianceBilin.lean
@@ -45,6 +45,12 @@ namespace ProbabilityTheory
 variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
   [MeasurableSpace E] [BorelSpace E] {μ : Measure E}
 
+-- This requires `RingHomCompTriple (starRingEnd ℝ) (RingHom.id ℝ) (RingHom.id ℝ)`, but the instance
+-- `RingHomCompTriple.right_ids` forces it to be
+-- `RingHomCompTriple (starRingEnd ℝ) (RingHom.id ℝ) (starRingEnd ℝ)`, but the third parameter is
+-- an `outParam` so we can't just add the missing instance for `TrivialStar R`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Covariance of a measure on an inner product space, as a continuous bilinear form. -/
 noncomputable
 def covarianceBilin (μ : Measure E) : E →L[ℝ] E →L[ℝ] ℝ :=
@@ -184,6 +190,9 @@ section covarianceOperator
 
 variable [CompleteSpace E]
 
+-- See comment on `ProbabilityTheory.covarianceBilin`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The covariance operator of the measure `μ`. This is the bounded operator `F : E →L[ℝ] E`
 associated to the continuous bilinear form `B : E →L[ℝ] E →L[ℝ] ℝ` such that
 `B x y = ∫ z, ⟪x, z⟫ * ⟪y, z⟫ ∂μ` (see `covarianceOperator_inner`). Namely we have
diff --git a/mathlib4/Mathlib/RepresentationTheory/Basic.lean b/mathlib4/Mathlib/RepresentationTheory/Basic.lean
index a0d2d91c6..7713722e9 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Basic.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Basic.lean
@@ -737,6 +737,7 @@ lemma free_single_single (g h : G) (i : α) (r : k) :
 variable (k G) (α : Type*)
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The free `k[G]`-module on a type `α` is isomorphic to the representation `free k G α`. -/
 noncomputable def finsuppLEquivFreeAsModule : (α →₀ k[G]) ≃ₗ[k[G]] (free k G α).asModule where
   toAddEquiv := (asModuleEquiv _).symm.toAddEquiv
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
index c82388589..8178f55ce 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
@@ -559,6 +559,8 @@ def cocyclesOfIsCocycle₁ {f : G → A} (hf : IsCocycle₁ f) :
     cocycles₁ (Rep.ofDistribMulAction k G A) :=
   ⟨f, (mem_cocycles₁_iff (A := Rep.ofDistribMulAction k G A) f).2 hf⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCocycle₁_of_mem_cocycles₁
     (f : G → A) (hf : f ∈ cocycles₁ (Rep.ofDistribMulAction k G A)) :
     IsCocycle₁ f :=
@@ -572,6 +574,8 @@ def coboundariesOfIsCoboundary₁ {f : G → A} (hf : IsCoboundary₁ f) :
     coboundaries₁ (Rep.ofDistribMulAction k G A) :=
   ⟨f, hf.choose, funext hf.choose_spec⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCoboundary₁_of_mem_coboundaries₁
     (f : G → A) (hf : f ∈ coboundaries₁ (Rep.ofDistribMulAction k G A)) :
     IsCoboundary₁ f := by
@@ -586,6 +590,8 @@ def cocyclesOfIsCocycle₂ {f : G × G → A} (hf : IsCocycle₂ f) :
     cocycles₂ (Rep.ofDistribMulAction k G A) :=
   ⟨f, (mem_cocycles₂_iff (A := Rep.ofDistribMulAction k G A) f).2 hf⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCocycle₂_of_mem_cocycles₂
     (f : G × G → A) (hf : f ∈ cocycles₂ (Rep.ofDistribMulAction k G A)) :
     IsCocycle₂ f := (mem_cocycles₂_iff (A := Rep.ofDistribMulAction k G A) f).1 hf
@@ -598,6 +604,8 @@ def coboundariesOfIsCoboundary₂ {f : G × G → A} (hf : IsCoboundary₂ f) :
     coboundaries₂ (Rep.ofDistribMulAction k G A) :=
   ⟨f, hf.choose,funext fun g ↦ hf.choose_spec g.1 g.2⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCoboundary₂_of_mem_coboundaries₂
     (f : G × G → A) (hf : f ∈ coboundaries₂ (Rep.ofDistribMulAction k G A)) :
     IsCoboundary₂ f := by
@@ -691,6 +699,8 @@ def cocyclesOfIsMulCocycle₁ {f : G → M} (hf : IsMulCocycle₁ f) :
     cocycles₁ (Rep.ofMulDistribMulAction G M) :=
   ⟨Additive.ofMul ∘ f, (mem_cocycles₁_iff (A := Rep.ofMulDistribMulAction G M) f).2 hf⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isMulCocycle₁_of_mem_cocycles₁
     (f : G → M) (hf : f ∈ cocycles₁ (Rep.ofMulDistribMulAction G M)) :
     IsMulCocycle₁ (Additive.toMul ∘ f) :=
@@ -704,6 +714,8 @@ def coboundariesOfIsMulCoboundary₁ {f : G → M} (hf : IsMulCoboundary₁ f) :
     coboundaries₁ (Rep.ofMulDistribMulAction G M) :=
   ⟨Additive.ofMul ∘ f, hf.choose, funext hf.choose_spec⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isMulCoboundary₁_of_mem_coboundaries₁
     (f : G → M) (hf : f ∈ coboundaries₁ (Rep.ofMulDistribMulAction G M)) :
     IsMulCoboundary₁ (M := M) (Additive.ofMul ∘ f) := by
@@ -718,6 +730,8 @@ def cocyclesOfIsMulCocycle₂ {f : G × G → M} (hf : IsMulCocycle₂ f) :
     cocycles₂ (Rep.ofMulDistribMulAction G M) :=
   ⟨Additive.ofMul ∘ f, (mem_cocycles₂_iff (A := Rep.ofMulDistribMulAction G M) f).2 hf⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isMulCocycle₂_of_mem_cocycles₂
     (f : G × G → M) (hf : f ∈ cocycles₂ (Rep.ofMulDistribMulAction G M)) :
     IsMulCocycle₂ (Additive.toMul ∘ f) :=
@@ -730,6 +744,8 @@ def coboundariesOfIsMulCoboundary₂ {f : G × G → M} (hf : IsMulCoboundary₂
     coboundaries₂ (Rep.ofMulDistribMulAction G M) :=
   ⟨Additive.ofMul ∘ f, hf.choose, funext fun g ↦ hf.choose_spec g.1 g.2⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isMulCoboundary₂_of_mem_coboundaries₂
     (f : G × G → M) (hf : f ∈ coboundaries₂ (Rep.ofMulDistribMulAction G M)) :
     IsMulCoboundary₂ (M := M) (Additive.toMul ∘ f) := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
index 63cc8f3ef..7fe22bb51 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
@@ -617,6 +617,7 @@ and `Y - ∑ aᵢ·sᵢ` is a cycle. -/
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a `G`-representation `A` and a normal subgroup `S ≤ G`, the degree 1
 corestriction-coinflation sequence `H₁(S, A) ⟶ H₁(G, A) ⟶ H₁(G ⧸ S, A_S)` is exact. `simp`s
 squeezed for performance. -/
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
index 5fda00c63..a74e5b470 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
@@ -636,6 +636,8 @@ def cyclesOfIsCycle₁ (x : G →₀ A) (hx : IsCycle₁ x) :
     cycles₁ (Rep.ofDistribMulAction k G A) :=
   ⟨x, (mem_cycles₁_iff (A := Rep.ofDistribMulAction k G A) x).2 hx⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCycle₁_of_mem_cycles₁
     (x : G →₀ A) (hx : x ∈ cycles₁ (Rep.ofDistribMulAction k G A)) :
     IsCycle₁ x := by
@@ -649,6 +651,8 @@ def boundariesOfIsBoundary₁ (x : G →₀ A) (hx : IsBoundary₁ x) :
     boundaries₁ (Rep.ofDistribMulAction k G A) :=
   ⟨x, hx⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isBoundary₁_of_mem_boundaries₁
     (x : G →₀ A) (hx : x ∈ boundaries₁ (Rep.ofDistribMulAction k G A)) :
     IsBoundary₁ x := hx
@@ -661,6 +665,8 @@ def cyclesOfIsCycle₂ (x : G × G →₀ A) (hx : IsCycle₂ x) :
     cycles₂ (Rep.ofDistribMulAction k G A) :=
   ⟨x, (mem_cycles₂_iff (A := Rep.ofDistribMulAction k G A) x).2 hx⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCycle₂_of_mem_cycles₂
     (x : G × G →₀ A) (hx : x ∈ cycles₂ (Rep.ofDistribMulAction k G A)) :
     IsCycle₂ x := (mem_cycles₂_iff (A := Rep.ofDistribMulAction k G A) x).1 hx
@@ -673,6 +679,8 @@ def boundariesOfIsBoundary₂ (x : G × G →₀ A) (hx : IsBoundary₂ x) :
     boundaries₂ (Rep.ofDistribMulAction k G A) :=
   ⟨x, hx⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isBoundary₂_of_mem_boundaries₂
     (x : G × G →₀ A) (hx : x ∈ boundaries₂ (Rep.ofDistribMulAction k G A)) :
     IsBoundary₂ x := hx
@@ -994,6 +1002,7 @@ lemma mkH1OfIsTrivial_apply (g : G) (a : A) :
       H1π A ((cycles₁IsoOfIsTrivial A).inv (single g a)) := rfl
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a `G`-representation on `A` is trivial, this is the natural map `H₁(G, A) → Gᵃᵇ ⊗[ℤ] A`
 sending `⟦single g a⟧` to `⟦g⟧ ⊗ₜ a`. -/
 def H1ToTensorOfIsTrivial : H1 A →ₗ[ℤ] (Additive <| Abelianization G) ⊗[ℤ] A :=
diff --git a/mathlib4/Mathlib/RepresentationTheory/Subrepresentation.lean b/mathlib4/Mathlib/RepresentationTheory/Subrepresentation.lean
index e855a1e86..6dcc4ad8c 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Subrepresentation.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Subrepresentation.lean
@@ -101,6 +101,7 @@ variable [CommSemiring A] [Monoid G] [AddCommMonoid W] [Module A W]
   {ρ : Representation A G W} [AddCommMonoid M] [Module A[G] M]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A subrepresentation of `ρ` can be thought of as an `A[G]` submodule of `ρ.asModule`.
 -/
 def asSubmodule (σ : Subrepresentation ρ) : Submodule A[G] ρ.asModule where
@@ -113,8 +114,12 @@ def asSubmodule (σ : Subrepresentation ρ) : Submodule A[G] ρ.asModule where
       rw [Representation.single_smul]
       exact σ.toSubmodule.smul_mem' a (σ.apply_mem_toSubmodule g hv)
 
+-- Type-correct statement would be `(Representation.asModuleEquiv ρ).symm v ∈ asSubmodule σ`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
-lemma mem_asSubmodule_iff {σ : Subrepresentation ρ} {v : W} : v ∈ asSubmodule σ ↔ v ∈ σ := by rfl
+lemma mem_asSubmodule_iff {σ : Subrepresentation ρ} {v : W} :
+    v ∈ asSubmodule σ ↔ v ∈ σ := by rfl
 
 /-- A subrepresentation of `ofModule M` can be thought of as an `A[G]` submodule of `M`.
 -/
@@ -130,6 +135,10 @@ def asSubmodule' (σ : Subrepresentation (Representation.ofModule (k := A) (G :=
       exact σ.toSubmodule.smul_mem' ((algebraMap A A) a) <| by
         simpa [Representation.ofModule, RestrictScalars.lsmul] using! σ.apply_mem_toSubmodule g hm
 
+-- Type-correct statement would be
+-- `m ∈ asSubmodule' σ ↔ Representation.asModuleEquiv (Representation.ofModule M) m ∈ σ`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_asSubmodule'_iff {σ : Subrepresentation (Representation.ofModule (k := A) (G := G) M)}
     {m : M} : m ∈ asSubmodule' σ ↔ m ∈ σ := by rfl
@@ -144,10 +153,15 @@ def ofSubmodule (N : Submodule A[G] M) :
     simpa [Representation.ofModule, RestrictScalars.lsmul] using!
       Submodule.smul_of_tower_mem N (MonoidAlgebra.single g 1) hv
 
+-- Type-correct statement would be
+-- `Representation.asModuleEquiv (Representation.ofModule M) m ∈ ofSubmodule N ↔ m ∈ N`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_ofSubmodule_iff {N : Submodule A[G] M} {m : M} : m ∈ ofSubmodule N ↔ m ∈ N := by rfl
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An `A[G]`-submodule of `ρ.asModule` can be thought of as a subrepresentation of `ρ`.
 -/
 def ofSubmodule' (N : Submodule A[G] ρ.asModule) : Subrepresentation ρ where
@@ -160,6 +174,8 @@ def ofSubmodule' (N : Submodule A[G] ρ.asModule) : Subrepresentation ρ where
     rw [Representation.single_smul, one_smul] at h
     exact h
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_ofSubmodule'_iff {N : Submodule A[G] ρ.asModule} {w : W} : w ∈ ofSubmodule' N ↔ w ∈ N :=
   .rfl
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
index 6a4cc4ce7..b0bc9008a 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
@@ -54,6 +54,8 @@ namespace Aux
 variable {P} {b}
 variable (D : Aux P b)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `T = R[X₁, ..., Xₙ] / (b₁, ..., bᵣ)` where the `bᵢ` are lifts of the basis elements
 of `I/I²` in `I`. -/
 abbrev T :=
@@ -275,6 +277,7 @@ end
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 open PresentationOfFreeCotangent in
 /--
 Version of `Algebra.Generators.exists_presentation_of_free_cotangent` taking a basis instead
@@ -329,6 +332,8 @@ public lemma exists_presentation_of_basis_cotangent [Algebra.FinitePresentation
   exact hf _
 
 open PresentationOfFreeCotangent in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `S` be a finitely presented `R`-algebra and suppose `P : R[X] → S` generates `S` with
 kernel `I`. If `I/I²` is free, there exists an `R`-presentation `P'` of `S` extending `P` with
 kernel `I'`, such that `I'/I'²` is free on the images of the relations of `P'`.
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean
index 0afd7ec27..8623136c0 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean
@@ -118,6 +118,7 @@ lemma sq_ker_comp_le_ker_compLocalizationAwayAlgHom :
       simp [hsple hx]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 Let `R → S → T` be algebras such that `T` is the localization of `S` away from one
 element, where `S` is generated over `R` by `P` with kernel `I` and `Q` is the
diff --git a/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean b/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
index 67a3cf90c..0637fffe2 100644
--- a/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
+++ b/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
@@ -924,6 +924,9 @@ variable {R S : Type*} (K L : Type*) [CommRing R] [IsDomain R] [CommRing S] [IsD
 local instance (f : R ≃+* S) : RingHomInvPair (f : R →+* S) f.symm :=
   RingHomInvPair.of_ringEquiv f
 
+local instance (f : R ≃+* S) : RingHomInvPair (f.symm : S →+* R) f :=
+  RingHomInvPair.of_ringEquiv f.symm
+
 /-- If `f : R ≃+* S` is a ring isomorphism and `I : Submodule R K` is fractional with respect to
 `R⁰`, then `I.map (IsFractionRing.semilinearEquivOfRingEquiv K L f).toLinearMap`
 is fractional with respect to `S⁰`.
@@ -947,6 +950,7 @@ theorem _root_.IsFractional.mapEquiv {I : Submodule R K} (hI : IsFractional R⁰
     ← map_mul, ← Algebra.smul_def, ← hr', ringEquivOfRingEquiv_algebraMap]
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The equiv `FractionalIdeal R⁰ K ≃+* FractionalIdeal S⁰ L`
   induced by a ring isomorphism `f : R ≃+* S`. -/
 @[simps -isSimp]
@@ -1013,6 +1017,7 @@ lemma ringEquivOfRingEquiv_refl :
   simp [semilinearEquivOfRingEquiv]
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ringEquivOfRingEquiv_spanSingleton (x : K) :
     FractionalIdeal.ringEquivOfRingEquiv K L f (spanSingleton R⁰ x) =
       spanSingleton S⁰ (IsFractionRing.ringEquivOfRingEquiv (L := L) f x) := by
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Nonunits.lean b/mathlib4/Mathlib/RingTheory/Ideal/Nonunits.lean
index 0c2acbd02..e574b6d62 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Nonunits.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Nonunits.lean
@@ -93,7 +93,7 @@ section GroupWithZero
 variable [GroupWithZero α] [SubmonoidClass C α] {S : C} {a : S}
 
 theorem isUnit_iff_and : IsUnit a ↔ (a : α) ≠ 0 ∧ (a : α)⁻¹ ∈ S where
-  mp h := ⟨(h.map <| subtype <| ofClass S).ne_zero, inv_mem_of_isUnit h⟩
+  mp h := ⟨(h.map <| SubmonoidClass.subtype S).ne_zero, inv_mem_of_isUnit h⟩
   mpr h :=
     ⟨⟨a, ⟨_, h.2⟩, Subtype.ext (mul_inv_cancel₀ h.1), Subtype.ext (inv_mul_cancel₀ h.1)⟩, rfl⟩
 
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean b/mathlib4/Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean
index 8c6ce13b3..18e9c58b9 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean
@@ -272,6 +272,8 @@ theorem span_singleton_absNorm {I : Ideal S} (hI : (Ideal.absNorm I).Prime) :
 
 variable [Module.Finite ℤ S]
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `e : S ≃ I` be an additive isomorphism (therefore a `ℤ`-linear equiv).
 Then an alternative way to compute the norm of `I` is given by taking the determinant of `e`.
 See `natAbs_det_basis_change` for a more familiar formulation of this result. -/
diff --git a/mathlib4/Mathlib/RingTheory/IdealFilter/Topology.lean b/mathlib4/Mathlib/RingTheory/IdealFilter/Topology.lean
index 260632839..c2d52d29b 100644
--- a/mathlib4/Mathlib/RingTheory/IdealFilter/Topology.lean
+++ b/mathlib4/Mathlib/RingTheory/IdealFilter/Topology.lean
@@ -124,6 +124,10 @@ lemma mem_nhds_zero_iff {s : Set (WithIdealFilter F)} :
     s ∈ 𝓝 0 ↔ ∃ I ∈ F, idealSet I ⊆ s := by
   simpa [zero_vadd] using mem_nhds_iff (a := 0) (s := s)
 
+-- Defeq abuse: uses `AddSubmonoidClass (Submodule A A) A` as
+-- `AddSubmonoidClass (Submodule A A) (WithIdealFilter F)`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The topology is linear in the sense that `𝓝 0` has a basis of ideals. -/
 instance instIsLinearTopology : IsLinearTopology (WithIdealFilter F) (WithIdealFilter F) :=
   IsLinearTopology.mk_of_hasBasis' (R := (WithIdealFilter F))
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean b/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
index ee13f7d06..bd8cf8763 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
@@ -76,6 +76,7 @@ attribute [local instance] SMulCommClass.of_commMonoid
 namespace Generators
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Cotangent.surjective_map_ofComp :
     Function.Surjective (Extension.Cotangent.map (Q.ofComp P).toExtensionHom) := by
   intro x
diff --git a/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean b/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
index 209bc9413..a3588fdcd 100644
--- a/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
@@ -112,6 +112,8 @@ variable
   [inst : ∀ (P : Ideal R) [P.IsMaximal], IsLocalizedModule P.primeCompl (f P)]
 
 set_option backward.defeqAttrib.useBackward true in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 include f in
 /--
diff --git a/mathlib4/Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean b/mathlib4/Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean
index fa70ddb50..2e687f1c4 100644
--- a/mathlib4/Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean
@@ -28,6 +28,8 @@ open Localization Ideal IsLocalization
 
 variable {R K : Type*} [CommRing R] [Field K] [Algebra R K] [IsFractionRing R K]
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem IsIntegrallyClosed.iInf {ι : Type*} (S : ι → Subalgebra R K)
     (h : ∀ i, IsIntegrallyClosed (S i)) :
     IsIntegrallyClosed (⨅ i, S i : Subalgebra R K) := by
diff --git a/mathlib4/Mathlib/RingTheory/Localization/FractionRing.lean b/mathlib4/Mathlib/RingTheory/Localization/FractionRing.lean
index 1198a37fc..a135014de 100644
--- a/mathlib4/Mathlib/RingTheory/Localization/FractionRing.lean
+++ b/mathlib4/Mathlib/RingTheory/Localization/FractionRing.lean
@@ -484,6 +484,9 @@ variable {A B : Type*} (K L : Type*) [CommRing A] [CommRing B] [CommRing K] [Com
 local instance : RingHomInvPair (f : A →+* B) f.symm :=
   RingHomInvPair.of_ringEquiv f
 
+local instance : RingHomInvPair (f.symm : B →+* A) f :=
+  RingHomInvPair.of_ringEquiv f.symm
+
 /-- Given rings `A, B` and localization maps to their fraction rings
 `f : A →+* K, g : B →+* L`, an isomorphism `h : A ≃+* B` induces a semilinear equivalence
 fraction rings `K ≃ₛₗ[f.toRingHom] L`. -/
diff --git a/mathlib4/Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean b/mathlib4/Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean
index 19af3d3b6..995f1d443 100644
--- a/mathlib4/Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean
@@ -116,6 +116,7 @@ variable [TopologicalSpace R]
 open WithPiTopology
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If the ring `R` is endowed with a linear topology, then the sets `↑basis σ R (J, d)`,
 for `J : TwoSidedIdeal R` which are neighborhoods of `0 : R` and `d : σ →₀ ℕ`,
 constitute a basis of neighborhoods of `0 : MvPowerSeries σ R` for the product topology. -/
diff --git a/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean b/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
index 9b58c8f23..ed3d5210b 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
@@ -572,6 +572,7 @@ lemma map_first_exact_on_four_term_right_exact_of_isSMulRegular_last
 section Perm
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 open _root_.LinearMap in
 private lemma IsWeaklyRegular.swap {a b : R} (h1 : IsWeaklyRegular M [a, b])
     (h2 : torsionBy R M b = a • torsionBy R M b → torsionBy R M b = ⊥) :
diff --git a/mathlib4/Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean b/mathlib4/Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean
index 35f86bc67..2ca1c9afc 100644
--- a/mathlib4/Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean
+++ b/mathlib4/Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean
@@ -259,6 +259,8 @@ instance : Module.Free S (Generators.localizationAway S r).toExtension.Cotangent
   inferInstanceAs <|
     Module.Free S ((SubmersivePresentation.localizationAway S r).toExtension.Cotangent)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (S) in
 /-- The image of `g * X - 1` in `I/I²` if `I` is the kernel of the canonical presentation
 of the localization of `S` away from `g`. -/
@@ -266,6 +268,8 @@ noncomputable
 abbrev Generators.cMulXSubOneCotangent : (Generators.localizationAway S r).toExtension.Cotangent :=
   Extension.Cotangent.mk ⟨C r * X () - 1, C_mul_X_sub_one_mem_ker _⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Generators.cMulXSubOneCotangent_eq :
     cMulXSubOneCotangent S r = Extension.Cotangent.mk ⟨C r * X () - 1, C_mul_X_sub_one_mem_ker _⟩ :=
   rfl
diff --git a/mathlib4/Mathlib/RingTheory/Spectrum/Prime/FreeLocus.lean b/mathlib4/Mathlib/RingTheory/Spectrum/Prime/FreeLocus.lean
index a52be8b7e..b1b24ba77 100644
--- a/mathlib4/Mathlib/RingTheory/Spectrum/Prime/FreeLocus.lean
+++ b/mathlib4/Mathlib/RingTheory/Spectrum/Prime/FreeLocus.lean
@@ -55,6 +55,8 @@ lemma mem_freeLocus {p} : p ∈ freeLocus R M ↔
     Module.Free (Localization.AtPrime p.asIdeal) (LocalizedModule p.asIdeal.primeCompl M) :=
   Iff.rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 lemma mem_freeLocus_of_isLocalization (p : PrimeSpectrum R)
     (Rₚ Mₚ) [CommRing Rₚ] [Algebra R Rₚ] [IsLocalization.AtPrime Rₚ p.asIdeal]
diff --git a/mathlib4/Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean b/mathlib4/Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean
index ab76a77a3..8a6719995 100644
--- a/mathlib4/Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean
+++ b/mathlib4/Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean
@@ -71,6 +71,7 @@ lemma isNilpotent_tensor_residueField_iff
 namespace PrimeSpectrum
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `A` be an `R`-algebra.
 `𝔭 : Spec R` is in the image of `Z(I) ∩ D(f) ⊆ Spec S`
 if and only if `f` is not nilpotent on `κ(𝔭) ⊗ A ⧸ I`. -/
diff --git a/mathlib4/Mathlib/RingTheory/Valuation/LocalSubring.lean b/mathlib4/Mathlib/RingTheory/Valuation/LocalSubring.lean
index de4963030..83a0b033b 100644
--- a/mathlib4/Mathlib/RingTheory/Valuation/LocalSubring.lean
+++ b/mathlib4/Mathlib/RingTheory/Valuation/LocalSubring.lean
@@ -143,6 +143,8 @@ lemma LocalSubring.exists_le_valuationSubring (A : LocalSubring K) :
     apply hCA.2.1
     exact isUnit_iff_exists_inv.mpr ⟨⟨b, hCB.1 hbB⟩, Subtype.ext congr(($e).1)⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Ideal.image_subset_nonunits_valuationSubring {A : Subring K} (I : Ideal A) (hI : I ≠ ⊤) :
     ∃ B : ValuationSubring K, A ≤ B.toSubring ∧ A.subtype '' I ⊆ B.nonunits := by
   have ⟨M, hM, le⟩ := I.exists_le_maximal hI
diff --git a/mathlib4/Mathlib/RingTheory/Valuation/RankOne.lean b/mathlib4/Mathlib/RingTheory/Valuation/RankOne.lean
index f128dd1b5..b0773fb2f 100644
--- a/mathlib4/Mathlib/RingTheory/Valuation/RankOne.lean
+++ b/mathlib4/Mathlib/RingTheory/Valuation/RankOne.lean
@@ -139,6 +139,8 @@ instance restrict_RankOne : RankOne (v.restrict) where
   hom' := (RankOne.hom v).comp embedding
   strictMono' := (strictMono v).comp embedding_strictMono
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma restrict_RankOne_hom_eq :
   RankOne.hom v.restrict = (RankOne.hom v).comp embedding := rfl
@@ -146,6 +148,7 @@ lemma restrict_RankOne_hom_eq :
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
 variable {K} in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem exists_val_lt {γ : ℝ≥0} (hγ : γ ≠ 0) : ∃ x ≠ 0, RankOne.hom v (v.restrict x) < γ := by
   have hγ_pos : 0 < γ := pos_iff_ne_zero.mpr hγ
   obtain ⟨x, h⟩ := NNReal.exists_lt_of_strictMono (RankOne.strictMono v.restrict) hγ_pos
diff --git a/mathlib4/Mathlib/RingTheory/WittVector/Isocrystal.lean b/mathlib4/Mathlib/RingTheory/WittVector/Isocrystal.lean
index cfe4966b0..899958784 100644
--- a/mathlib4/Mathlib/RingTheory/WittVector/Isocrystal.lean
+++ b/mathlib4/Mathlib/RingTheory/WittVector/Isocrystal.lean
@@ -90,6 +90,9 @@ scoped[Isocrystal] notation "φ(" p ", " k ")" => WittVector.FractionRing.froben
 instance inv_pair₁ : RingHomInvPair φ(p, k) (FractionRing.frobenius p k).symm :=
   RingHomInvPair.of_ringEquiv (FractionRing.frobenius p k)
 
+instance inv_pair₁_symm : RingHomInvPair (FractionRing.frobenius p k).symm φ(p, k)  :=
+  RingHomInvPair.of_ringEquiv (FractionRing.frobenius p k).symm
+
 instance inv_pair₂ : RingHomInvPair ((FractionRing.frobenius p k).symm : K(p, k) →+* K(p, k))
     (FractionRing.frobenius p k) :=
   RingHomInvPair.of_ringEquiv (FractionRing.frobenius p k).symm
@@ -164,6 +167,8 @@ section PerfectRing
 
 variable [IsDomain k] [CharP k p] [PerfectRing k p]
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The standard one-dimensional isocrystal of slope `m : ℤ` is an isocrystal. -/
 instance (m : ℤ) : Isocrystal p k (StandardOneDimIsocrystal p k m) where
   frob :=
diff --git a/mathlib4/Mathlib/SetTheory/Ordinal/Basic.lean b/mathlib4/Mathlib/SetTheory/Ordinal/Basic.lean
index 844d543fa..50872b7ca 100644
--- a/mathlib4/Mathlib/SetTheory/Ordinal/Basic.lean
+++ b/mathlib4/Mathlib/SetTheory/Ordinal/Basic.lean
@@ -571,7 +571,7 @@ theorem enum_zero_eq_bot {o : Ordinal} (ho : 0 < o) :
 
 theorem lt_wf : @WellFounded Ordinal (· < ·) :=
   wellFounded_iff_wellFounded_subrel.mpr (·.induction_on fun ⟨_, _, wo⟩ ↦
-    RelHomClass.wellFounded (enum _) wo.wf)
+    (RelHomClass.wellFounded (enum _) wo.wf :))
 
 instance wellFoundedRelation : WellFoundedRelation Ordinal :=
   ⟨(· < ·), lt_wf⟩
diff --git a/mathlib4/Mathlib/SetTheory/ZFC/Class.lean b/mathlib4/Mathlib/SetTheory/ZFC/Class.lean
index 9e12f7040..1183adcaa 100644
--- a/mathlib4/Mathlib/SetTheory/ZFC/Class.lean
+++ b/mathlib4/Mathlib/SetTheory/ZFC/Class.lean
@@ -31,7 +31,7 @@ universe u
 We define `Class` as `Set ZFSet`, as this allows us to get many instances automatically. However, in
 practice, we treat it as (the definitionally equal) `ZFSet → Prop`. This means, the preferred way to
 state that `x : ZFSet` belongs to `A : Class` is to write `A x`. -/
-@[pp_with_univ, use_set_notation_for_order]
+@[instance_reducible, pp_with_univ, use_set_notation_for_order]
 def Class :=
   Set ZFSet deriving LE, EmptyCollection, Nonempty, Union, Inter, Compl, SDiff
 
@@ -371,7 +371,7 @@ noncomputable def coeEquiv : ZFSet.{u} ≃ {s : Set ZFSet.{u} // Small.{u, u+1}
   right_inv s := private Subtype.coe_injective <| coe_equiv_aux s.2
 
 /-- The **Burali-Forti paradox**: ordinals form a proper class. -/
-theorem isOrdinal_notMem_univ : IsOrdinal ∉ Class.univ.{u} := by
+theorem isOrdinal_notMem_univ : { o | IsOrdinal o } ∉ Class.univ.{u} := by
   rintro ⟨x, hx, -⟩
   suffices IsOrdinal x by
     apply Class.mem_irrefl x
diff --git a/mathlib4/Mathlib/Tactic/ComputeAsymptotics/Multiseries/Defs.lean b/mathlib4/Mathlib/Tactic/ComputeAsymptotics/Multiseries/Defs.lean
index ea58b5637..c44c9f59c 100644
--- a/mathlib4/Mathlib/Tactic/ComputeAsymptotics/Multiseries/Defs.lean
+++ b/mathlib4/Mathlib/Tactic/ComputeAsymptotics/Multiseries/Defs.lean
@@ -808,6 +808,7 @@ end Sorted
 
 section Approximates
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Coinductive predicate stating that `ms` approximates its attached function on `basis`.
 * If `basis = []`, i.e. `ms` is just a real number, `Approximates` holds unconditionally.
 * If `basis = basis_hd :: basis_tl` and `ms = nil`, then `f =ᶠ[atTop] 0`.
diff --git a/mathlib4/Mathlib/Tactic/Simproc/ExistsAndEq.lean b/mathlib4/Mathlib/Tactic/Simproc/ExistsAndEq.lean
index 0684540ca..484cc6ee9 100644
--- a/mathlib4/Mathlib/Tactic/Simproc/ExistsAndEq.lean
+++ b/mathlib4/Mathlib/Tactic/Simproc/ExistsAndEq.lean
@@ -422,7 +422,7 @@ simproc ↓ existsAndEq (Exists _) := fun e => do
   lambdaBoundedTelescope p 1 fun xs (body : Q(Prop)) => withNewMCtxDepth do
     let some u := f.constLevels![0]? | unreachable!
     have α : Q(Sort $u) := α; have p : Q($α → Prop) := p
-    let some (a : Q($α)) := xs[0]? | return .continue
+    let some (a : Q($α)) := (xs[0]? :) | return .continue
     let some path ← findEqPath a body | return .continue
     let (fvars, lctx, newBody, a') ← findEq a body path
     withLCtx' lctx do
diff --git a/mathlib4/Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean b/mathlib4/Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
index 8fdb74642..0835b3d9a 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
@@ -93,6 +93,9 @@ def toLimit (P : ProfiniteGrp.{u}) : P ⟶ limit (diagram P) :=
   ofHom { toLimitFun P with
   continuous_toFun := toLimitFun_continuous P }
 
+-- Defeq abuse, see `change` below.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An auxiliary result, superseded by `toLimit_surjective` -/
 theorem denseRange_toLimit (P : ProfiniteGrp.{u}) : DenseRange (toLimit P) := by
   apply dense_iff_inter_open.mpr
@@ -153,6 +156,7 @@ noncomputable def isoLimittoFiniteQuotientFunctor (P : ProfiniteGrp.{u}) :
   ContinuousMulEquiv.toProfiniteGrpIso (continuousMulEquivLimittoFiniteQuotientFunctor P)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The projection from `P` to the quotient by an open normal subgroup. -/
 @[to_additive /-- The projection from `P` to the quotient by an open normal subgroup. -/]
 def proj {P : ProfiniteGrp.{u}} (U : OpenNormalSubgroup P) : P ⟶ (diagram P).obj U :=
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean b/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
index 093a172af..4b61e1077 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
@@ -110,6 +110,11 @@ lemma UniformOnFun.continuousSMul_induced_of_image_bounded (φ : hom) (hφ : IsI
   refine UniformFun.continuousSMul_induced_of_range_bounded 𝕜 s E H φ' ⟨rfl⟩ fun u ↦ ?_
   simpa only [Set.image_eq_range] using! h u s hs
 
+variable (H : Submodule 𝕜 (α →ᵤ[𝔖] E))
+
+-- Abuses defeq `α →ᵤ[𝔖] E = α → E`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
 `S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
 equipped with the topology of `𝔖`-convergence, is a TVS.
diff --git a/mathlib4/Mathlib/Topology/Algebra/StarSubalgebra.lean b/mathlib4/Mathlib/Topology/Algebra/StarSubalgebra.lean
index 403ae5bee..137c392a3 100644
--- a/mathlib4/Mathlib/Topology/Algebra/StarSubalgebra.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/StarSubalgebra.lean
@@ -258,6 +258,7 @@ theorem induction_on {x y : A}
     exact mul u (subset_closure hu_mem) v (subset_closure hv_mem) (hu hu_mem) (hv hv_mem)
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem starAlgHomClass_ext [T2Space B] {F : Type*} {a : A}
     [FunLike F (elemental R a) B] [AlgHomClass F R _ B] [StarHomClass F _ B]
     {φ ψ : F} (hφ : Continuous φ)
diff --git a/mathlib4/Mathlib/Topology/Category/CompHausLike/Basic.lean b/mathlib4/Mathlib/Topology/Category/CompHausLike/Basic.lean
index 822b65506..1e2605ce2 100644
--- a/mathlib4/Mathlib/Topology/Category/CompHausLike/Basic.lean
+++ b/mathlib4/Mathlib/Topology/Category/CompHausLike/Basic.lean
@@ -92,6 +92,9 @@ instance : CoeSort (CompHausLike P) (Type u) :=
 instance category : Category (CompHausLike P) :=
   inferInstanceAs <| Category (InducedCategory _ toTop)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance concreteCategory : ConcreteCategory (CompHausLike P) (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTop) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/CompHausLike/Cartesian.lean b/mathlib4/Mathlib/Topology/Category/CompHausLike/Cartesian.lean
index b6059b439..c51534467 100644
--- a/mathlib4/Mathlib/Topology/Category/CompHausLike/Cartesian.lean
+++ b/mathlib4/Mathlib/Topology/Category/CompHausLike/Cartesian.lean
@@ -41,6 +41,8 @@ def productCone : BinaryFan X Y :=
   BinaryFan.mk (P := CompHausLike.of P (X × Y))
     (ofHom _ { toFun := Prod.fst }) (ofHom _ { toFun := Prod.snd })
 
+-- `continuity` getting confused about category theory
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 When the predicate `P` is preserved under taking type-theoretic products, that product is a
 category-theoretic product in `CompHausLike P`.
@@ -80,6 +82,7 @@ def coproductCocone : BinaryCofan X Y := BinaryCofan.mk (P := CompHausLike.of P
   (ofHom _ { toFun := Sum.inl }) (ofHom _ { toFun := Sum.inr })
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 When the predicate `P` is preserved under taking type-theoretic sums, that sum is a
 category-theoretic coproduct in `CompHausLike P`.
diff --git a/mathlib4/Mathlib/Topology/Category/CompactlyGenerated.lean b/mathlib4/Mathlib/Topology/Category/CompactlyGenerated.lean
index 1509d32e5..97c48c9a0 100644
--- a/mathlib4/Mathlib/Topology/Category/CompactlyGenerated.lean
+++ b/mathlib4/Mathlib/Topology/Category/CompactlyGenerated.lean
@@ -49,6 +49,9 @@ attribute [instance] is_compactly_generated
 instance : Category.{w, w + 1} CompactlyGenerated.{u, w} :=
   inferInstanceAs <| Category (InducedCategory _ toTop)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ConcreteCategory.{w} CompactlyGenerated.{u, w} (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTop) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/FinTopCat.lean b/mathlib4/Mathlib/Topology/Category/FinTopCat.lean
index 30c0a223d..104511c23 100644
--- a/mathlib4/Mathlib/Topology/Category/FinTopCat.lean
+++ b/mathlib4/Mathlib/Topology/Category/FinTopCat.lean
@@ -42,6 +42,9 @@ attribute [instance] fintype
 instance : Category FinTopCat :=
   inferInstanceAs <| Category (InducedCategory _ toTop)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ConcreteCategory FinTopCat (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTop) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/LightProfinite/Basic.lean b/mathlib4/Mathlib/Topology/Category/LightProfinite/Basic.lean
index 51a5db192..1baae4e1d 100644
--- a/mathlib4/Mathlib/Topology/Category/LightProfinite/Basic.lean
+++ b/mathlib4/Mathlib/Topology/Category/LightProfinite/Basic.lean
@@ -257,6 +257,9 @@ def toProfinite (S : LightDiagram) : Profinite := S.cone.pt
 instance : Category LightDiagram :=
   inferInstanceAs <| Category (InducedCategory _ toProfinite)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance hasForget : ConcreteCategory LightDiagram (fun X Y => C(X.toProfinite, Y.toProfinite)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toProfinite) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/Profinite/Product.lean b/mathlib4/Mathlib/Topology/Category/Profinite/Product.lean
index 53f9493c3..53ff533be 100644
--- a/mathlib4/Mathlib/Topology/Category/Profinite/Product.lean
+++ b/mathlib4/Mathlib/Topology/Category/Profinite/Product.lean
@@ -100,6 +100,7 @@ def indexCone (hC : IsCompact C) : Cone (indexFunctor hC) where
 variable (hC : IsCompact C)
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance isIso_indexCone_lift :
     IsIso ((limitConeIsLimit.{u, u} (indexFunctor hC)).lift (indexCone hC)) :=
   haveI : CompactSpace C := by rwa [← isCompact_iff_compactSpace]
diff --git a/mathlib4/Mathlib/Topology/Category/Sequential.lean b/mathlib4/Mathlib/Topology/Category/Sequential.lean
index 493885ee6..cf9c219c9 100644
--- a/mathlib4/Mathlib/Topology/Category/Sequential.lean
+++ b/mathlib4/Mathlib/Topology/Category/Sequential.lean
@@ -44,6 +44,9 @@ attribute [instance] is_sequential
 instance : Category.{u, u + 1} Sequential.{u} :=
   inferInstanceAs <| Category (InducedCategory _ toTop)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ConcreteCategory.{u} Sequential.{u} (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTop) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/TopCat/Limits/Products.lean b/mathlib4/Mathlib/Topology/Category/TopCat/Limits/Products.lean
index de6303f57..5d3e4755e 100644
--- a/mathlib4/Mathlib/Topology/Category/TopCat/Limits/Products.lean
+++ b/mathlib4/Mathlib/Topology/Category/TopCat/Limits/Products.lean
@@ -129,6 +129,7 @@ abbrev prodSnd {X Y : TopCat.{u}} : TopCat.of (X × Y) ⟶ Y :=
 def prodBinaryFan (X Y : TopCat.{u}) : BinaryFan X Y :=
   BinaryFan.mk prodFst prodSnd
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The constructed binary fan is indeed a limit -/
 def prodBinaryFanIsLimit (X Y : TopCat.{u}) : IsLimit (prodBinaryFan X Y) where
   lift := fun S : BinaryFan X Y => ofHom { toFun s := (S.fst s, S.snd s) }
@@ -234,6 +235,9 @@ protected def binaryCofan (X Y : TopCat.{u}) : BinaryCofan X Y :=
   BinaryCofan.mk (ofHom ⟨Sum.inl, by fun_prop⟩) (ofHom ⟨Sum.inr, by fun_prop⟩)
 
 set_option backward.isDefEq.respectTransparency.types false in
+-- `continuity` can't unfold the category theory language properly.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The constructed binary coproduct cofan in `TopCat` is the coproduct. -/
 def binaryCofanIsColimit (X Y : TopCat.{u}) : IsColimit (TopCat.binaryCofan X Y) := by
   refine Limits.BinaryCofan.isColimitMk (fun s => ofHom
@@ -250,6 +254,7 @@ def binaryCofanIsColimit (X Y : TopCat.{u}) : IsColimit (TopCat.binaryCofan X Y)
     exacts [ConcreteCategory.congr_hom h₁ x, ConcreteCategory.congr_hom h₂ x]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem binaryCofan_isColimit_iff {X Y : TopCat.{u}} (c : BinaryCofan X Y) :
     Nonempty (IsColimit c) ↔
       IsOpenEmbedding c.inl ∧ IsOpenEmbedding c.inr ∧ IsCompl (range c.inl) (range c.inr) := by
diff --git a/mathlib4/Mathlib/Topology/Category/TopCat/ULift.lean b/mathlib4/Mathlib/Topology/Category/TopCat/ULift.lean
index 26fe7b61a..4faaf93f8 100644
--- a/mathlib4/Mathlib/Topology/Category/TopCat/ULift.lean
+++ b/mathlib4/Mathlib/Topology/Category/TopCat/ULift.lean
@@ -57,6 +57,7 @@ def uliftFunctorCompForgetIso : uliftFunctor.{v, u} ⋙ forget TopCat.{max u v}
     forget TopCat.{u} ⋙ CategoryTheory.uliftFunctor.{v, u} := Iso.refl _
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The `ULift` functor on categories of topological spaces is fully faithful. -/
 def uliftFunctorFullyFaithful : uliftFunctor.{v, u}.FullyFaithful where
   preimage f := ofHom ⟨ULift.down ∘ f ∘ ULift.up, by fun_prop⟩
diff --git a/mathlib4/Mathlib/Topology/Category/UniformSpace.lean b/mathlib4/Mathlib/Topology/Category/UniformSpace.lean
index 46335ec85..baa765d5e 100644
--- a/mathlib4/Mathlib/Topology/Category/UniformSpace.lean
+++ b/mathlib4/Mathlib/Topology/Category/UniformSpace.lean
@@ -165,6 +165,7 @@ instance instFunLike (X Y : CpltSepUniformSpace) :
   coe_injective _ _ h := Subtype.ext h
 
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The concrete category instance on `CpltSepUniformSpace`. -/
 instance concreteCategory : ConcreteCategory CpltSepUniformSpace
     ({ f : · → · // UniformContinuous f }) :=
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/Basic.lean b/mathlib4/Mathlib/Topology/ContinuousMap/Basic.lean
index 70dfd5b86..d91eda2a6 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/Basic.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/Basic.lean
@@ -454,7 +454,7 @@ variable (hf : IsQuotientMap f) (g : C(X, Z)) (h : Function.FactorsThrough g f)
 noncomputable def lift : C(Y, Z) where
   toFun := ((fun i ↦ Quotient.liftOn' i g (fun _ _ (hab : f _ = f _) ↦ h hab)) :
     Quotient (Setoid.ker f) → Z) ∘ hf.homeomorph.symm
-  continuous_toFun := Continuous.comp (continuous_quot_lift _ g.2) (Homeomorph.continuous _)
+  continuous_toFun := Continuous.comp (g.2.quotient_liftOn' _) (Homeomorph.continuous _)
 
 /--
 The obvious triangle induced by `IsQuotientMap.lift` commutes:
diff --git a/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean b/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
index 174e0498c..082aed9d9 100644
--- a/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
+++ b/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
@@ -683,6 +683,8 @@ lemma eVariationOn_inter_Iio_eq_inter_Iic_of_continuousWithinAt
   · congr 1
     grind
 
+-- Defeq abuse: `h` should be translated into a statement about `aᵒᵈ`.
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- If a function is continuous on the right at a point `a`, then its variations on `Ioi a` and
 on `Ici a` coincide. We give a version relative to a set `s`. -/
 lemma eVariationOn_inter_Ioi_eq_inter_Ici_of_continuousWithinAt
diff --git a/mathlib4/Mathlib/Topology/EMetricSpace/PairReduction.lean b/mathlib4/Mathlib/Topology/EMetricSpace/PairReduction.lean
index a2c61a6f5..f0669b361 100644
--- a/mathlib4/Mathlib/Topology/EMetricSpace/PairReduction.lean
+++ b/mathlib4/Mathlib/Topology/EMetricSpace/PairReduction.lean
@@ -359,6 +359,7 @@ lemma logSizeRadius_le_card_smallBall (hJ : J.Nonempty) (i : ℕ) (ha : 1 < a) :
     simp [h]
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma card_pairSet_le (ha : 1 < a) : #(pairSet J a c) ≤ a * #J := by
   wlog hJ : J.Nonempty
   · simp [Finset.not_nonempty_iff_eq_empty.mp hJ]
diff --git a/mathlib4/Mathlib/Topology/Homotopy/TopCat/Path.lean b/mathlib4/Mathlib/Topology/Homotopy/TopCat/Path.lean
index 8c11261fa..09bfd5062 100644
--- a/mathlib4/Mathlib/Topology/Homotopy/TopCat/Path.lean
+++ b/mathlib4/Mathlib/Topology/Homotopy/TopCat/Path.lean
@@ -37,6 +37,9 @@ protected structure Path (x y : X) where
 
 attribute [simp] Path.hom₀ Path.hom₁
 
+-- Would need `(ULift.{u, 0} ↑unitInterval) = TopCat.I` at instances transparency
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable {X} in
 /-- The bijection between `TopCat.Path X x y` and `_root_.Path x y`. -/
 @[simps!]
diff --git a/mathlib4/Mathlib/Topology/Homotopy/TopCat/ZerothHomotopy.lean b/mathlib4/Mathlib/Topology/Homotopy/TopCat/ZerothHomotopy.lean
index a0c1a429a..b568d0ba0 100644
--- a/mathlib4/Mathlib/Topology/Homotopy/TopCat/ZerothHomotopy.lean
+++ b/mathlib4/Mathlib/Topology/Homotopy/TopCat/ZerothHomotopy.lean
@@ -29,6 +29,7 @@ namespace TopCat
 variable {X : TopCat.{u}}
 
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given `X : TopCat`, this is the bijection between `1`-simplices of the
 singular simplicial set of `X` and the type of morphisms `I ⟶ X`. -/
 noncomputable def toSSetObj₁Equiv :
diff --git a/mathlib4/Mathlib/Topology/Instances/Rat.lean b/mathlib4/Mathlib/Topology/Instances/Rat.lean
index 41efad1a5..2c569ba5b 100644
--- a/mathlib4/Mathlib/Topology/Instances/Rat.lean
+++ b/mathlib4/Mathlib/Topology/Instances/Rat.lean
@@ -119,6 +119,9 @@ set_option linter.style.whitespace false in -- linter false positive
 @[simp ←, push_cast]
 lemma nndist_eq (p q : ℚ≥0) : nndist p q = nndist (p : ℚ) (q : ℚ) := rfl
 
+-- Defeq abuse, applying instances about `Subtype` to `ℚ≥0`.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : IsTopologicalSemiring ℚ≥0 where
   toContinuousAdd := continuousAdd_induced Nonneg.coeRingHom
   toContinuousMul := continuousMul_induced Nonneg.coeRingHom
diff --git a/mathlib4/Mathlib/Topology/Order/Category/AlexDisc.lean b/mathlib4/Mathlib/Topology/Order/Category/AlexDisc.lean
index 50cb21cc7..a5fdf6220 100644
--- a/mathlib4/Mathlib/Topology/Order/Category/AlexDisc.lean
+++ b/mathlib4/Mathlib/Topology/Order/Category/AlexDisc.lean
@@ -32,6 +32,9 @@ instance : CoeSort AlexDisc (Type _) :=
 instance category : Category AlexDisc :=
   inferInstanceAs <| Category (InducedCategory _ toTopCat)
 
+-- Would need to have a new type synonym for the `FunLike` instance for the induced category.
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance concreteCategory : ConcreteCategory AlexDisc (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTopCat) _
 
diff --git a/mathlib4/Mathlib/Topology/Order/IsLUB.lean b/mathlib4/Mathlib/Topology/Order/IsLUB.lean
index c3dcdc6ce..086fb5957 100644
--- a/mathlib4/Mathlib/Topology/Order/IsLUB.lean
+++ b/mathlib4/Mathlib/Topology/Order/IsLUB.lean
@@ -154,6 +154,8 @@ theorem isLUB_iff_of_subset_of_subset_closure {α : Type*} [TopologicalSpace α]
   isLUB_congr <| (upperBounds_closure (s := s) ▸ upperBounds_mono_set hts).antisymm <|
     upperBounds_mono_set hst
 
+-- Defeq abuse: `hst` and `hts` should be translated into statements about the order dual.
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem isGLB_iff_of_subset_of_subset_closure {α : Type*} [TopologicalSpace α] [Preorder α]
     [ClosedIciTopology α] {s t : Set α} (hst : s ⊆ t) (hts : t ⊆ closure s) {x : α} :
     IsGLB s x ↔ IsGLB t x :=
diff --git a/mathlib4/Mathlib/Topology/Order/MonotoneConvergence.lean b/mathlib4/Mathlib/Topology/Order/MonotoneConvergence.lean
index d74c618da..40188ab20 100644
--- a/mathlib4/Mathlib/Topology/Order/MonotoneConvergence.lean
+++ b/mathlib4/Mathlib/Topology/Order/MonotoneConvergence.lean
@@ -257,18 +257,24 @@ theorem Monotone.ge_of_tendsto [TopologicalSpace α] [Preorder α] [OrderClosedT
   haveI : Nonempty β := Nonempty.intro b
   _root_.ge_of_tendsto ha ((eventually_ge_atTop b).mono fun _ hxy => hf hxy)
 
+-- Defeq abuse: `ha` should be translated into a statement about the order dual
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem Monotone.le_of_tendsto [TopologicalSpace α] [Preorder α] [OrderClosedTopology α]
     [Preorder β] [IsCodirectedOrder β] {f : β → α} {a : α} (hf : Monotone f)
     (ha : Tendsto f atBot (𝓝 a)) (b : β) :
     a ≤ f b :=
   hf.dual.ge_of_tendsto ha b
 
+-- Defeq abuse: `ha` should be translated into a statement about the order dual
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem Antitone.le_of_tendsto [TopologicalSpace α] [Preorder α] [OrderClosedTopology α]
     [Preorder β] [IsDirectedOrder β] {f : β → α} {a : α} (hf : Antitone f)
     (ha : Tendsto f atTop (𝓝 a)) (b : β) :
     a ≤ f b :=
   hf.dual_right.ge_of_tendsto ha b
 
+-- Defeq abuse: `ha` should be translated into a statement about the order dual
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem Antitone.ge_of_tendsto [TopologicalSpace α] [Preorder α] [OrderClosedTopology α]
     [Preorder β] [IsCodirectedOrder β] {f : β → α} {a : α} (hf : Antitone f)
     (ha : Tendsto f atBot (𝓝 a)) (b : β) :

From fd9cdf299bf80c687b159e348dd90510eaea66f6 Mon Sep 17 00:00:00 2001
From: Paul Reichert <6992158+datokrat@users.noreply.github.com>
Date: Thu, 13 Aug 2026 08:00:55 +0000
Subject: [PATCH 3/7] builds

---
 mathlib4/Mathlib/Algebra/Algebra/Basic.lean   |  4 +
 mathlib4/Mathlib/Algebra/Algebra/Equiv.lean   |  1 +
 mathlib4/Mathlib/Algebra/Algebra/Hom.lean     |  2 +
 .../Mathlib/Algebra/Algebra/NonUnitalHom.lean |  4 +
 .../Algebra/Algebra/NonUnitalSubalgebra.lean  |  3 +
 .../Algebra/Spectrum/Quasispectrum.lean       |  1 +
 .../Mathlib/Algebra/Algebra/Unitization.lean  |  1 +
 mathlib4/Mathlib/Algebra/Azumaya/Basic.lean   |  1 +
 .../Mathlib/Algebra/BigOperators/Expect.lean  |  1 +
 .../Algebra/Category/Grp/Colimits.lean        | 11 ++-
 .../Category/ModuleCat/ChangeOfRings.lean     | 12 +++
 .../ModuleCat/Differentials/Presheaf.lean     | 28 ++++++
 .../Category/ModuleCat/FilteredColimits.lean  |  2 +
 .../Algebra/Category/ModuleCat/Free.lean      |  1 +
 .../Algebra/Category/ModuleCat/Images.lean    |  1 +
 .../ModuleCat/InjectiveDimension.lean         |  4 +
 .../Category/ModuleCat/Monoidal/Closed.lean   | 23 +++++
 .../ModuleCat/Presheaf/ColimitFunctor.lean    |  1 +
 .../Category/ModuleCat/Presheaf/Monoidal.lean | 58 +++++++++++++
 .../ModuleCat/Presheaf/Pushforward.lean       | 53 +++++++++++
 .../Category/ModuleCat/Presheaf/Sheafify.lean | 37 ++++++++
 .../ModuleCat/Presheaf/Submodule.lean         |  2 +
 .../Category/ModuleCat/Sheaf/LocallyFree.lean |  1 +
 .../Category/ModuleCat/Topology/Basic.lean    |  9 ++
 .../Algebra/Category/Ring/Constructions.lean  |  2 +
 .../Category/Ring/FilteredColimits.lean       |  4 +
 .../Mathlib/Algebra/Colimit/DirectLimit.lean  |  8 ++
 mathlib4/Mathlib/Algebra/Colimit/Module.lean  |  4 +
 .../Mathlib/Algebra/DirectSum/Algebra.lean    |  1 +
 .../Algebra/DirectSum/Decomposition.lean      |  2 +
 .../Mathlib/Algebra/Group/Action/Sigma.lean   |  1 +
 .../Mathlib/Algebra/Group/ForwardDiff.lean    |  1 +
 mathlib4/Mathlib/Algebra/Group/Hom/Defs.lean  |  6 +-
 .../Homology/Embedding/AreComplementary.lean  |  2 +
 .../HomotopyCategory/HomComplexShift.lean     | 35 ++++++++
 .../Homology/SpectralObject/Cycles.lean       |  4 +
 mathlib4/Mathlib/Algebra/Lie/Abelian.lean     |  1 +
 mathlib4/Mathlib/Algebra/Lie/BaseChange.lean  |  3 +
 mathlib4/Mathlib/Algebra/Lie/Basic.lean       |  5 ++
 mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean |  1 +
 .../Mathlib/Algebra/Lie/CartanCriterion.lean  |  1 +
 .../Mathlib/Algebra/Lie/CartanExists.lean     |  1 +
 mathlib4/Mathlib/Algebra/Lie/Character.lean   |  1 +
 mathlib4/Mathlib/Algebra/Lie/Cochain.lean     |  1 +
 .../Mathlib/Algebra/Lie/Derivation/Basic.lean |  3 +
 mathlib4/Mathlib/Algebra/Lie/Extension.lean   |  3 +
 mathlib4/Mathlib/Algebra/Lie/Free.lean        |  1 +
 mathlib4/Mathlib/Algebra/Lie/Graded.lean      |  3 +
 mathlib4/Mathlib/Algebra/Lie/Loop.lean        |  1 +
 mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean  |  1 +
 .../Algebra/Lie/Semisimple/Lemmas.lean        |  1 +
 mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean  |  2 +
 .../Mathlib/Algebra/Lie/TensorProduct.lean    |  1 +
 mathlib4/Mathlib/Algebra/Lie/TraceForm.lean   |  3 +
 .../Mathlib/Algebra/Lie/TransferInstance.lean |  1 +
 .../Mathlib/Algebra/Lie/Weights/Basic.lean    |  4 +
 .../Mathlib/Algebra/Lie/Weights/Chain.lean    |  1 +
 .../Mathlib/Algebra/Lie/Weights/IsSimple.lean |  1 +
 .../Mathlib/Algebra/Lie/Weights/Killing.lean  |  5 ++
 .../Mathlib/Algebra/Lie/Weights/Linear.lean   |  2 +
 .../Algebra/Module/Congruence/Defs.lean       |  1 +
 .../Mathlib/Algebra/Module/Equiv/Basic.lean   |  1 +
 .../Mathlib/Algebra/Module/Equiv/Defs.lean    | 20 +++++
 .../Algebra/Module/FinitePresentation.lean    |  1 +
 .../Mathlib/Algebra/Module/Injective.lean     |  2 +
 .../Algebra/Module/LinearMap/Defs.lean        |  5 ++
 .../Mathlib/Algebra/Module/LinearMap/End.lean |  2 +
 .../Algebra/Module/LinearMap/Index.lean       | 25 ++++++
 .../Algebra/Module/LocalizedModule/Basic.lean | 13 +++
 .../Algebra/Module/LocalizedModule/Exact.lean |  1 +
 mathlib4/Mathlib/Algebra/Module/PID.lean      |  1 +
 .../Module/Presentation/Differentials.lean    | 24 +++++
 .../Module/Presentation/RestrictScalars.lean  |  1 +
 .../Mathlib/Algebra/Module/SnakeLemma.lean    |  8 ++
 .../Algebra/Module/Submodule/Bilinear.lean    |  1 +
 .../Algebra/Module/Submodule/LinearMap.lean   |  2 +
 .../Module/Torsion/PrimaryComponent.lean      |  1 +
 .../Algebra/Module/TransferInstance.lean      |  1 +
 .../Algebra/Module/ZLattice/Covolume.lean     |  2 +
 .../Algebra/Order/Module/HahnEmbedding.lean   |  1 +
 .../Mathlib/Algebra/Polynomial/Bivariate.lean |  1 +
 .../Mathlib/Algebra/Polynomial/Coeff.lean     |  1 +
 .../Algebra/Polynomial/Derivation.lean        |  1 +
 .../Mathlib/Algebra/Polynomial/Expand.lean    |  1 +
 .../Algebra/Polynomial/Module/AEval.lean      |  2 +
 .../Algebra/QuadraticAlgebra/Basic.lean       |  2 +
 mathlib4/Mathlib/Algebra/QuaternionBasis.lean |  2 +
 mathlib4/Mathlib/Algebra/RingQuot.lean        |  6 ++
 .../Algebra/Star/NonUnitalSubalgebra.lean     |  1 +
 mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean |  6 ++
 mathlib4/Mathlib/Algebra/Star/Subalgebra.lean |  1 +
 .../Algebra/Vertex/HVertexOperator.lean       |  1 +
 .../AlgebraicGeometry/EffectiveEpi.lean       |  2 +
 .../EllipticCurve/Affine/Point.lean           |  1 +
 .../Geometrically/Connected.lean              |  2 +
 .../Geometrically/Integral.lean               |  2 +
 .../Geometrically/Irreducible.lean            |  2 +
 .../Geometrically/Reduced.lean                |  2 +
 .../Mathlib/AlgebraicGeometry/Limits.lean     | 37 +++++++-
 .../AlgebraicGeometry/Modules/Tilde.lean      |  2 +
 .../AlgebraicGeometry/Morphisms/Flat.lean     |  1 +
 .../AlgebraicGeometry/Sites/Etale.lean        |  1 +
 .../AlgebraicGeometry/Sites/EtalePoint.lean   |  3 +
 .../AlgebraicGeometry/StructureSheaf.lean     | 33 ++++++-
 .../DoldKan/Projections.lean                  |  1 +
 .../AnodyneExtensions/UnionProd.lean          |  1 +
 .../Mathlib/Analysis/Asymptotics/TVS.lean     |  2 +
 .../Mathlib/Analysis/BoxIntegral/Basic.lean   |  1 +
 .../Analysis/CStarAlgebra/CStarMatrix.lean    |  3 +
 .../ContinuousFunctionalCalculus/Commute.lean |  1 +
 .../Continuity.lean                           |  1 +
 .../NonUnital.lean                            |  2 +
 .../ContinuousFunctionalCalculus/Unique.lean  |  1 +
 .../ContinuousFunctionalCalculus/Unital.lean  |  2 +
 .../CStarAlgebra/GelfandNaimarkSegal.lean     |  6 ++
 .../Mathlib/Analysis/CStarAlgebra/Matrix.lean |  1 +
 .../Analysis/CStarAlgebra/Multiplier.lean     |  1 +
 .../CStarAlgebra/PositiveLinearMap.lean       |  1 +
 .../Analysis/CStarAlgebra/Spectrum.lean       |  1 +
 .../Analysis/CStarAlgebra/Unitization.lean    |  1 +
 .../Calculus/ContDiff/FTaylorSeries.lean      |  1 +
 .../Analysis/Calculus/Deriv/Basic.lean        |  1 +
 .../Analysis/Calculus/FDeriv/Symmetric.lean   |  2 +
 .../Mathlib/Analysis/Calculus/Rademacher.lean |  1 +
 .../Analysis/Complex/Harmonic/Analytic.lean   |  2 +
 .../Analysis/Convex/Approximation.lean        |  2 +
 mathlib4/Mathlib/Analysis/Convex/EGauge.lean  |  1 +
 mathlib4/Mathlib/Analysis/Convex/Side.lean    |  1 +
 .../Distribution/ContDiffMapSupportedIn.lean  |  3 +
 .../Analysis/Distribution/Distribution.lean   |  2 +
 .../Distribution/FourierMultiplier.lean       |  3 +
 .../Distribution/TemperedDistribution.lean    |  6 ++
 .../Analysis/Distribution/TestFunction.lean   |  2 +
 .../BoundedContinuousFunctionChar.lean        |  1 +
 .../Fourier/FourierTransformDeriv.lean        |  1 +
 .../Analysis/InnerProductSpace/Adjoint.lean   |  1 +
 .../Analysis/InnerProductSpace/Basic.lean     |  1 +
 .../Analysis/InnerProductSpace/Coalgebra.lean |  1 +
 .../Analysis/InnerProductSpace/Dual.lean      |  1 +
 .../Analysis/InnerProductSpace/LinearMap.lean |  5 ++
 .../Analysis/InnerProductSpace/NormDet.lean   |  1 +
 .../Analysis/InnerProductSpace/OfNorm.lean    |  1 +
 .../Analysis/InnerProductSpace/PiL2.lean      | 50 +++++++++++
 .../Analysis/InnerProductSpace/Positive.lean  |  1 +
 .../Analysis/InnerProductSpace/ProdL2.lean    | 18 ++++
 .../InnerProductSpace/Reproducing.lean        |  1 +
 .../Analysis/InnerProductSpace/Spectrum.lean  |  2 +
 .../Analysis/InnerProductSpace/Symmetric.lean |  1 +
 .../Analysis/InnerProductSpace/TwoDim.lean    |  1 +
 .../Analysis/InnerProductSpace/l2Space.lean   |  1 +
 .../Analysis/LocallyConvex/WeakDual.lean      |  1 +
 .../Analysis/Normed/Algebra/Unitization.lean  |  1 +
 .../Mathlib/Analysis/Normed/Module/Bases.lean |  2 +
 .../Mathlib/Analysis/Normed/Module/Basic.lean |  2 +
 .../Normed/Module/FiniteDimension.lean        |  1 +
 .../PiTensorProduct/InjectiveSeminorm.lean    |  1 +
 .../PiTensorProduct/ProjectiveSeminorm.lean   |  1 +
 .../Analysis/Normed/Module/RCLike/Basic.lean  |  1 +
 .../Operator/Compact/FredholmAlternative.lean |  1 +
 .../Analysis/Normed/Operator/Extend.lean      |  1 +
 .../Normed/Unbundled/FiniteExtension.lean     |  1 +
 .../Normed/Unbundled/InvariantExtension.lean  |  5 ++
 .../Normed/Unbundled/SpectralNorm.lean        |  1 +
 mathlib4/Mathlib/Analysis/RCLike/Basic.lean   |  1 +
 mathlib4/Mathlib/Analysis/RCLike/Extend.lean  |  1 +
 .../EnoughInjectives.lean                     |  3 +
 .../ModuleEmbedding/GabrielPopescu.lean       |  1 +
 .../Abelian/Pseudoelements.lean               |  1 +
 .../Filtered/CostructuredArrow.lean           | 28 ++++++
 .../CategoryTheory/GradedObject/Monoidal.lean |  2 +
 .../WithAlgebraicStructures.lean              |  1 +
 .../CategoryTheory/Monoidal/Bimod.lean        |  4 +
 .../CategoryTheory/Sites/LocalSite.lean       |  1 +
 .../IsCardinalForSmallObjectArgument.lean     | 24 +++++
 .../CategoryTheory/Subobject/Lattice.lean     |  2 +
 .../Enumerative/Partition/GenFun.lean         |  1 +
 .../SimpleGraph/Coloring/Vertex.lean          |  2 +
 .../Mathlib/Condensed/TopCatAdjunction.lean   | 33 +++++++
 mathlib4/Mathlib/FieldTheory/Fixed.lean       |  1 +
 .../Mathlib/FieldTheory/KummerExtension.lean  |  3 +
 .../Mathlib/FieldTheory/NormalizedTrace.lean  |  2 +
 .../FieldTheory/SeparablyGenerated.lean       |  1 +
 .../Mathlib/Geometry/Convex/Cone/Dual.lean    |  1 +
 .../Geometry/Convex/Cone/Face/Basic.lean      |  2 +
 .../Euclidean/Angle/Oriented/RightAngle.lean  |  3 +
 .../Euclidean/Angle/Oriented/Rotation.lean    |  4 +
 .../Geometry/Euclidean/Angle/Sphere.lean      |  2 +
 .../Geometry/Euclidean/MongePoint.lean        |  2 +
 .../Geometry/Euclidean/NinePointCircle.lean   |  2 +
 .../Euclidean/Sphere/SecondInter.lean         |  1 +
 .../Algebra/LeftInvariantDerivation.lean      |  3 +
 .../Geometry/Manifold/Instances/Sphere.lean   |  1 +
 .../Manifold/IntegralCurve/Basic.lean         |  2 +
 .../Geometry/Manifold/MFDeriv/Atlas.lean      |  6 +-
 .../Geometry/Manifold/MFDeriv/Basic.lean      | 30 +++++++
 .../Manifold/MFDeriv/NormedSpace.lean         |  2 +
 .../Manifold/MFDeriv/SpecificFunctions.lean   |  2 +
 .../Manifold/Riemannian/PathELength.lean      |  2 +
 .../Manifold/VectorBundle/LocalFrame.lean     |  2 +
 .../Manifold/VectorField/LieBracket.lean      | 87 +++++++++++++++++++
 .../Geometry/RingedSpace/OpenImmersion.lean   |  1 -
 .../AffineSpace/AffineEquiv.lean              |  1 +
 .../AffineSpace/AffineSubspace/Basic.lean     |  2 +
 .../AffineSpace/AffineSubspace/Shift.lean     |  2 +
 .../AffineSpace/Combination.lean              |  1 +
 .../Mathlib/LinearAlgebra/Basis/Basic.lean    |  1 +
 .../Mathlib/LinearAlgebra/Basis/Bilinear.lean |  1 +
 .../LinearAlgebra/Basis/Cardinality.lean      |  1 +
 .../Mathlib/LinearAlgebra/Basis/Defs.lean     |  3 +
 .../Mathlib/LinearAlgebra/Basis/Exact.lean    |  1 +
 .../Mathlib/LinearAlgebra/Basis/SMul.lean     |  1 +
 .../LinearAlgebra/Basis/VectorSpace.lean      |  1 +
 .../LinearAlgebra/BilinearForm/Basic.lean     |  1 +
 .../BilinearForm/DualLattice.lean             |  1 +
 .../BilinearForm/Orthogonal.lean              |  2 +
 .../BilinearForm/Properties.lean              |  1 +
 mathlib4/Mathlib/LinearAlgebra/Center.lean    |  1 +
 .../Mathlib/LinearAlgebra/Charpoly/Basic.lean |  1 +
 .../CliffordAlgebra/BaseChange.lean           |  1 +
 .../LinearAlgebra/CliffordAlgebra/Basic.lean  |  1 +
 .../CliffordAlgebra/Contraction.lean          |  5 ++
 .../LinearAlgebra/CliffordAlgebra/Equivs.lean |  1 +
 .../LinearAlgebra/CliffordAlgebra/Even.lean   |  5 ++
 .../CliffordAlgebra/EvenEquiv.lean            |  1 +
 .../CliffordAlgebra/Inversion.lean            |  3 +
 .../LinearAlgebra/CliffordAlgebra/Star.lean   |  1 +
 .../Mathlib/LinearAlgebra/Complex/Module.lean |  3 +
 .../Mathlib/LinearAlgebra/Contraction.lean    |  2 +
 .../Mathlib/LinearAlgebra/CrossProduct.lean   |  1 +
 mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean  |  1 +
 .../Mathlib/LinearAlgebra/Determinant.lean    | 27 ++++++
 .../LinearAlgebra/Dimension/Basic.lean        |  2 +
 .../Dimension/Constructions.lean              |  2 +
 .../Mathlib/LinearAlgebra/Dimension/Free.lean |  1 +
 .../LinearAlgebra/Dimension/RankNullity.lean  |  2 +
 .../Dimension/Torsion/Basic.lean              |  1 +
 .../Dimension/Torsion/Finite.lean             |  1 +
 .../LinearAlgebra/DirectSum/Finsupp.lean      |  2 +
 .../Mathlib/LinearAlgebra/Dual/Basis.lean     |  2 +
 mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean |  1 +
 .../LinearAlgebra/Eigenspace/Matrix.lean      |  1 +
 .../ExteriorAlgebra/OfAlternating.lean        |  4 +
 .../FiniteDimensional/Basic.lean              |  1 +
 .../Mathlib/LinearAlgebra/FiniteSpan.lean     |  1 +
 .../Mathlib/LinearAlgebra/Finsupp/Defs.lean   |  3 +
 .../LinearAlgebra/Finsupp/VectorSpace.lean    |  1 +
 .../LinearAlgebra/FreeModule/Basic.lean       |  2 +
 .../FreeModule/Finite/CardQuotient.lean       |  1 +
 .../Mathlib/LinearAlgebra/FreeModule/Int.lean |  1 +
 .../Mathlib/LinearAlgebra/FreeModule/PID.lean |  5 ++
 .../GeneralLinearGroup/AlgEquiv.lean          |  1 +
 .../LinearAlgebra/InvariantBasisNumber.lean   |  1 +
 .../LinearIndependent/Lemmas.lean             |  1 +
 .../LinearAlgebra/Matrix/Adjugate.lean        |  1 +
 .../Mathlib/LinearAlgebra/Matrix/Basis.lean   |  2 +
 .../Matrix/Charpoly/LinearMap.lean            |  1 +
 .../Mathlib/LinearAlgebra/Matrix/Rank.lean    |  1 +
 .../Mathlib/LinearAlgebra/Matrix/ToLin.lean   |  8 ++
 .../Mathlib/LinearAlgebra/Matrix/ZMatrix.lean |  1 +
 .../LinearAlgebra/Multilinear/DFinsupp.lean   |  1 +
 .../PerfectPairing/Restrict.lean              |  1 +
 mathlib4/Mathlib/LinearAlgebra/Pi.lean        |  2 +
 .../LinearAlgebra/PiTensorProduct/Basic.lean  |  3 +
 .../PiTensorProduct/Generators.lean           | 39 +++++++++
 mathlib4/Mathlib/LinearAlgebra/Prod.lean      |  2 +
 .../LinearAlgebra/QuadraticForm/Basic.lean    | 30 +++++++
 .../LinearAlgebra/QuadraticForm/Basis.lean    |  1 +
 .../LinearAlgebra/QuadraticForm/Dual.lean     |  1 +
 .../QuadraticForm/QuadraticModuleCat.lean     |  1 +
 .../QuadraticForm/TensorProduct.lean          |  1 +
 mathlib4/Mathlib/LinearAlgebra/Ray.lean       |  1 +
 .../Mathlib/LinearAlgebra/Reflection.lean     |  6 ++
 .../LinearAlgebra/RootSystem/Base.lean        |  1 +
 .../LinearAlgebra/RootSystem/BaseExists.lean  |  1 +
 .../LinearAlgebra/RootSystem/Basic.lean       |  1 +
 .../RootSystem/CartanMatrix.lean              |  1 +
 .../LinearAlgebra/RootSystem/Defs.lean        |  8 ++
 .../RootSystem/Finite/CanonicalBilinear.lean  |  3 +
 .../LinearAlgebra/RootSystem/Finite/G2.lean   |  4 +
 .../RootSystem/Finite/Nondegenerate.lean      |  2 +
 .../LinearAlgebra/RootSystem/OfBilinear.lean  |  3 +
 .../LinearAlgebra/RootSystem/Reduced.lean     |  1 +
 .../LinearAlgebra/SesquilinearForm/Basic.lean |  2 +
 .../LinearAlgebra/SesquilinearForm/Star.lean  |  1 +
 .../Mathlib/LinearAlgebra/Span/Basic.lean     |  1 +
 mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean |  2 +
 .../LinearAlgebra/SpecialLinearGroup.lean     |  2 +
 .../TensorAlgebra/ToTensorPower.lean          |  1 +
 .../LinearAlgebra/TensorPower/Basic.lean      |  5 ++
 .../TensorProduct/Graded/External.lean        |  3 +
 .../TensorProduct/Graded/Internal.lean        |  3 +
 .../TensorProduct/RightExactness.lean         |  2 +
 mathlib4/Mathlib/LinearAlgebra/Trace.lean     |  2 +
 .../LinearAlgebra/Transvection/Basic.lean     |  5 ++
 .../Transvection/Generation.lean              |  2 +
 .../MeasureTheory/Function/Jacobian.lean      |  2 +
 .../MeasureTheory/Integral/Bochner/L1.lean    |  1 +
 .../MeasureTheory/Integral/CircleAverage.lean |  1 +
 .../Integral/FinMeasAdditive.lean             |  1 +
 .../Integral/RieszMarkovKakutani/Basic.lean   |  1 +
 .../MeasureTheory/Integral/SetToL1.lean       |  1 +
 .../TaylorExpansion.lean                      |  1 +
 .../MeasureTheory/Measure/Haar/Extension.lean | 22 +++++
 .../MeasureTheory/Measure/Haar/OfBasis.lean   |  1 +
 .../Presburger/Semilinear/Basic.lean          |  1 +
 mathlib4/Mathlib/ModelTheory/Types.lean       | 27 ++++++
 .../NumberTheory/ClassNumber/Finite.lean      |  2 +
 .../LevelOne/DimensionFormula.lean            |  1 +
 .../CanonicalEmbedding/NormLeOne.lean         |  1 +
 .../NumberField/Cyclotomic/Basic.lean         |  1 +
 .../NumberField/Ideal/Asymptotics.lean        |  1 +
 .../NumberTheory/Padics/Measure/Basic.lean    |  3 +
 .../Mathlib/NumberTheory/Padics/WithVal.lean  | 34 ++++++++
 .../RamificationInertia/Basic.lean            |  1 +
 .../Probability/Distributions/Binomial.lean   |  1 +
 .../Distributions/Gaussian/CharFun.lean       |  1 +
 .../Mathlib/RepresentationTheory/Basic.lean   |  2 +
 .../RepresentationTheory/Character.lean       |  2 +
 .../Continuous/Basic.lean                     |  1 +
 .../GroupCohomology/Functoriality.lean        | 19 ++++
 .../GroupCohomology/LowDegree.lean            |  3 +
 .../GroupHomology/Functoriality.lean          |  4 +
 .../Homological/GroupHomology/LowDegree.lean  |  1 -
 .../Homological/Resolution.lean               |  1 +
 .../Mathlib/RepresentationTheory/Induced.lean |  6 --
 .../RepresentationTheory/Intertwining.lean    | 30 +++++++
 .../RepresentationTheory/Invariants.lean      |  1 +
 .../Mathlib/RepresentationTheory/Rep/Iso.lean |  1 +
 .../RepresentationTheory/Submodule.lean       |  1 +
 .../RingTheory/AdicCompletion/Algebra.lean    |  4 +
 .../RingTheory/AdicCompletion/Basic.lean      |  2 +
 .../AdicCompletion/Completeness.lean          |  1 +
 .../AdicCompletion/Functoriality.lean         |  2 +
 .../RingTheory/AdicCompletion/LocalRing.lean  |  1 +
 .../Mathlib/RingTheory/Adjoin/PowerBasis.lean |  2 +
 mathlib4/Mathlib/RingTheory/AlgebraTower.lean |  1 +
 .../RingTheory/Algebraic/Integral.lean        |  1 +
 .../Mathlib/RingTheory/Bialgebra/Equiv.lean   |  2 +
 .../Mathlib/RingTheory/Bialgebra/Hom.lean     |  2 +
 .../RingTheory/Bialgebra/MonoidAlgebra.lean   |  1 +
 .../RingTheory/DedekindDomain/Different.lean  |  3 +
 .../Mathlib/RingTheory/Derivation/Basic.lean  |  8 ++
 .../RingTheory/DividedPowerAlgebra/Init.lean  |  1 +
 .../Mathlib/RingTheory/Etale/Kaehler.lean     |  2 +
 .../Extension/Cotangent/BaseChange.lean       |  2 +
 .../RingTheory/Extension/Cotangent/Basic.lean |  1 +
 .../RingTheory/Extension/Cotangent/Basis.lean | 70 +++++++++++++++
 .../RingTheory/Extension/Cotangent/Free.lean  |  1 +
 mathlib4/Mathlib/RingTheory/FiniteType.lean   |  5 ++
 .../RingTheory/Flat/EquationalCriterion.lean  |  1 +
 .../RingTheory/Flat/FaithfullyFlat/Basic.lean |  1 +
 .../FractionalIdeal/Operations.lean           |  1 +
 .../Mathlib/RingTheory/HopfAlgebra/Basic.lean |  1 +
 .../Ideal/AssociatedPrime/Basic.lean          |  2 +
 .../Ideal/AssociatedPrime/Finiteness.lean     |  1 +
 .../Mathlib/RingTheory/Ideal/Cotangent.lean   |  2 +
 mathlib4/Mathlib/RingTheory/Ideal/Maps.lean   |  2 +
 .../RingTheory/Ideal/Quotient/Basic.lean      |  1 +
 .../RingTheory/Ideal/Quotient/Operations.lean |  2 +
 .../IsIntegralClosure/Basic.lean              |  1 +
 mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean |  1 +
 .../RingTheory/IsGaloisGroup/Defs.lean        |  1 +
 mathlib4/Mathlib/RingTheory/IsPrimary.lean    |  1 +
 .../Mathlib/RingTheory/IsTensorProduct.lean   |  2 +
 .../Mathlib/RingTheory/Kaehler/Basic.lean     | 34 ++++++++
 .../RingTheory/Kaehler/JacobiZariski.lean     |  3 +
 .../RingTheory/Kaehler/Polynomial.lean        |  1 +
 .../RingTheory/Kaehler/TensorProduct.lean     |  2 +
 .../RingTheory/LocalProperties/Injective.lean |  1 +
 .../LocalProperties/Projective.lean           |  1 +
 .../LocalRing/ResidueField/Fiber.lean         |  1 +
 .../RingTheory/Localization/Basic.lean        |  1 +
 .../RingTheory/Localization/Finiteness.lean   |  1 +
 .../RingTheory/Localization/Module.lean       |  3 +
 .../Mathlib/RingTheory/Morita/Matrix.lean     |  1 +
 .../MvPolynomial/WeightedHomogeneous.lean     |  1 +
 .../RingTheory/MvPowerSeries/Basic.lean       |  2 +
 .../RingTheory/MvPowerSeries/Order.lean       |  1 +
 .../MvPowerSeries/Substitution.lean           |  1 +
 .../RingTheory/NoetherNormalization.lean      |  1 +
 mathlib4/Mathlib/RingTheory/NormTrace.lean    |  1 +
 .../Mathlib/RingTheory/PiTensorProduct.lean   |  1 +
 mathlib4/Mathlib/RingTheory/PicardGroup.lean  |  3 +
 .../RingTheory/Polynomial/DegreeLT.lean       |  2 +
 .../Polynomial/Resultant/Basic.lean           |  2 +
 .../UniversalFactorizationRing.lean           |  3 +-
 .../RingTheory/PolynomialLaw/Basic.lean       |  3 +
 mathlib4/Mathlib/RingTheory/PowerBasis.lean   |  1 +
 .../RingTheory/QuasiFinite/Weakly.lean        |  1 +
 mathlib4/Mathlib/RingTheory/Regular/Free.lean |  1 +
 .../RingTheory/Regular/IsSMulRegular.lean     |  3 +
 .../Mathlib/RingTheory/Regular/LinearMap.lean |  1 +
 .../RingTheory/Regular/RegularSequence.lean   | 31 +++++++
 .../RingTheory/SimpleModule/Basic.lean        |  2 +
 mathlib4/Mathlib/RingTheory/Smooth/Basic.lean |  1 +
 .../Mathlib/RingTheory/Smooth/Kaehler.lean    |  1 +
 .../Mathlib/RingTheory/Smooth/Quotient.lean   |  2 +
 mathlib4/Mathlib/RingTheory/Support.lean      |  1 +
 .../TensorProduct/IsBaseChangeFree.lean       |  1 +
 mathlib4/Mathlib/RingTheory/Trace/Basic.lean  |  1 +
 .../Mathlib/RingTheory/Unramified/Field.lean  |  1 +
 .../Mathlib/RingTheory/Unramified/Finite.lean |  1 +
 mathlib4/Mathlib/Tactic/NormNum/Basic.lean    |  2 +
 .../Mathlib/Tactic/NormNum/BigOperators.lean  |  2 +
 mathlib4/Mathlib/Tactic/NormNum/Inv.lean      |  3 +
 mathlib4/Mathlib/Tactic/NormNum/Result.lean   |  3 +
 .../Mathlib/Topology/Algebra/Algebra.lean     |  1 +
 .../Module/ContinuousLinearMap/Basic.lean     |  1 +
 .../Algebra/Module/FiniteDimension.lean       |  1 +
 .../Module/FiniteDimensionBilinear.lean       |  1 +
 .../Topology/Algebra/Module/IsWeak.lean       |  1 +
 .../Algebra/Module/Spaces/CharacterSpace.lean |  3 +
 .../Algebra/Module/UniformConvergence.lean    |  2 +
 .../Mathlib/Topology/Algebra/MulAction.lean   |  1 +
 .../Profinite/Nobeling/Successor.lean         |  1 +
 .../Topology/Category/TopCat/Monoidal.lean    |  6 ++
 .../ContinuousMap/CompactlySupported.lean     |  1 +
 .../ContinuousMap/ContinuousMapZero.lean      |  1 +
 .../Mathlib/Topology/ContinuousMap/Star.lean  |  1 +
 .../ContinuousMap/StoneWeierstrass.lean       |  4 +
 .../EMetricSpace/BoundedVariation.lean        |  6 ++
 .../Mathlib/Topology/VectorBundle/Basic.lean  |  1 +
 mathlib4/lakefile.lean                        |  1 +
 423 files changed, 1754 insertions(+), 18 deletions(-)

diff --git a/mathlib4/Mathlib/Algebra/Algebra/Basic.lean b/mathlib4/Mathlib/Algebra/Algebra/Basic.lean
index 81ec13d6f..610396623 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Basic.lean
@@ -251,6 +251,7 @@ namespace LinearMap
 variable {R : Type*} {A : Type*} {B : Type*} [CommSemiring R] [Semiring A] [Semiring B]
   [Algebra R A] [Algebra R B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An alternate statement of `LinearMap.map_smul` for when `algebraMap` is more convenient to
 work with than `•`. -/
 theorem map_algebraMap_mul (f : A →ₗ[R] B) (a : A) (r : R) :
@@ -503,6 +504,7 @@ section invertibility
 variable {R A B : Type*}
 variable [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If there is a linear map `f : A →ₗ[R] B` that preserves `1`, then `algebraMap R B r` is
 invertible when `algebraMap R A r` is. -/
 abbrev Invertible.algebraMapOfInvertibleAlgebraMap (f : A →ₗ[R] B) (hf : f 1 = 1) {r : R}
@@ -526,6 +528,7 @@ section algebraMap
 
 variable {F E : Type*} [CommSemiring F] [Semiring E] [Algebra F E] (b : F →ₗ[F] E)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `E` is an `F`-algebra, and there exists an injective `F`-linear map from `F` to `E`,
 then the algebra map from `F` to `E` is also injective. -/
 theorem injective_algebraMap_of_linearMap (hb : Injective b) :
@@ -533,6 +536,7 @@ theorem injective_algebraMap_of_linearMap (hb : Injective b) :
   rw [← mul_one x, ← mul_one y, ← smul_eq_mul, ← smul_eq_mul,
     map_smul, map_smul, Algebra.smul_def, Algebra.smul_def, e]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `E` is an `F`-algebra, and there exists a surjective `F`-linear map from `F` to `E`,
 then the algebra map from `F` to `E` is also surjective. -/
 theorem surjective_algebraMap_of_linearMap (hb : Surjective b) :
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Equiv.lean b/mathlib4/Mathlib/Algebra/Algebra/Equiv.lean
index f423163bc..80f0d7b37 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Equiv.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Equiv.lean
@@ -957,6 +957,7 @@ variable {R S M₁ M₂ : Type*} [CommSemiring R] [AddCommMonoid M₁] [Module R
   [SMulCommClass S R M₁] [SMulCommClass S R M₂] [SMul R S] [IsScalarTower R S M₁]
   [IsScalarTower R S M₂]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (R) in
 /-- A linear equivalence of two modules induces an equivalence of algebras of their
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Hom.lean b/mathlib4/Mathlib/Algebra/Algebra/Hom.lean
index 0942fd932..8cb51f3ef 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Hom.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Hom.lean
@@ -271,6 +271,7 @@ theorem comp_assoc (φ₁ : C →ₐ[R] D) (φ₂ : B →ₐ[R] C) (φ₃ : A 
 instance {φ₁ : B →ₐ[R] C} {φ₂ : A →ₐ[R] B} :
     RingHomCompTriple φ₂.toRingHom φ₁.toRingHom (φ₁.comp φ₂).toRingHom := ⟨rfl⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- R-Alg ⥤ R-Mod -/
 def toLinearMap : A →ₗ[R] B where
   toFun := φ
@@ -297,6 +298,7 @@ theorem comp_toLinearMap (f : A →ₐ[R] B) (g : B →ₐ[R] C) :
 theorem toLinearMap_id : toLinearMap (AlgHom.id R A) = LinearMap.id :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma linearMapMk_toAddHom (f : A →ₐ[R] B) : LinearMap.mk f (map_smul f) = f.toLinearMap :=
   rfl
 
diff --git a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
index c5e4ecadc..cddec230e 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
@@ -373,6 +373,7 @@ def snd : A × B →ₙₐ[R] B where
 variable {R A B}
 variable [DistribMulAction R C]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The prod of two morphisms is a morphism. -/
 @[simps toFun]
@@ -444,9 +445,11 @@ variable {A B : Type*} [Semiring A] [Semiring B] [Algebra R A]
   [Algebra R B]
 
 -- see Note [lower instance priority]
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) [FunLike F A B] [AlgHomClass F R A B] : NonUnitalAlgHomClass F R A B :=
   { ‹AlgHomClass F R A B› with map_smulₛₗ := map_smul }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A unital morphism of algebras is a `NonUnitalAlgHom`. -/
 @[coe]
 def toNonUnitalAlgHom (f : A →ₐ[R] B) : A →ₙₐ[R] B :=
@@ -470,6 +473,7 @@ variable (R : Type*) {S A B : Type*} [Monoid R] [Monoid S]
     [DistribMulAction S A] [DistribMulAction S B] [DistribMulAction R A] [DistribMulAction R B]
     [IsScalarTower R S A] [IsScalarTower R S B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a monoid `R` acts on another monoid `S`, then a non-unital algebra homomorphism
 over `S` can be viewed as a non-unital algebra homomorphism over `R`. -/
 def restrictScalars (f : A →ₙₐ[S] B) : A →ₙₐ[R] B :=
diff --git a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
index 47b6fce6d..c946d2a2f 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@@ -451,6 +451,7 @@ variable [CommSemiring R]
 variable [NonUnitalNonAssocSemiring A] [Module R A] [NonUnitalNonAssocSemiring B] [Module R B]
 variable [NonUnitalNonAssocSemiring C] [Module R C] [FunLike F A B] [NonUnitalAlgHomClass F R A B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Range of an `NonUnitalAlgHom` as a non-unital subalgebra. -/
 protected def range (φ : F) : NonUnitalSubalgebra R B where
   toNonUnitalSubsemiring := NonUnitalRingHom.srange (φ : A →ₙ+* B)
@@ -479,6 +480,7 @@ theorem range_comp_le_range (f : A →ₙₐ[R] B) (g : B →ₙₐ[R] C) :
     NonUnitalAlgHom.range (g.comp f) ≤ NonUnitalAlgHom.range g :=
   SetLike.coe_mono (Set.range_comp_subset_range f g)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Restrict the codomain of a non-unital algebra homomorphism. -/
 def codRestrict (f : F) (S : NonUnitalSubalgebra R B) (hf : ∀ x, f x ∈ S) : A →ₙₐ[R] S :=
   { NonUnitalRingHom.codRestrict (f : A →ₙ+* B) S.toNonUnitalSubsemiring hf with
@@ -504,6 +506,7 @@ This is the bundled version of `Set.rangeFactorization`. -/
 abbrev rangeRestrict (f : F) : A →ₙₐ[R] (NonUnitalAlgHom.range f : NonUnitalSubalgebra R B) :=
   NonUnitalAlgHom.codRestrict f (NonUnitalAlgHom.range f) (NonUnitalAlgHom.mem_range_self f)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The equalizer of two non-unital `R`-algebra homomorphisms -/
 def equalizer (ϕ ψ : F) : NonUnitalSubalgebra R A where
   carrier := {a | (ϕ a : B) = ψ a}
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Spectrum/Quasispectrum.lean b/mathlib4/Mathlib/Algebra/Algebra/Spectrum/Quasispectrum.lean
index d8518f393..e193a7f8e 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Spectrum/Quasispectrum.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Spectrum/Quasispectrum.lean
@@ -268,6 +268,7 @@ instance quasispectrum.instZero [Nontrivial R] (a : A) : Zero (quasispectrum R a
 
 variable {R}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A version of `NonUnitalAlgHom.quasispectrum_apply_subset` which allows for `quasispectrum R`,
 where `R` is a *semi*ring, but `φ` must still function over a scalar ring `S`. In this case, we
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Unitization.lean b/mathlib4/Mathlib/Algebra/Algebra/Unitization.lean
index 430cf2088..bb584656c 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Unitization.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Unitization.lean
@@ -729,6 +729,7 @@ theorem algHom_ext' {φ ψ : Unitization R A →ₐ[R] C}
     φ = ψ :=
   algHom_ext'' (NonUnitalAlgHom.congr_fun h)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A non-unital algebra homomorphism from `A` into a unital `R`-algebra `C` lifts to a unital
 algebra homomorphism from the unitization into `C`. This is extended to an `Equiv` in
 `Unitization.lift` and that should be used instead. This declaration only exists for performance
diff --git a/mathlib4/Mathlib/Algebra/Azumaya/Basic.lean b/mathlib4/Mathlib/Algebra/Azumaya/Basic.lean
index 8f5035854..272e285f6 100644
--- a/mathlib4/Mathlib/Algebra/Azumaya/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Azumaya/Basic.lean
@@ -73,6 +73,7 @@ lemma mulLeftRight_comp_congr (e : A ≃ₐ[R] B) :
     (e.toLinearEquiv.conjAlgEquiv R).toAlgHom.comp (AlgHom.mulLeftRight R A) := by
   ext <;> simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem of_AlgEquiv (e : A ≃ₐ[R] B) [IsAzumaya R A] : IsAzumaya R B :=
   let _ : Module.Projective R B := .of_equiv e.toLinearEquiv
   let _ : FaithfulSMul R B := .of_injective e e.injective
diff --git a/mathlib4/Mathlib/Algebra/BigOperators/Expect.lean b/mathlib4/Mathlib/Algebra/BigOperators/Expect.lean
index 6021bb341..506844645 100644
--- a/mathlib4/Mathlib/Algebra/BigOperators/Expect.lean
+++ b/mathlib4/Mathlib/Algebra/BigOperators/Expect.lean
@@ -282,6 +282,7 @@ end bij
 @[simp] lemma expect_neg_index [DecidableEq ι] [InvolutiveNeg ι] (s : Finset ι) (f : ι → M) :
     𝔼 i ∈ -s, f i = 𝔼 i ∈ s, f (-i) := expect_image neg_injective.injOn
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma _root_.map_expect {F : Type*} [FunLike F M N] [LinearMapClass F ℚ≥0 M N]
     (g : F) (f : ι → M) (s : Finset ι) :
diff --git a/mathlib4/Mathlib/Algebra/Category/Grp/Colimits.lean b/mathlib4/Mathlib/Algebra/Category/Grp/Colimits.lean
index bcef27d14..fda41af16 100644
--- a/mathlib4/Mathlib/Algebra/Category/Grp/Colimits.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Grp/Colimits.lean
@@ -301,6 +301,13 @@ namespace AddCommGrpCat
 
 open QuotientAddGroup
 
+#adaptation_note
+/--
+This definition fails without `respectTransparency false`. Removing `lift_mk` from the `dsimp only`
+set in `inv_hom_id` would help. A more sustainable fix would probably be to revisit the `lift_mk`
+refl lemma: Its LHS and RHS are not defeq at implicit transparency. Either the lemma shouldn't be
+a refl lemma or more declarations need to be implicit-reducible.
+-/
 set_option backward.isDefEq.respectTransparency false in
 set_option backward.defeqAttrib.useBackward true in
 /-- The categorical cokernel of a morphism in `AddCommGrpCat`
@@ -321,8 +328,8 @@ noncomputable def cokernelIsoQuotient {G H : AddCommGrpCat.{u}} (f : G ⟶ H) :
     rfl
   inv_hom_id := by
     ext x
-    dsimp only [hom_comp, hom_ofHom, hom_zero, AddMonoidHom.coe_comp, coe_mk',
-      Function.comp_apply, AddMonoidHom.zero_apply, id_eq, lift_mk, hom_id, AddMonoidHom.coe_id]
+    dsimp only [hom_comp, hom_ofHom, hom_zero, AddMonoidHom.coe_comp, coe_mk', lift_mk,
+      Function.comp_apply, AddMonoidHom.zero_apply, id_eq, hom_id, AddMonoidHom.coe_id]
     exact QuotientAddGroup.induction_on (α := H) x <| cokernel.π_desc_apply f _ _
 
 end AddCommGrpCat
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
index ff1c2858a..a3ca30990 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
@@ -423,6 +423,7 @@ theorem map_tmul {M M' : ModuleCat.{v} R} (g : M ⟶ M') (s : S) (m : M) :
 
 variable {f}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[ext]
 lemma hom_ext {M : ModuleCat R} {N : ModuleCat S}
@@ -452,6 +453,7 @@ variable (M : Type v) [AddCommMonoid M] [Module R M]
 -- Porting note: this seems to cause problems related to lack of reducibility
 -- local notation "S'" => (restrictScalars f).obj ⟨S⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given an `R`-module M, consider Hom(S, M) -- the `R`-linear maps between S (as an `R`-module by
 means of restriction of scalars) and M. `S` acts on Hom(S, M) by `s • g = x ↦ g (x • s)`
@@ -562,6 +564,7 @@ namespace RestrictionCoextensionAdj
 
 variable {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given `R`-module X and `S`-module Y, any `g : (restrictScalars f).obj Y ⟶ X`
 corresponds to `Y ⟶ (coextendScalars f).obj X` by sending `y ↦ (s ↦ g (s • y))`
@@ -585,6 +588,7 @@ def HomEquiv.fromRestriction {X : ModuleCat R} {Y : ModuleCat S}
     (g : (restrictScalars f).obj Y ⟶ X) (y) (s : S) :
     (HomEquiv.fromRestriction f g).hom y s = g (s • y) := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given `R`-module X and `S`-module Y, any `g : Y ⟶ (coextendScalars f).obj X`
 corresponds to `(restrictScalars f).obj Y ⟶ X` by `y ↦ g y 1`
@@ -605,6 +609,7 @@ def HomEquiv.toRestriction {X : ModuleCat R} {Y : ModuleCat S} (g : Y ⟶ (coext
     (g : Y ⟶ (coextendScalars f).obj X) (y) :
     (HomEquiv.toRestriction f g).hom y = g.hom y (1 : S) := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Auxiliary definition for `unit'`, to address timeouts. -/
 def app' (Y : ModuleCat S) : Y →ₗ[S] (restrictScalars f ⋙ coextendScalars f).obj Y :=
@@ -620,6 +625,7 @@ def app' (Y : ModuleCat S) : Y →ₗ[S] (restrictScalars f ⋙ coextendScalars
       LinearMap.ext fun t : S => by
         simp [mul_smul] }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The natural transformation from identity functor to the composition of restriction and coextension
 of scalars.
@@ -634,6 +640,7 @@ protected noncomputable def unit' : 𝟭 (ModuleCat S) ⟶ restrictScalars f ⋙
       change s • (g y) = g (s • y)
       rw [map_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The natural transformation from the composition of coextension and restriction of scalars to
 identity functor.
@@ -654,8 +661,11 @@ protected noncomputable def counit' : coextendScalars f ⋙ restrictScalars f 
 
 end RestrictionCoextensionAdj
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 -- Porting note: very fiddly universes
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Restriction of scalars is left adjoint to coextension of scalars. -/
 -- @[simps] Porting note: not in normal form and not used
 def restrictCoextendScalarsAdj {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) :
@@ -710,6 +720,7 @@ def HomEquiv.toRestrictScalars {X : ModuleCat R} {Y : ModuleCat S}
 
 set_option backward.isDefEq.respectTransparency false in
 -- Porting note: forced to break apart fromExtendScalars due to timeouts
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The map `S → X →ₗ[R] Y` given by `fun s x => s • (g x)`
 -/
@@ -854,6 +865,7 @@ lemma Counit.map_apply_one_tmul {Y : ModuleCat S} (y : Y) :
   change (1 : S) • y = y
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- The natural transformation from the composition of restriction and extension of scalars to the
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
index d7e431bdf..89df16a1b 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
@@ -78,6 +78,34 @@ variable (d : M.Derivation φ)
 @[simp] lemma d_one (X : Dᵒᵖ) : d.d (X := X) 1 = 0 := by
   simpa using d.d_mul (X := X) 1 1
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized, writing `Y` for
+`Opposite.op (F.obj (Opposite.unop X))`:
+`FunLike (↑(M.obj Y) →ₗ[↑(R.obj Y)] ↑(N.obj Y)) ↑(M.obj Y) ↑(N.obj Y)`
+It is needed by the `rw [map_zero]` in `d_app` below; the accompanying `ZeroHomClass` fails the
+same way.
+
+The failure happens while applying `@LinearMap.instFunLike`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `Module ↑(R.obj Y) ↑(M.obj Y)`, whereas the assigned value `(M.obj (F.op.obj X)).isModule` has
+type `Module ↑((R ⋙ forget₂ CommRingCat RingCat).obj (F.op.obj X)) ↑(M.obj (F.op.obj X))`. The
+comparison bottoms out at
+`(R.obj Y).1 =?= ((R ⋙ forget₂ CommRingCat RingCat).obj (F.op.obj X)).1`, which would require
+unfolding `Functor.comp` and `Functor.op`; both are `@[implicit_reducible]` and therefore do not
+unfold at the `.instances` transparency that instance search runs at. Lean falls back to synthesize
+an instance of the correct type, which succeeds, but it returns `(M.obj Y).isModule`, which is again
+not defeq to the assigned value, stalling at `F.op.1 X =?= Opposite.op (F.obj (Opposite.unop X))`.
+That comparison, too, runs at `.instances`, since `respectTransparency false` suppresses the
+transparency bump that instance-implicit arguments would otherwise receive.
+
+Potential fix: see `# Fix` below — mark `ModuleCat.restrictScalars` and
+`ModuleCat.RestrictScalars.obj'` implicit-reducible. Then `respectTransparency false` and
+`instanceTypes false` can both go, and the `erw` becomes an `rw`.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- The postcomposition of a derivation by a morphism of presheaves of modules. -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
index a2f9f7c75..cdc3914a1 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
@@ -123,6 +123,7 @@ instance colimitSMulWithZero : SMulWithZero R (M F) :=
     simp [← colimit_zero_eq] }
 
 instance colimitModule : Module R (M F) :=
+set_option backward.isDefEq.respectTransparency.outParams false in
 { colimitMulAction F,
   colimitSMulWithZero F with
   smul_add := fun r x y => by
@@ -148,6 +149,7 @@ def coconeMorphism (j : J) : F.obj j ⟶ colimit F :=
       (F ⋙ forget₂ (ModuleCat R) AddCommGrpCat.{max v u})).ι.app j).hom with
     map_smul' := by solve_by_elim }
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit module. -/
 @[implicit_reducible]
 def colimitCocone : Cocone F where
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Free.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Free.lean
index e5317f642..6afcc17f0 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Free.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Free.lean
@@ -92,6 +92,7 @@ end LinearIndependent
 
 section Span
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hS in
 /-- In the commutative diagram
 ```
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Images.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Images.lean
index 47574ab1b..d2b6cf218 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Images.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Images.lean
@@ -53,6 +53,7 @@ attribute [local simp] image.fac
 
 variable {f}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- The universal property for the image factorisation -/
 noncomputable def image.lift (F' : MonoFactorisation f) : image f ⟶ F'.I :=
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/InjectiveDimension.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/InjectiveDimension.lean
index 384f9e816..6866ca33c 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/InjectiveDimension.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/InjectiveDimension.lean
@@ -86,6 +86,7 @@ variable [Small.{v} R] {R' : Type u'} [Ring R'] (eR : R ≃+* R')
 
 attribute [local instance] RingHomInvPair.of_ringEquiv
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 private lemma hasInjectiveDimensionLE_iff_of_semiLinearEquiv_aux [Small.{v} R']
     {M : ModuleCat.{v} R} {N : ModuleCat.{v} R'} (e : M ≃ₛₗ[RingHomClass.toRingHom eR] N)
@@ -126,6 +127,7 @@ private lemma hasInjectiveDimensionLE_iff_of_semiLinearEquiv_aux [Small.{v} R']
     exact (exactS.hasInjectiveDimensionLT_X₃_iff n inferInstance).symm.trans
       ((ih eCoker).trans (exactS'.hasInjectiveDimensionLT_X₃_iff n inferInstance))
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 attribute [local instance] small_lift in
 lemma hasInjectiveDimensionLE_iff_of_semiLinearEquiv [Small.{v'} R']
@@ -137,6 +139,8 @@ lemma hasInjectiveDimensionLE_iff_of_semiLinearEquiv [Small.{v'} R']
     hasInjectiveDimensionLE_iff_of_linearEquiv_aux eN]
   exact hasInjectiveDimensionLE_iff_of_semiLinearEquiv_aux eR ((eM.symm.trans e).trans eN) n
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma injectiveDimension_eq_of_semiLinearEquiv [Small.{v'} R']
     {M : ModuleCat.{v} R} {N : ModuleCat.{v'} R'} (e : M ≃ₛₗ[RingHomClass.toRingHom eR] N) :
     injectiveDimension M = injectiveDimension N := by
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Monoidal/Closed.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Monoidal/Closed.lean
index 119610224..8b4c0f546 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Monoidal/Closed.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Monoidal/Closed.lean
@@ -76,6 +76,29 @@ theorem ihom_ev_app (M N : ModuleCat.{u} R) :
   apply TensorProduct.ext'
   apply monoidalClosed_uncurry
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`Module R (TensorProduct R ↑(unop (op M)) ↑((𝟭 (ModuleCat R)).obj N))`
+
+The failure happens while applying `@TensorProduct.leftModule`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type is
+`Module R ↑((𝟭 (ModuleCat R)).obj N)`, whereas the assigned value `N.isModule` has type
+`Module R ↑N`. Lean falls back to synthesize an instance of the correct type, but it returns
+`((𝟭 (ModuleCat R)).obj N).isModule`, which is again not defeq to `N.isModule`: seeing that
+`(𝟭 (ModuleCat R)).obj N` is `N` requires unfolding `𝟭`, which is `@[implicit_reducible]` and
+therefore does not unfold at the `.instances` transparency that instance search runs at.
+
+Potential fix: Concentrate on removing `respectTransparency false` first.
+For example, do this by making `TensorProduct` implicit-reducible.
+Without the backward-compatibility flag `respectTransparency false`, Lean bumps transparency for
+instance-implicit arguments to `implicit`, thereby comparing the synthesized and unified instances
+at implicit transparency instead of the stricter instance transparency.
+After that, you can remove `instanceTypes false`, too.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Describes the unit of the adjunction `M ⊗ - ⊣ Hom(M, -)`. Given an `R`-module `N` this should
 define a map `N ⟶ Hom(M, M ⊗ N)`, which is given by flipping the arguments in the natural
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
index fb2c51cee..d28822408 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
@@ -237,6 +237,7 @@ lemma map_smul_homEquiv'_iff {N : ModuleCat.{w} cR.pt}
     congr 1
     exact (smul_eq ..).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- This is the universal property of `PresheafOfModules.ModuleColimit` as a module.
 See also `PresheafOfModules.colimitAdjunction`. -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
index 1fe00e832..e1b824f72 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
@@ -40,6 +40,37 @@ namespace Monoidal
 
 variable (M₁ M₂ M₃ M₄ : PresheafOfModules.{u} (R ⋙ forget₂ _ _))
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`TensorProduct.CompatibleSMul ↑(R.obj Y) ↑(R.obj Y) ↑(M₁.obj Y) ↑(M₂.obj Y)`
+
+The failure happens while applying `@TensorProduct.CompatibleSMul.isScalarTower`: assigning one of
+its instance-implicit-argument metavariables is rejected because the metavariable's type and the
+type of the assigned value do not match at `.instances` transparency. The metavariable's expected
+type is `DistribMulAction ↑(R.obj Y) ↑(M₂.obj Y)`, whereas the assigned value
+`ModuleCat.instModuleCarrierObjRestrictScalars.toDistribMulAction` has type
+```
+DistribMulAction ↑((R ⋙ forget₂ CommRingCat RingCat).obj Y)
+  ↑((ModuleCat.restrictScalars (RingCat.Hom.hom ((R ⋙ forget₂ CommRingCat RingCat).map f))).obj
+      (M₂.obj Y))
+```
+Lean falls back to synthesize an instance of the correct type, but it returns
+`(M₂.obj Y).isModule.toDistribMulAction`, which is again not defeq to the assigned value. Both
+comparisons bottom out at `↑(R.obj Y) =?= ↑((R ⋙ forget₂ CommRingCat RingCat).obj Y)`, the same
+ring bundled once as a `CommRingCat` and once as a `RingCat`; seeing that these agree requires
+unfolding `⋙`, which is `@[implicit_reducible]`.
+
+Potential fix: Concentrate on removing `respectTransparency false` first.
+For example, do this by making `ModuleCat.RestrictScalars.obj'` and `ModuleCat.restrictScalars`
+implicit-reducible *at their definition site*.
+Without the backward-compatibility flag `respectTransparency false`, Lean bumps transparency for
+instance-implicit arguments to `implicit`, thereby comparing the synthesized and unified instances
+at implicit transparency instead of the stricter instance transparency.
+After that, you can remove `instanceTypes false`, too.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Auxiliary definition for `tensorObj`. -/
 noncomputable def tensorObjMap {X Y : Cᵒᵖ} (f : X ⟶ Y) : M₁.obj X ⊗ M₂.obj X ⟶
@@ -75,6 +106,33 @@ noncomputable def tensorObj : PresheafOfModules (R ⋙ forget₂ _ _) where
 
 variable {M₁ M₂ M₃ M₄}
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`Module ↑(R.obj Y)
+  ↑((ModuleCat.restrictScalars (RingCat.Hom.hom ((R ⋙ forget₂ CommRingCat RingCat).map f))).obj
+      (M₁.obj Y))`
+
+The failure happens while applying `@ModuleCat.isModule`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `Ring ↑(R.obj Y)`, whereas the assigned value `RingCat.instRingObjForgetRingHomCarrier` has type
+`Ring ((forget RingCat).obj ((R ⋙ forget₂ CommRingCat RingCat).obj X))`. Lean falls back to
+synthesize an instance of the correct type, but it returns
+`CommRingCat.instCommRingObjForgetRingHomCarrier.toRing`, which is again not defeq to the assigned
+value. As for `tensorObjMap` above, both comparisons bottom out at
+`(R.obj Y).1 =?= ((R ⋙ forget₂ CommRingCat RingCat).obj X).1`.
+
+Potential fix: Concentrate on removing `respectTransparency false` first.
+For example, do this by making `ModuleCat.RestrictScalars.obj'` and `ModuleCat.restrictScalars`
+implicit-reducible  *at their definition site*.
+Without the backward-compatibility flag `respectTransparency false`, Lean bumps transparency for
+instance-implicit arguments to `implicit`, thereby comparing the synthesized and unified instances
+at implicit transparency instead of the stricter instance transparency.
+After that, you can remove `instanceTypes false`, too.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
index 468e6d78c..b394d5e25 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
@@ -108,6 +108,38 @@ lemma pushforward_obj_map_apply (M : PresheafOfModules.{v} R) {X Y : Cᵒᵖ} (f
     (m : (ModuleCat.restrictScalars (φ.app X).hom).obj (M.obj (Opposite.op (F.obj X.unop)))) :
       (((pushforward φ).obj M).map f).hom m = M.map (F.map f.unop).op m := rfl
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized, writing `P Z` for
+`(ModuleCat.restrictScalars (RingCat.Hom.hom (φ.app Z))).obj (((pushforward₀ F R).obj M).obj Z)`:
+```
+DFunLike (↑(P X) →ₗ[↑(S.obj X)]
+    ↑((ModuleCat.restrictScalars (RingCat.Hom.hom (S.map f))).obj (P Y))) _ _
+```
+It is needed to elaborate the `DFunLike.coe` in the statement below, whose `F` annotation spells
+domain and codomain on the `restrictScalars` side.
+
+The failure happens while applying `@LinearMap.instFunLike`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `Module ↑(S.obj X) ↑(P X)`, whereas the assigned value `(((pushforward φ).obj M).obj X).isModule`
+has type `Module ↑(S.obj X) ↑(((pushforward φ).obj M).obj X)`. The comparison bottoms out at
+`(ModuleCat.restrictScalars (RingCat.Hom.hom (φ.app X))).1 =?= ((pushforward φ).obj M).1`, the same
+module written once through `pushforward` and once through `restrictScalars`. Lean falls back to
+synthesize an instance of the correct type, which succeeds, but it returns
+```
+((ModuleCat.restrictScalars (RingCat.Hom.hom (φ.app X))).obj (((pushforward₀ F R).obj M).obj
+X)).isModule
+```
+This again not defeq to the assigned value, stalling in the same way. That second comparison runs at
+`.implicit`, but `pushforward` does not unfold there either.
+
+Potential fix: Mark `pushforward`, `PresheafOfModules.restrictScalars` and
+`PresheafOfModules.restrictScalarsObj` implicit-reducible; then both backward compatibility options
+can go.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `@[simp]`-normal form of `pushforward_obj_map_apply`. -/
@@ -123,6 +155,27 @@ lemma pushforward_map_app_apply {M N : PresheafOfModules.{v} R} (α : M ⟶ N) (
     (m : (ModuleCat.restrictScalars (φ.app X).hom).obj (M.obj (Opposite.op (F.obj X.unop)))) :
     (((pushforward φ).map α).app X).hom m = α.app (Opposite.op (F.obj X.unop)) m := rfl
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized, writing `P Z` for
+`(ModuleCat.restrictScalars (RingCat.Hom.hom (φ.app Z))).obj (((pushforward₀ F R).obj M).obj Z)`:
+`DFunLike (↑(P X) →ₗ[↑(S.obj X)] ↑((ModuleCat.restrictScalars (RingCat.Hom.hom (φ.app X))).obj
+  (((pushforward₀ F R).obj N).obj X))) _ _`
+It is needed to elaborate the `DFunLike.coe` in the statement below.
+
+This is the same failure as for `pushforward_obj_map_apply'` above, again while applying
+`@LinearMap.instFunLike`: the metavariable's expected type is `Module ↑(S.obj X) ↑(P X)`, the
+assigned value is `(((pushforward φ).obj M).obj X).isModule` of type
+`Module ↑(S.obj X) ↑(((pushforward φ).obj M).obj X)`, and both the direct `.instances` check and the
+comparison against the re-synthesized instance bottom out at
+`(ModuleCat.restrictScalars (RingCat.Hom.hom (φ.app X))).1 =?= ((pushforward φ).obj M).1`.
+
+Potential fix: Mark `pushforward`, `PresheafOfModules.restrictScalars` and
+`PresheafOfModules.restrictScalarsObj` implicit-reducible; then both backward compatibility options
+can go.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `@[simp]`-normal form of `pushforward_map_app_apply`. -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean
index 6e1d44b59..e0005acb4 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean
@@ -338,6 +338,43 @@ noncomputable def toSheafify : M₀ ⟶ (restrictScalars α).obj (sheafify α φ
 lemma toSheafify_app_apply (X : Cᵒᵖ) (x : M₀.obj X) :
     ((toSheafify α φ).app X).hom x = φ.app X x := rfl
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+```
+DFunLike (↑(M₀.obj X) →ₗ[↑(R₀.obj X)]
+    ↑((ModuleCat.restrictScalars (RingCat.Hom.hom (α.app X))).obj ((sheafify α φ).val.obj X)))
+  ↑(M₀.obj X) _
+```
+It is needed to elaborate the `DFunLike.coe` in the statement below.
+
+The failure happens while applying `@LinearMap.instFunLike`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type is
+```
+Module ↑(R₀.obj X) ↑((ModuleCat.restrictScalars (RingCat.Hom.hom (α.app X))).obj
+((sheafify α φ).val.obj X))
+```
+The assigned value
+```
+(((restrictScalars α).obj (sheafify α φ).val).obj X).isModule
+```
+has type `Module ↑(R₀.obj X) ↑(((restrictScalars α).obj (sheafify α φ).val).obj X)`, which is the
+same module written once through `PresheafOfModules.restrictScalars` and once through
+`ModuleCat.restrictScalars`. Lean falls back to synthesize an instance of the correct type, which
+succeeds, but the candidate is again not defeq to the assigned value. Both comparisons bottom out at
+```
+((restrictScalars α).obj (sheafify α φ).val).1 =?=
+(ModuleCat.restrictScalars (RingCat.Hom.hom (α.app X))).1
+```
+The second one runs at `.implicit`, where `PresheafOfModules.restrictScalars` does not unfold
+either.
+
+Potential fix: Mark `PresheafOfModules.restrictScalars` and `PresheafOfModules.restrictScalarsObj`
+implicit-reducible; then both backward compatibility options can go.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- `@[simp]`-normal form of `toSheafify_app_apply`. -/
 @[simp]
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean
index 8becc6ba6..76268197a 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean
@@ -53,6 +53,8 @@ lemma ext {N₁ N₂ : M.Submodule} (h : ∀ X, N₁.obj X = N₂.obj X) :
     N₁ = N₂ := by
   cases N₁; cases N₂; congr 1; ext X : 1; exact h X
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[grind .]
 lemma map_mem {X Y : Cᵒᵖ} (f : X ⟶ Y) {x : M.obj X} (hx : x ∈ N.obj X) :
     M.map f x ∈ N.obj Y :=
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Sheaf/LocallyFree.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Sheaf/LocallyFree.lean
index c157a2ada..aee7ac299 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Sheaf/LocallyFree.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Sheaf/LocallyFree.lean
@@ -92,6 +92,7 @@ instance (I : Type u) : IsIso (free.generatingSections (R := R) I).π := by
 variable [∀ X, HasSheafify (J.over X) AddCommGrpCat.{u}] [HasBinaryProducts C]
   [∀ X, (J.over X).WEqualsLocallyBijective AddCommGrpCat.{u}] [HasSheafify J AddCommGrpCat]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 instance (I : Type u) :
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
index 2ddca8bbb..e4dcce5c3 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
@@ -267,6 +267,7 @@ variable {R}
 
 variable {M : ModuleCat R} {I : Type*} {X : I → TopModuleCat R} (f : ∀ i, M ⟶ (X i).toModuleCat)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The induced topology on `M` from a family of continuous linear maps from `M`, which is the
 coarsest topology that makes every map continuous. -/
 def induced : TopModuleCat R :=
@@ -404,6 +405,9 @@ def freeObj (X : TopCat.{v}) : TopModuleCat.{max v u} R :=
 
 lemma coe_freeObj (X : TopCat.{v}) : freeObj R X = (X →₀ R) := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The free topological module over a topological space is functorial. -/
 noncomputable
@@ -421,9 +425,11 @@ def freeMap {X Y : TopCat.{v}} (f : X ⟶ Y) : freeObj R X ⟶ freeObj R Y :=
     ext x
     simp [coe_freeObj]⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
 lemma freeMap_map {X Y : TopCat.{v}} (f : X ⟶ Y) (v : X →₀ R) :
     (freeMap R f : (X →₀ R) → (Y →₀ R)) v = Finsupp.mapDomain f.hom v := rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
 set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The free topological module over a topological space as a functor.
 This is left adjoint to the forgetful functor. -/
@@ -434,6 +440,9 @@ def free : TopCat.{v} ⥤ TopModuleCat.{max v u} R :=
     map_id M := by ext x; exact DFunLike.congr_fun (Finsupp.lmapDomain_id _ _) x
     map_comp f g := by ext; exact DFunLike.congr_fun (Finsupp.lmapDomain_comp _ _ f.hom g.hom) _ }
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.outParams false in
+set_option backward.isDefEq.respectTransparency.instances false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- The free-forgetful adjoint for `TopModuleCat R`. -/
diff --git a/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean b/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
index cdb2705b7..7c900f7f5 100644
--- a/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
@@ -344,6 +344,7 @@ namespace Limits
 
 variable {J : Type u'} [SmallCategory J] (F : J ⥤ CommRingCat.{u}) {c : Cone F}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem isUnit_iff_forall_isUnit (hc : IsLimit c) (r : c.pt) : IsUnit r ↔
     ∀ (j : J), IsUnit (c.π.app j r) := by
@@ -484,6 +485,7 @@ def pullbackConeIsLimit (f : A ⟶ C) (g : B ⟶ C) :
 
 open WalkingCospan
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance pullbackFst_isLocalHom (f : A ⟶ C) (g : B ⟶ C) [IsLocalHom g.hom] :
     IsLocalHom (pullback.fst f g).hom := by
   refine Limits.π_isLocalHom _ (limit.isLimit _) left fun x hx i ↦ ?_
diff --git a/mathlib4/Mathlib/Algebra/Category/Ring/FilteredColimits.lean b/mathlib4/Mathlib/Algebra/Category/Ring/FilteredColimits.lean
index 6daebb16d..39ee48e86 100644
--- a/mathlib4/Mathlib/Algebra/Category/Ring/FilteredColimits.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Ring/FilteredColimits.lean
@@ -113,6 +113,7 @@ instance colimitSemiring : Semiring.{max v u} <| R.{v, u} F :=
 def colimit : SemiRingCat.{max v u} :=
   SemiRingCat.of <| R.{v, u} F
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit semiring. -/
 def colimitCocone : Cocone F where
   pt := colimit.{v, u} F
@@ -215,6 +216,7 @@ instance colimitCommSemiring : CommSemiring.{max v u} <| R.{v, u} F :=
 def colimit : CommSemiRingCat.{max v u} :=
   CommSemiRingCat.of <| R.{v, u} F
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit commutative semiring. -/
 def colimitCocone : Cocone F where
   pt := colimit.{v, u} F
@@ -273,6 +275,7 @@ instance colimitRing : Ring.{max v u} <| R.{v, u} F :=
 def colimit : RingCat.{max v u} :=
   RingCat.of <| R.{v, u} F
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit ring. -/
 def colimitCocone : Cocone F where
   pt := colimit.{v, u} F
@@ -336,6 +339,7 @@ instance colimitCommRing : CommRing.{max v u} <| R.{v, u} F :=
 def colimit : CommRingCat.{max v u} :=
   CommRingCat.of <| R.{v, u} F
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit commutative ring. -/
 def colimitCocone : Cocone F where
   pt := colimit.{v, u} F
diff --git a/mathlib4/Mathlib/Algebra/Colimit/DirectLimit.lean b/mathlib4/Mathlib/Algebra/Colimit/DirectLimit.lean
index c00d58f3f..272555f0e 100644
--- a/mathlib4/Mathlib/Algebra/Colimit/DirectLimit.lean
+++ b/mathlib4/Mathlib/Algebra/Colimit/DirectLimit.lean
@@ -523,6 +523,7 @@ instance [∀ i, AddZeroClass (G i)] [∀ i, DistribSMul R (G i)]
   smul_add r := DirectLimit.induction₂ _ fun i _ _ ↦ by
     simp_rw [add_def, smul_def, smul_add, add_def]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance [Monoid R] [∀ i, AddMonoid (G i)] [∀ i, DistribMulAction R (G i)]
     [∀ i j h, DistribMulActionHomClass (T h) R (G i) (G j)] :
     DistribMulAction R (DirectLimit G f) :=
@@ -634,6 +635,7 @@ lemma map₀_algebraMap (i : ι) (r : R) :
     map₀ f (fun i ↦ algebraMap R (G i) r) = ⟦⟨i, algebraMap R (G i) r⟩⟧ :=
   map₀_def _ _ (fun _ _ _ => AlgHomClass.commutes _ _) i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 instance : Algebra R (DirectLimit G f) where
   algebraMap := map₀RingHom (f := f).comp (algebraMap R (∀ i, G i))
@@ -661,6 +663,7 @@ variable [Semiring R] [∀ i, AddCommMonoid (G i)] [∀ i, Module R (G i)]
 variable [∀ i j h, LinearMapClass (T h) R (G i) (G j)]
 variable (R ι G f) [Nonempty ι]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The canonical map from a component to the direct limit. -/
 @[simps]
 def of (i) : G i →ₗ[R] DirectLimit G f where
@@ -674,6 +677,7 @@ theorem of_f {i j hij x} : of R ι G f j (f i j hij x) = of R ι G f i x := .sym
 
 variable {P : Type*} [AddCommMonoid P] [Module R P]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R ι G f) in
 /-- The universal property of the direct limit: maps from the components to another module
 that respect the directed system structure (i.e. make some diagram commute) give rise
@@ -899,6 +903,7 @@ variable [∀ i, NonUnitalNonAssocSemiring (G i)] [∀ i, DistribMulAction R (G
 variable [∀ i j h, NonUnitalAlgHomClass (T h) R (G i) (G j)]
 variable [Nonempty ι]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (G f) in
 /-- The canonical map from a component to the direct limit. -/
 def of (i) : G i →ₙₐ[R] DirectLimit G f where
@@ -910,6 +915,7 @@ lemma of_f {i j} (hij) (x) : of G f j (f i j hij x) = of G f i x := .symm <| eq_
 
 variable (P : Type*) [NonUnitalNonAssocSemiring P] [DistribMulAction R P]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (G f) in
 /-- The universal property of the direct limit: maps from the components to another R-algebra
 that respect the directed system structure (i.e. make some diagram commute) give rise
@@ -924,9 +930,11 @@ def lift (g : ∀ i, G i →ₙₐ[R] P) (Hg : ∀ i j hij x, g j (f i j hij x)
 
 variable (g : ∀ i, G i →ₙₐ[R] P) (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem lift_comp_of {i} : (lift G f P g Hg).comp (of G f i) = g i := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem lift_of (i x) : lift G f P g Hg (of G f i x) = g i x := rfl
 
 @[ext]
diff --git a/mathlib4/Mathlib/Algebra/Colimit/Module.lean b/mathlib4/Mathlib/Algebra/Colimit/Module.lean
index 9e4d148fa..cc4e85317 100644
--- a/mathlib4/Mathlib/Algebra/Colimit/Module.lean
+++ b/mathlib4/Mathlib/Algebra/Colimit/Module.lean
@@ -51,6 +51,7 @@ inductive DirectLimit.Eqv [DecidableEq ι] : DirectSum ι G → DirectSum ι G 
   | of_map {i j} (h : i ≤ j) (x : G i) :
     Eqv (DirectSum.lof R ι G i x) (DirectSum.lof R ι G j <| f i j h x)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The congruence relation to quotient the direct sum by to obtain the direct limit. -/
 def DirectLimit.moduleCon [DecidableEq ι] : ModuleCon R (DirectSum ι G) :=
   SMulCon.addConGen' (Eqv f) <| by rintro _ _ _ ⟨⟩; simpa only [← map_smul] using .of_map ..
@@ -91,6 +92,7 @@ variable {R ι G f}
 
 theorem quotMk_of (i x) : Quot.mk _ (.of G i x) = of R ι G f i x := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem of_f {i j hij x} : of R ι G f j (f i j hij x) = of R ι G f i x :=
   (AddCon.eq _).mpr <| .symm <| .of _ _ (.of_map _ _)
@@ -123,6 +125,7 @@ protected theorem induction_on [Nonempty ι] [IsDirectedOrder ι] {C : DirectLim
 
 variable {P : Type*} [AddCommMonoid P] [Module R P]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R ι G f) in
 /-- The universal property of the direct limit: maps from the components to another module
 that respect the directed system structure (i.e. make some diagram commute) give rise
@@ -135,6 +138,7 @@ def lift (g : ∀ i, G i →ₗ[R] P) (Hg : ∀ i j hij x, g j (f i j hij x) = g
 
 variable (g : ∀ i, G i →ₗ[R] P) (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] theorem lift_of {i} (x) : lift R ι G f g Hg (of R ι G f i x) = g i x :=
   DirectSum.toModule_lof R _ _
 
diff --git a/mathlib4/Mathlib/Algebra/DirectSum/Algebra.lean b/mathlib4/Mathlib/Algebra/DirectSum/Algebra.lean
index cdaafbd69..02dd38b7d 100644
--- a/mathlib4/Mathlib/Algebra/DirectSum/Algebra.lean
+++ b/mathlib4/Mathlib/Algebra/DirectSum/Algebra.lean
@@ -106,6 +106,7 @@ theorem algebraMap_toAddMonoid_hom :
     ↑(algebraMap R (⨁ i, A i)) = (DirectSum.of A 0).comp (GAlgebra.toFun : R →+ A 0) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A family of `LinearMap`s preserving `DirectSum.GOne.one` and `DirectSum.GMul.mul`
 describes an `AlgHom` on `⨁ i, A i`. This is a stronger version of `DirectSum.toSemiring`.
 
diff --git a/mathlib4/Mathlib/Algebra/DirectSum/Decomposition.lean b/mathlib4/Mathlib/Algebra/DirectSum/Decomposition.lean
index fb3138888..d803ac190 100644
--- a/mathlib4/Mathlib/Algebra/DirectSum/Decomposition.lean
+++ b/mathlib4/Mathlib/Algebra/DirectSum/Decomposition.lean
@@ -256,6 +256,7 @@ abbrev Decomposition.ofLinearMap (decompose : M →ₗ[R] ⨁ i, ℳ i)
 
 variable [Decomposition ℳ]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `M` is graded by `ι` with degree `i` component `ℳ i`, then it is isomorphic as
 a module to a direct sum of components. -/
 def decomposeLinearEquiv : M ≃ₗ[R] ⨁ i, ℳ i :=
@@ -268,6 +269,7 @@ theorem decomposeLinearEquiv_apply (m : M) :
 theorem decomposeLinearEquiv_symm_apply (m : ⨁ i, ℳ i) :
     (decomposeLinearEquiv ℳ).symm m = (decompose ℳ).symm m := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem decompose_smul (r : R) (x : M) : decompose ℳ (r • x) = r • decompose ℳ x :=
   map_smul (decomposeLinearEquiv ℳ) r x
diff --git a/mathlib4/Mathlib/Algebra/Group/Action/Sigma.lean b/mathlib4/Mathlib/Algebra/Group/Action/Sigma.lean
index f593f1244..e0e835c84 100644
--- a/mathlib4/Mathlib/Algebra/Group/Action/Sigma.lean
+++ b/mathlib4/Mathlib/Algebra/Group/Action/Sigma.lean
@@ -38,6 +38,7 @@ variable [∀ i, SMul M (α i)] [∀ i, SMul N (α i)] (a : M) (i : ι) (b : α
 instance : SMul M (Σ i, α i) :=
   ⟨fun a => (Sigma.map id) fun _ => (a • ·)⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 theorem smul_def : a • x = x.map id fun _ => (a • ·) :=
   rfl
diff --git a/mathlib4/Mathlib/Algebra/Group/ForwardDiff.lean b/mathlib4/Mathlib/Algebra/Group/ForwardDiff.lean
index 895643625..0abd31c1e 100644
--- a/mathlib4/Mathlib/Algebra/Group/ForwardDiff.lean
+++ b/mathlib4/Mathlib/Algebra/Group/ForwardDiff.lean
@@ -140,6 +140,7 @@ open fwdDiff_aux
 
 section newton_formulae
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 Express the `n`-th forward difference of `f` at `y` in terms of the values `f (y + k)`, for
 `0 ≤ k ≤ n`.
diff --git a/mathlib4/Mathlib/Algebra/Group/Hom/Defs.lean b/mathlib4/Mathlib/Algebra/Group/Hom/Defs.lean
index 5aa3b8cc6..0284322a8 100644
--- a/mathlib4/Mathlib/Algebra/Group/Hom/Defs.lean
+++ b/mathlib4/Mathlib/Algebra/Group/Hom/Defs.lean
@@ -259,7 +259,7 @@ theorem ne_one_of_map {R S F : Type*} [One R] [One S] [FunLike F R S] [OneHomCla
 
 /-- Turn an element of a type `F` satisfying `OneHomClass F M N` into an actual
 `OneHom`. This is declared as the default coercion from `F` to `OneHom M N`. -/
-@[to_additive (attr := coe)
+@[to_additive (attr := coe, instance_reducible)
 /-- Turn an element of a type `F` satisfying `ZeroHomClass F M N` into an actual
 `ZeroHom`. This is declared as the default coercion from `F` to `ZeroHom M N`. -/]
 def OneHomClass.toOneHom [OneHomClass F M N] (f : F) : OneHom M N where
@@ -332,7 +332,7 @@ lemma map_comp_mul [MulHomClass F M N] (f : F) (g h : ι → M) : f ∘ (g * h)
 
 /-- Turn an element of a type `F` satisfying `MulHomClass F M N` into an actual
 `MulHom`. This is declared as the default coercion from `F` to `M →ₙ* N`. -/
-@[to_additive (attr := coe)
+@[to_additive (attr := coe, instance_reducible)
 /-- Turn an element of a type `F` satisfying `AddHomClass F M N` into an actual
 `AddHom`. This is declared as the default coercion from `F` to `M →ₙ+ N`. -/]
 def MulHomClass.toMulHom [MulHomClass F M N] (f : F) : M →ₙ* N where
@@ -400,7 +400,7 @@ variable [FunLike F M N]
 
 /-- Turn an element of a type `F` satisfying `MonoidHomClass F M N` into an actual
 `MonoidHom`. This is declared as the default coercion from `F` to `M →* N`. -/
-@[to_additive (attr := coe)
+@[to_additive (attr := coe, instance_reducible)
 /-- Turn an element of a type `F` satisfying `AddMonoidHomClass F M N` into an
 actual `MonoidHom`. This is declared as the default coercion from `F` to `M →+ N`. -/]
 def MonoidHomClass.toMonoidHom [MonoidHomClass F M N] (f : F) : M →* N :=
diff --git a/mathlib4/Mathlib/Algebra/Homology/Embedding/AreComplementary.lean b/mathlib4/Mathlib/Algebra/Homology/Embedding/AreComplementary.lean
index bb6317c8d..726fe0ac0 100644
--- a/mathlib4/Mathlib/Algebra/Homology/Embedding/AreComplementary.lean
+++ b/mathlib4/Mathlib/Algebra/Homology/Embedding/AreComplementary.lean
@@ -309,6 +309,8 @@ noncomputable def shortComplexTruncLEX₃ToTruncGE :
     (K.shortComplexTruncLE e₁).X₃ ⟶ K.truncGE e₂ :=
   cokernel.desc _ (K.πTruncGE e₂) (ac.hom_ext _)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp)]
 lemma g_shortComplexTruncLEX₃ToTruncGE :
     (K.shortComplexTruncLE e₁).g ≫ K.shortComplexTruncLEX₃ToTruncGE ac = K.πTruncGE e₂ :=
diff --git a/mathlib4/Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean b/mathlib4/Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
index d7dba586b..504fb8185 100644
--- a/mathlib4/Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
+++ b/mathlib4/Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
@@ -292,6 +292,39 @@ lemma rightShift_smul (a n' : ℤ) (hn' : n' + a = n) (x : R) :
   dsimp
   simp only [rightShift_v _ a n' hn' p q hpq _ rfl, smul_v, Linear.smul_comp]
 
+#adaptation_note
+/--
+We had to mark `CochainComplex.shiftFunctor` implicit-reducible locally to make an instance search
+succeed. Concretely, the following instance cannot be synthesized:
+`SMulCommClass R ℤˣ (K.X (p + a) ⟶ L.X q)`
+It is needed because `leftShift` carries a sign `u : ℤˣ`, so the closing `simp only` fires
+`smul_comm x`.
+
+The failure happens while applying `@Units.smulCommClass_right`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `SMul R (K.X (p + a) ⟶ L.X q)`, whereas the assigned value
+`DistribMulAction.toDistribSMul.toSMul` has type
+```
+SMul R (((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K).X p ⟶ L.X q)
+```
+Lean falls back to synthesize an instance of the correct type, but the candidate is again not defeq
+to the result. Both comparisons bottom out at
+```
+K.X (p + a) ⟶ L.X q =?= ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K).X p ⟶ L.X q
+```
+Since `SMulCommClass` stays unsynthesizable, `smul_comm x` never fires and the goal
+`u • x • f = x • u • f` is left unsolved.
+
+`CategoryTheory.shiftFunctor` is already `@[implicit_reducible]`, but the
+`CochainComplex.shiftFunctor` underneath it is semireducible, so the two hom types cannot be seen
+to agree at either transparency. Marking it implicit-reducible makes the assignment go through,
+since Lean bumps transparency for instance-implicit arguments to `implicit`.
+
+Potential fix: mark `CochainComplex.shiftFunctor` implicit-reducible at its definition site; then
+the local `attribute` and `allowUnsafeReducibility` here can be dropped.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 lemma leftShift_smul (a n' : ℤ) (hn' : n + a = n') (x : R) :
@@ -357,6 +390,7 @@ lemma shift_units_smul (a : ℤ) (x : Rˣ) :
   dsimp
   simp only [shift_v', units_smul_v]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma rightUnshift_smul {n' a : ℤ} (γ : Cochain K (L⟦a⟧) n') (n : ℤ) (hn : n' + a = n) (x : R) :
     (x • γ).rightUnshift n hn = x • γ.rightUnshift n hn := by
@@ -369,6 +403,7 @@ lemma rightUnshift_units_smul {n' a : ℤ} (γ : Cochain K (L⟦a⟧) n') (n : 
     (x • γ).rightUnshift n hn = x • γ.rightUnshift n hn := by
   apply rightUnshift_smul
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma leftUnshift_smul {n' a : ℤ} (γ : Cochain (K⟦a⟧) L n') (n : ℤ) (hn : n + a = n') (x : R) :
     (x • γ).leftUnshift n hn = x • γ.leftUnshift n hn := by
diff --git a/mathlib4/Mathlib/Algebra/Homology/SpectralObject/Cycles.lean b/mathlib4/Mathlib/Algebra/Homology/SpectralObject/Cycles.lean
index 8720cc8a2..983ef28c8 100644
--- a/mathlib4/Mathlib/Algebra/Homology/SpectralObject/Cycles.lean
+++ b/mathlib4/Mathlib/Algebra/Homology/SpectralObject/Cycles.lean
@@ -294,6 +294,8 @@ noncomputable def toCycles (n : ℤ) :
     (X.H n).obj (mk₁ fg) ⟶ X.cycles f g n :=
   kernel.lift _ ((X.H n).map (twoδ₁Toδ₀ f g fg h)) (by simp)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (n : ℤ) : Epi (X.toCycles f g fg h n) :=
   (ShortComplex.exact_iff_epi_kernel_lift _).1 (X.exact₃ f g fg h n (n + 1))
 
@@ -325,6 +327,8 @@ noncomputable def fromOpcycles (n : ℤ) :
     X.opcycles f g n ⟶ (X.H n).obj (mk₁ fg) :=
   cokernel.desc _ ((X.H n).map (twoδ₂Toδ₁ f g fg h)) (by simp)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (n : ℤ) : Mono (X.fromOpcycles f g fg h n) :=
   (ShortComplex.exact_iff_mono_cokernel_desc _).1 (X.exact₁ f g fg h (n - 1) n)
 
diff --git a/mathlib4/Mathlib/Algebra/Lie/Abelian.lean b/mathlib4/Mathlib/Algebra/Lie/Abelian.lean
index f5aeda58e..be9b489f1 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Abelian.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Abelian.lean
@@ -205,6 +205,7 @@ theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M
 
 variable {R L M N}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `maxTrivSubmodule` is functorial. -/
 def maxTrivHom (f : M →ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M →ₗ⁅R,L⁆ maxTrivSubmodule R L N where
diff --git a/mathlib4/Mathlib/Algebra/Lie/BaseChange.lean b/mathlib4/Mathlib/Algebra/Lie/BaseChange.lean
index 75dd94397..0cbe83d88 100644
--- a/mathlib4/Mathlib/Algebra/Lie/BaseChange.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/BaseChange.lean
@@ -111,6 +111,7 @@ instance instLieRing : LieRing (A ⊗[R] L) where
 
 instance instBaseLieAlgebra : LieAlgebra R (A ⊗[R] L) where lie_smul := by simp [bracket_def]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance instLieAlgebra : LieAlgebra A (A ⊗[R] L) where lie_smul _a _x _y := map_smul _ _ _
 
 set_option backward.privateInPublic true in
@@ -120,6 +121,7 @@ instance instLieRingModule : LieRingModule (A ⊗[R] L) (A ⊗[R] M) where
   lie_add x y z := by simp only [bracket_def, map_add]
   leibniz_lie := bracket_leibniz_lie R A L M
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance instLieModule : LieModule A (A ⊗[R] L) (A ⊗[R] M) where
   smul_lie t x m := by simp only [bracket_def, map_smul, LinearMap.smul_apply]
@@ -183,6 +185,7 @@ variable (N : LieSubmodule R L M)
 
 open LieModule
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable {R L M} in
 /-- If `A` is an `R`-algebra, any Lie submodule of a Lie module `M` with coefficients in `R` may be
diff --git a/mathlib4/Mathlib/Algebra/Lie/Basic.lean b/mathlib4/Mathlib/Algebra/Lie/Basic.lean
index 381271a19..559abaaef 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Basic.lean
@@ -245,6 +245,7 @@ instance : LieModule ℤ L M where
   smul_lie n x m := zsmul_lie x m n
   lie_smul n x m := lie_zsmul x m n
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance LinearMap.instLieRingModule : LieRingModule L (M →ₗ[R] N) where
   bracket x f :=
@@ -271,6 +272,7 @@ instance LinearMap.instLieRingModule : LieRingModule L (M →ₗ[R] N) where
 theorem LieHom.lie_apply (f : M →ₗ[R] N) (x : L) (m : M) : ⁅x, f⁆ m = ⁅x, f m⁆ - f ⁅x, m⁆ :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance LinearMap.instLieModule : LieModule R L (M →ₗ[R] N) where
   smul_lie t x f := by
@@ -486,6 +488,7 @@ theorem LieRingModule.compLieHom_apply (x : L₁) (m : M) :
     ⁅x, m⁆ = ⁅f x, m⁆ :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A Lie module may be pulled back along a morphism of Lie algebras. -/
 theorem LieModule.compLieHom [Module R M] [LieModule R L₂ M] :
@@ -564,6 +567,7 @@ theorem toLinearEquiv_injective : Injective ((↑) : (L₁ ≃ₗ⁅R⁆ L₂) 
 theorem coe_injective : @Injective (L₁ ≃ₗ⁅R⁆ L₂) (L₁ → L₂) (↑) :=
   LinearEquiv.coe_injective.comp toLinearEquiv_injective
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : LinearEquivClass (L₁ ≃ₗ⁅R⁆ L₂) R L₁ L₂ where
   map_add _ _ _ := by
     rw [← coe_toLinearEquiv, map_add]
@@ -947,6 +951,7 @@ theorem toEquiv_injective : Function.Injective (toEquiv : (M ≃ₗ⁅R,L⁆ N)
 theorem ext (e₁ e₂ : M ≃ₗ⁅R,L⁆ N) (h : ∀ m, e₁ m = e₂ m) : e₁ = e₂ :=
   toEquiv_injective (Equiv.ext h)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : LinearEquivClass (M ≃ₗ⁅R,L⁆ N) R M N where
   map_add _ _ _ := by
     rw [← coe_toLinearEquiv, map_add]
diff --git a/mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean b/mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean
index 0b0ee9794..00a32c56d 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean
@@ -300,6 +300,7 @@ lemma linearIndependent_baseSupp [IsDomain R] [CharZero R] :
   have hv : LinearIndependent R v := Basis.linearIndependent_coord _
   simpa [Int.cast_smul_eq_zsmul] using! hv.sum_smul_of_nondegenerate this
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma baseSupp_apply_smul_e (i : ι) (x : H) :
     b.baseSupp i x • b.e i = ⁅x, b.e i⁆ := by
   obtain ⟨x, hx⟩ := x
diff --git a/mathlib4/Mathlib/Algebra/Lie/CartanCriterion.lean b/mathlib4/Mathlib/Algebra/Lie/CartanCriterion.lean
index 5eb3e2e7a..db30a4989 100644
--- a/mathlib4/Mathlib/Algebra/Lie/CartanCriterion.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/CartanCriterion.lean
@@ -70,6 +70,7 @@ lemma exists_polynomial_eval_sub_aux
 variable [AddCommGroup M] [LieRingModule L M]
 attribute [local instance 100] LieRing.ofAssociativeRing
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An auxiliary lemma used to prove `LieModule.isNilpotent_derivedSeries_of_traceForm_eq_zero`
 which proves the same result except without the algebraically closed assumption. -/
 theorem isNilpotent_derivedSeries_of_traceForm_eq_zero_aux {K : Type*}
diff --git a/mathlib4/Mathlib/Algebra/Lie/CartanExists.lean b/mathlib4/Mathlib/Algebra/Lie/CartanExists.lean
index 64c74afcf..d28e96f0d 100644
--- a/mathlib4/Mathlib/Algebra/Lie/CartanExists.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/CartanExists.lean
@@ -95,6 +95,7 @@ set_option backward.privateInPublic.warn false in
 lemma lieCharpoly_natDegree [Nontrivial R] : (lieCharpoly R M x y).natDegree = finrank R M := by
   rw [lieCharpoly, (polyCharpoly_monic _ _).natDegree_map, polyCharpoly_natDegree]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.privateInPublic true in
 set_option backward.privateInPublic.warn false in
 variable {R} in
diff --git a/mathlib4/Mathlib/Algebra/Lie/Character.lean b/mathlib4/Mathlib/Algebra/Lie/Character.lean
index 230e525f1..8bf66f495 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Character.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Character.lean
@@ -49,6 +49,7 @@ theorem lieCharacter_apply_lie (χ : LieCharacter R L) (x y : L) : χ ⁅x, y⁆
 theorem lieCharacter_apply_lie' (χ : LieCharacter R L) (x y : L) : ⁅χ x, χ y⁆ = 0 := by
   rw [LieRing.of_associative_ring_bracket, mul_comm, sub_self]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem lieCharacter_apply_of_mem_derived (χ : LieCharacter R L) {x : L}
     (h : x ∈ derivedSeries R L 1) : χ x = 0 := by
   rw [derivedSeries_def, derivedSeriesOfIdeal_succ, derivedSeriesOfIdeal_zero, ←
diff --git a/mathlib4/Mathlib/Algebra/Lie/Cochain.lean b/mathlib4/Mathlib/Algebra/Lie/Cochain.lean
index 4370193d3..5659934a0 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Cochain.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Cochain.lean
@@ -118,6 +118,7 @@ lemma d₁₂_apply_apply_ofTrivial [LieModule.IsTrivial L M] (f : oneCochain R
     d₁₂ R L M f x y = - f ⁅x, y⁆ := by
   simp [trivial_lie_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The coboundary operator taking degree 2 cochains to a space containing degree 3 cochains. -/
 def d₂₃ : twoCochain R L M →ₗ[R] L →ₗ[R] L →ₗ[R] L →ₗ[R] M where
   toFun a := {
diff --git a/mathlib4/Mathlib/Algebra/Lie/Derivation/Basic.lean b/mathlib4/Mathlib/Algebra/Lie/Derivation/Basic.lean
index 564378d8f..44894a344 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Derivation/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Derivation/Basic.lean
@@ -107,6 +107,7 @@ lemma apply_lie_eq_add (D : LieDerivation R L L) (a b : L) :
     D ⁅a, b⁆ = ⁅a, D b⁆ + ⁅D a, b⁆ := by
   rw [LieDerivation.apply_lie_eq_sub, sub_eq_add_neg, lie_skew]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Two Lie derivations equal on a set are equal on its Lie span. -/
 theorem eqOn_lieSpan {s : Set L} (h : Set.EqOn D1 D2 s) :
@@ -318,6 +319,7 @@ instance : LieRing (LieDerivation R L L) where
   leibniz_lie d e f := by
     ext a; simp only [commutator_apply, add_apply, map_sub]; abel
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The set of Lie derivations from a Lie algebra `L` to itself is a Lie algebra. -/
 instance instLieAlgebra : LieAlgebra R (LieDerivation R L L) where
@@ -383,6 +385,7 @@ instance instLieRingModule : LieRingModule L (LieDerivation R L M) where
     ⁅x, (D : L →ₗ[R] M)⁆ = ⁅x, D⁆ := by
   ext; simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance instLieModule : LieModule R L (LieDerivation R L M) where
   smul_lie t x D := by ext; simp
diff --git a/mathlib4/Mathlib/Algebra/Lie/Extension.lean b/mathlib4/Mathlib/Algebra/Lie/Extension.lean
index 80fbb9a4f..75460b534 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Extension.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Extension.lean
@@ -299,6 +299,7 @@ lemma lie_incl_mem_ker {E : Extension R M L} (x : E.L) (y : M) :
     ⁅x, E.incl y⁆ ∈ E.proj.ker := by
   rw [LieHom.mem_ker, LieHom.map_lie, proj_incl, lie_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- The Lie algebra isomorphism from the kernel of an extension to the kernel of the projection. -/
 noncomputable def toKer (E : Extension R M L) :
@@ -351,6 +352,7 @@ lemma ringModuleOf_bracket_proj [IsLieAbelian M] (E : Extension R M L) (y : M) (
     Subtype.ext_iff, LieSubmodule.coe_bracket, lie_toKer_apply, ZeroMemClass.coe_zero, ← hx,
     LieHom.coe_toLinearMap, ← LieHom.map_lie, trivial_lie_zero M M x y, map_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given an extension of `L` by `M` whose kernel `M` is abelian, the kernel `M` gets an `R`-linear
 `L`-module structure. We do not make this an instance, because we may have to work with more than
 one extension. -/
@@ -423,6 +425,7 @@ noncomputable def twoCocycleOf [IsLieAbelian M] (E : Extension R M L) {s : L →
       sub_add_cancel_right, map_add, neg_add_rev]
     abel_nf
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The 1-cochain attached to a pair of splittings of an extension. -/
 @[simps]
 noncomputable def oneCochainOfTwoSplitting (E : Extension R M L) {s₁ s₂ : L →ₗ[R] E.L}
diff --git a/mathlib4/Mathlib/Algebra/Lie/Free.lean b/mathlib4/Mathlib/Algebra/Lie/Free.lean
index 83833f85c..a430832ce 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Free.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Free.lean
@@ -185,6 +185,7 @@ variable {L : Type w} [LieRing L] [LieAlgebra R L]
 def liftAux (f : X → CommutatorRing L) :=
   lib.lift R f
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem liftAux_map_smul (f : X → L) (t : R) (a : lib R X) :
     liftAux R f (t • a) = t • liftAux R f a :=
   map_smul _ t a
diff --git a/mathlib4/Mathlib/Algebra/Lie/Graded.lean b/mathlib4/Mathlib/Algebra/Lie/Graded.lean
index 5c7729945..644e27a48 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Graded.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Graded.lean
@@ -83,6 +83,7 @@ lemma decompose_symm_bracket (x y : ⨁ i, ℒ i) :
   simp only [← decomposeLinearEquiv_symm_apply]
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance : LieAlgebra R (⨁ i, ℒ i) where
   add_smul _ _ _ := by simp [add_smul]
@@ -142,6 +143,7 @@ lemma ofGradingSum_of (φ : ι →+ R) (i : ι) (a : ℒ i) :
     ofGradingSum ℒ φ (of (ℒ ·) i a) = (φ i) • (of (ℒ ·) i a) := by
   simp [← lof_eq_of R, ofGradingSum]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The Lie derivation on a graded Lie algebra that scalar-multiplies by an additive function of
 the degree. -/
@@ -152,6 +154,7 @@ def ofGrading (φ : ι →+ R) :
   map_smul' _ _ := by simp
   leibniz' x y := by simp [decomposeLinearEquiv_apply, decomposeLinearEquiv_symm_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma ofGrading_apply_apply (φ : ι →+ R) {i : ι} {a : L} (ha : a ∈ ℒ i) :
     ofGrading ℒ φ a = φ i • a := by
diff --git a/mathlib4/Mathlib/Algebra/Lie/Loop.lean b/mathlib4/Mathlib/Algebra/Lie/Loop.lean
index 7ce93dfbd..4d3cf1a94 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Loop.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Loop.lean
@@ -122,6 +122,7 @@ lemma toFinsupp_single_tmul (c : A) (z : L) :
     (toFinsupp R A L (AddMonoidAlgebra.single c 1 ⊗ₜ[R] z)) = Finsupp.single c z := by
   simp [← toFinsupp_symm_single]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open Finsupp in
 set_option backward.isDefEq.respectTransparency false in
 /-- The residue pairing on the loop algebra.  When `A = ℤ` and the elements are viewed as Laurent
diff --git a/mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean b/mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean
index 0532ebe7a..be02de91b 100644
--- a/mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean
@@ -96,6 +96,7 @@ instance : LieRing (K ⋊⁅ψ⁆ L) where
   lie_self _ := by simp
   leibniz_lie _ _ _ := by simp; grind [lie_skew]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance : LieAlgebra R (K ⋊⁅ψ⁆ L) where
   lie_smul _ _ _ := by simp [smul_sub, smul_add]
diff --git a/mathlib4/Mathlib/Algebra/Lie/Semisimple/Lemmas.lean b/mathlib4/Mathlib/Algebra/Lie/Semisimple/Lemmas.lean
index 37d353285..4e12cad34 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Semisimple/Lemmas.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Semisimple/Lemmas.lean
@@ -79,6 +79,7 @@ theorem hasTrivialRadical_of_isIrreducible_of_isFaithful
 variable {k L M}
 variable {R : Type*} [CommRing R] [LieAlgebra R L] [Module R M] [LieModule R L M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open LinearMap in
 lemma trace_toEnd_eq_zero {s : Set L} (hs : ∀ x ∈ s, LinearMap.trace R _ (toEnd R _ M x) = 0)
     {x : L} (hx : x ∈ LieSubalgebra.lieSpan R L s) :
diff --git a/mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean b/mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean
index 08df1c027..fd5ff8a36 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean
@@ -548,6 +548,8 @@ variable {K K'} in
 
 variable (R L)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance wellFoundedGT_of_noetherian [IsNoetherian R L] : WellFoundedGT (LieSubalgebra R L) :=
   RelHomClass.isWellFounded (⟨toSubmodule, @fun _ _ h ↦ h⟩ : _ →r (· > ·))
 
diff --git a/mathlib4/Mathlib/Algebra/Lie/TensorProduct.lean b/mathlib4/Mathlib/Algebra/Lie/TensorProduct.lean
index 3db802952..fbb1ba22e 100644
--- a/mathlib4/Mathlib/Algebra/Lie/TensorProduct.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/TensorProduct.lean
@@ -66,6 +66,7 @@ instance lieRingModule : LieRingModule L (M ⊗[R] N) where
       map_add, LieHom.lie_apply, Module.End.lie_apply, LinearMap.lTensor_tmul]
     abel
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The tensor product of two Lie modules is a Lie module. -/
 instance lieModule : LieModule R L (M ⊗[R] N) where
diff --git a/mathlib4/Mathlib/Algebra/Lie/TraceForm.lean b/mathlib4/Mathlib/Algebra/Lie/TraceForm.lean
index b8117c7d2..337fa99c4 100644
--- a/mathlib4/Mathlib/Algebra/Lie/TraceForm.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/TraceForm.lean
@@ -114,6 +114,7 @@ open scoped TensorProduct in
     traceForm A (A ⊗[R] L) (A ⊗[R] M) = (traceForm R L M).baseChange A := by
   ext; simp [traceForm_apply_apply, ← LinearMap.baseChange_comp, Algebra.algebraMap_eq_smul_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable {R L M} in
 lemma trace_toEnd_mul_eq_zero_of_traceForm_eq_zero (h : traceForm R L M = 0)
     (y : End R M) (hy : ∀ z ∈ LieHom.range φ, ⁅y, z⁆ ∈ LieHom.range φ)
@@ -134,6 +135,7 @@ lemma trace_toEnd_mul_eq_zero_of_traceForm_eq_zero (h : traceForm R L M = 0)
   | add u v _ _ hu hv => simp [add_mul, hu, hv]
   | smul t u _ hu => simp [hu]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma traceForm_genWeightSpace_eq [Module.Free R M]
     [IsDomain R] [IsPrincipalIdealRing R]
@@ -216,6 +218,7 @@ lemma eq_zero_of_mem_genWeightSpace_mem_posFitting [LieRing.IsNilpotent L]
   obtain ⟨m, rfl⟩ := (mem_posFittingCompOf R x m₁).mp hm₁ k
   simp [hB, hk]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma trace_toEnd_eq_zero_of_mem_lcs
     {k : ℕ} {x : L} (hk : 1 ≤ k) (hx : x ∈ lowerCentralSeries R L L k) :
     trace R _ (toEnd R L M x) = 0 := by
diff --git a/mathlib4/Mathlib/Algebra/Lie/TransferInstance.lean b/mathlib4/Mathlib/Algebra/Lie/TransferInstance.lean
index c5f8ac587..7b0d22ce3 100644
--- a/mathlib4/Mathlib/Algebra/Lie/TransferInstance.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/TransferInstance.lean
@@ -39,6 +39,7 @@ lemma AddEquiv.bracket_def (e : M ≃+ L) (x y : M) :
     letI := e.lieRing
     ⁅x, y⁆ = e.symm ⁅e x, e y⁆ := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Transfer `LieAlgebra` across a `LinearEquiv` -/
 protected abbrev LinearEquiv.lieAlgebra (e : M ≃ₗ[R] L) :
     letI := e.toAddEquiv.lieRing
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/Basic.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/Basic.lean
index d7a5aac91..4aba6a4a1 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/Basic.lean
@@ -72,6 +72,7 @@ section notation_genWeightSpaceOf
 /-- Until we define `LieModule.genWeightSpaceOf`, it is useful to have some notation as follows: -/
 local notation3 "𝕎("M", " χ", " x")" => (toEnd R L M x).maxGenEigenspace χ
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- See also `bourbaki1975b` Chapter VII §1.1, Proposition 2 (ii). -/
 protected theorem weight_vector_multiplication (M₁ M₂ M₃ : Type*)
     [AddCommGroup M₁] [Module R M₁] [LieRingModule L M₁] [LieModule R L M₁] [AddCommGroup M₂]
@@ -506,6 +507,7 @@ lemma map_posFittingComp_le :
   use f n
   rw [LieModule.toEnd_pow_apply_map, hn]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma map_genWeightSpace_le :
     (genWeightSpace M χ).map f ≤ genWeightSpace M₂ χ := by
   rw [LieSubmodule.map_le_iff_le_comap]
@@ -520,6 +522,7 @@ lemma map_genWeightSpace_le :
 
 variable {f}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma comap_genWeightSpace_eq_of_injective (hf : Injective f) :
     (genWeightSpace M₂ χ).comap f = genWeightSpace M χ := by
   refine le_antisymm (fun m hm ↦ ?_) ?_
@@ -735,6 +738,7 @@ lemma iSup_genWeightSpaceOf_eq_top [IsTriangularizable R L M] (x : L) :
   dsimp [genWeightSpaceOf]
   exact IsTriangularizable.maxGenEigenspace_eq_top x
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open LinearMap Module in
 @[simp]
 lemma trace_toEnd_genWeightSpace [IsDomain R] [IsPrincipalIdealRing R]
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/Chain.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/Chain.lean
index 92e837262..846b44ccb 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/Chain.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/Chain.lean
@@ -174,6 +174,7 @@ section IsCartanSubalgebra
 variable [H.IsCartanSubalgebra] [IsNoetherian R L]
 attribute [local instance 100] LieRing.ofAssociativeRing
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma trace_toEnd_genWeightSpaceChain_eq_zero
     (hp : genWeightSpace M (p • α + χ) = ⊥)
     (hq : genWeightSpace M (q • α + χ) = ⊥)
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/IsSimple.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/IsSimple.lean
index 6fb2317ca..57587412d 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/IsSimple.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/IsSimple.lean
@@ -293,6 +293,7 @@ private theorem chi_in_q_aux (h_chi_in_q : ↑χ ∈ q) :
 
 include hq hα₀ hy
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private theorem chi_not_in_q_aux (h_chi_not_in_q : ↑χ ∉ q) :
     ⁅x_χ, m_α⁆ ∈ ⨆ α : {α : Weight K H L // ↑α ∈ q ∧ α.IsNonZero}, sl2SubmoduleOfRoot α.2.2 := by
   let S := rootSystem H
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/Killing.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/Killing.lean
index 5913e4f43..2ad88c21d 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/Killing.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/Killing.lean
@@ -239,6 +239,7 @@ variable {K L H}
 noncomputable def coroot (α : Weight K H L) : H :=
   2 • (α <| (cartanEquivDual H).symm α)⁻¹ • (cartanEquivDual H).symm α
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma traceForm_coroot (α : Weight K H L) (x : H) :
     traceForm K H L (coroot α) x = 2 • (α <| (cartanEquivDual H).symm α)⁻¹ • α x := by
   have : cartanEquivDual H ((cartanEquivDual H).symm α) x = α x := by
@@ -473,6 +474,7 @@ lemma coe_corootSpace_eq_span_singleton (α : Weight K H L) :
     change (K ∙ (2 • (α α')⁻¹ • α')) = _
     simpa [← Nat.cast_smul_eq_nsmul K, smul_smul] using Submodule.span_singleton_smul_eq this _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma eq_coroot_of_mem_corootSpace_of_two (α : Weight K H L) {x : H}
     (h_mem : x ∈ corootSpace α) (h_two : α x = 2) :
     x = coroot α := by
@@ -552,6 +554,7 @@ lemma traceForm_eq_zero_of_mem_ker_of_mem_span_coroot {α : Weight K H L} {x y :
         root_apply_coroot hβ]
     · simp [root_apply_coroot hα]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma exists_isSl2Triple_of_weight_isNonZero {α : Weight K H L} (hα : α.IsNonZero) :
     ∃ h e f : L, IsSl2Triple h e f ∧ e ∈ rootSpace H α ∧ f ∈ rootSpace H (-α) := by
   obtain ⟨e, heα : e ∈ rootSpace H α, he₀ : e ≠ 0⟩ := α.exists_ne_zero
@@ -580,6 +583,7 @@ lemma exists_isSl2Triple_of_weight_isNonZero {α : Weight K H L} (hα : α.IsNon
     rw [lie_smul, lie_smul, smul_lie, this]
     simp [← smul_assoc, f, hh, mul_comm _ (2 * (α h)⁻¹)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma _root_.IsSl2Triple.h_eq_coroot {α : Weight K H L} (hα : α.IsNonZero)
     {h e f : L} (ht : IsSl2Triple h e f) (heα : e ∈ rootSpace H α) (hfα : f ∈ rootSpace H (-α)) :
     h = coroot α := by
@@ -693,6 +697,7 @@ lemma coe_coroot_mem_corootSubmodule (α : Weight K H L) :
   (LieSubmodule.mem_map _).mpr
     ⟨⟨coroot α, (coroot α).property⟩, coroot_mem_corootSpace α, rfl⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 open Submodule in
 lemma sl2SubmoduleOfRoot_eq_sup (α : Weight K H L) (hα : α.IsNonZero) :
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/Linear.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/Linear.lean
index 312681d6a..7566648c8 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/Linear.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/Linear.lean
@@ -96,6 +96,7 @@ end Weight
 
 attribute [local instance 100] LieRing.ofAssociativeRing
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- For an Abelian Lie algebra, the weights of any Lie module are linear. -/
 instance instLinearWeightsOfIsLieAbelian [IsLieAbelian L] [IsDomain R] [Module.IsTorsionFree R M] :
     LinearWeights R L M :=
@@ -135,6 +136,7 @@ lemma zero_lt_finrank_genWeightSpace {χ : L → R} (hχ : genWeightSpace M χ 
   rwa [← LieSubmodule.nontrivial_iff_ne_bot, ← rank_pos_iff_nontrivial (R := R), ← finrank_eq_rank,
     Nat.cast_pos] at hχ
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- In characteristic zero, the weights of any finite-dimensional Lie module are linear and vanish
 on the derived ideal. -/
 instance instLinearWeightsOfCharZero [CharZero R] :
diff --git a/mathlib4/Mathlib/Algebra/Module/Congruence/Defs.lean b/mathlib4/Mathlib/Algebra/Module/Congruence/Defs.lean
index 5c8216b2c..e42b572f8 100644
--- a/mathlib4/Mathlib/Algebra/Module/Congruence/Defs.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Congruence/Defs.lean
@@ -150,6 +150,7 @@ def ModuleCon.ker [Monoid R] [Monoid S] [AddMonoid M] [AddMonoid N] [DistribMulA
   __ := SMulCon.ker f.toMulActionHom
   __ := AddCon.ker f
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The first isomorphism theorem for semimodules in the case of a surjective homomorphism. -/
 noncomputable def ModuleCon.quotientKerEquivOfSurjective [Semiring S] [AddCommMonoid M]
     [AddCommMonoid N] [Module S M] [Module S N] (f : M →ₗ[S] N) (hf : Function.Surjective f) :
diff --git a/mathlib4/Mathlib/Algebra/Module/Equiv/Basic.lean b/mathlib4/Mathlib/Algebra/Module/Equiv/Basic.lean
index a805a427a..4da0cab8b 100644
--- a/mathlib4/Mathlib/Algebra/Module/Equiv/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Equiv/Basic.lean
@@ -347,6 +347,7 @@ theorem piApply_apply_apply {V : M → Type*}
 variable (R S M)
 variable [Semiring R] [Semiring S] [AddCommMonoid M] [Module R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The equivalence between R-linear maps from `R` to `M`, and points of `M` itself.
 This says that the forgetful functor from `R`-modules to types is representable, by `R`.
 
diff --git a/mathlib4/Mathlib/Algebra/Module/Equiv/Defs.lean b/mathlib4/Mathlib/Algebra/Module/Equiv/Defs.lean
index 14a412f25..495ed6143 100644
--- a/mathlib4/Mathlib/Algebra/Module/Equiv/Defs.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Equiv/Defs.lean
@@ -584,7 +584,27 @@ def _root_.RingEquiv.toSemilinearEquiv (f : R ≃+* S) :
     toFun := f
     map_smul' := f.map_mul }
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` and `respectTransparency` backward compatibility flags to make an
+instance search succeed. Concretely, the following instance cannot be synthesized:
+`CoeFun (R ≃ₛₗ[↑f] S) ?m`
+so without them the application below reports
+`Function expected at f.symm.toSemilinearEquiv.symm`.
+
+The failure happens while applying `@instEquivLike` to `EquivLike (R ≃ₛₗ[↑f] S) ?α ?β`: assigning
+one of its instance-implicit-argument metavariables is rejected because the metavariable's type and
+the type of the assigned value do not match at `.instances` transparency. The metavariable's
+expected type is `RingHomInvPair ↑f ↑f.symm`, whereas the assigned value
+`RingHomInvPair.symm ↑f.symm ↑f.symm.symm` has type `RingHomInvPair ↑f.symm.symm ↑f.symm`. Lean
+falls back to synthesizing `RingHomInvPair ↑f ↑f.symm`, but no such instnace is found, so the
+assignment fails.
+
+This is the intended behavior.
+A quick fix could be to provide the required instance via `haveI` or as a local instance.
+-/
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.instanceTypes false in
 @[simp]
 lemma _root_.RingEquiv.symm_toSemilinearEquiv_symm_apply (f : R ≃+* S) (x : R) :
   f.symm.toSemilinearEquiv.symm (σ' := RingHomClass.toRingHom f) x = f x := rfl
diff --git a/mathlib4/Mathlib/Algebra/Module/FinitePresentation.lean b/mathlib4/Mathlib/Algebra/Module/FinitePresentation.lean
index f706ac8c5..61cde903f 100644
--- a/mathlib4/Mathlib/Algebra/Module/FinitePresentation.lean
+++ b/mathlib4/Mathlib/Algebra/Module/FinitePresentation.lean
@@ -517,6 +517,7 @@ lemma Module.FinitePresentation.exists_notMem_bijective [Module.Finite R M]
   obtain ⟨g, hg, h⟩ := exists_bijective_map_powers p.primeCompl fM fN f hf
   exact ⟨g, hg, h g dvd_rfl⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open IsLocalizedModule in
 /--
 Let `M` `N` be a finitely presented `R`-modules.
diff --git a/mathlib4/Mathlib/Algebra/Module/Injective.lean b/mathlib4/Mathlib/Algebra/Module/Injective.lean
index 516e1c4d4..98e03f538 100644
--- a/mathlib4/Mathlib/Algebra/Module/Injective.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Injective.lean
@@ -181,6 +181,7 @@ theorem ExtensionOf.le_max {c : Set (ExtensionOf i f)} (hchain : IsChain (· ≤
 
 variable (i f) [Fact <| Function.Injective i]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance ExtensionOf.inhabited : Inhabited (ExtensionOf i f) where
   default :=
     { domain := LinearMap.range i
@@ -331,6 +332,7 @@ theorem ExtensionOfMaxAdjoin.extensionToFun_wd (h : Module.Baer R Q) {y : N}
   rw [Subtype.coe_mk, add_sub, ← eq1]
   exact eq_sub_of_add_eq (ExtensionOfMaxAdjoin.eqn i x).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The linear map `M ⊔ ⟨y⟩ ⟶ Q` by `x + r • y ↦ f x + φ r` is an extension of `f` -/
 def extensionOfMaxAdjoin (h : Module.Baer R Q) (y : N) : ExtensionOf i f where
   domain := supExtensionOfMaxSingleton i f y -- (extensionOfMax i f).domain ⊔ Submodule.span R {y}
diff --git a/mathlib4/Mathlib/Algebra/Module/LinearMap/Defs.lean b/mathlib4/Mathlib/Algebra/Module/LinearMap/Defs.lean
index a56f661b2..c37756dae 100644
--- a/mathlib4/Mathlib/Algebra/Module/LinearMap/Defs.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LinearMap/Defs.lean
@@ -124,6 +124,7 @@ abbrev LinearMapClass (F : Type*) (R : outParam Type*) (M M₂ : Type*)
     [FunLike F M M₂] :=
   SemilinearMapClass F (RingHom.id R) M M₂
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected lemma LinearMapClass.map_smul {R M M₂ : outParam Type*} [Semiring R] [AddCommMonoid M]
     [AddCommMonoid M₂] [Module R M] [Module R M₂]
     {F : Type*} [FunLike F M M₂] [LinearMapClass F R M M₂] (f : F) (r : R) (x : M) :
@@ -333,6 +334,7 @@ protected theorem map_zero : f 0 = 0 :=
 protected theorem map_smulₛₗ (c : R) (x : M) : f (c • x) = σ c • f x :=
   map_smulₛₗ f c x
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem map_smul (c : R) (x : M) : fₗ (c • x) = c • fₗ x :=
   map_smul fₗ c x
 
@@ -361,11 +363,13 @@ section
 
 variable {R S : Type*} [Semiring S] [SMul R M] [Module S M] [SMul R M₂] [Module S M₂]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) IsScalarTower.compatibleSMul [SMul R S]
     [IsScalarTower R S M] [IsScalarTower R S M₂] :
     CompatibleSMul M M₂ R S :=
   ⟨fun fₗ c x ↦ by rw [← smul_one_smul S c x, ← smul_one_smul S c (fₗ x), map_smul]⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance IsScalarTower.compatibleSMul' [SMul R S] [IsScalarTower R S M] :
     CompatibleSMul S M R S where
   map_smul := (IsScalarTower.smulHomClass R S M (S →ₗ[S] M)).map_smulₛₗ
@@ -380,6 +384,7 @@ theorem _root_.LinearMapClass.map_smul_of_tower {F : Type*} [CompatibleSMul M M
     fₗ (c • x) = c • fₗ x :=
   LinearMap.CompatibleSMul.map_smul (fₗ : M →ₗ[S] M₂) c x
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R R) in
 theorem isScalarTower_of_injective [SMul R S] [CompatibleSMul M M₂ R S] [IsScalarTower R S M₂]
     (f : M →ₗ[S] M₂) (hf : Function.Injective f) : IsScalarTower R S M where
diff --git a/mathlib4/Mathlib/Algebra/Module/LinearMap/End.lean b/mathlib4/Mathlib/Algebra/Module/LinearMap/End.lean
index c60fb89dc..587c0e24b 100644
--- a/mathlib4/Mathlib/Algebra/Module/LinearMap/End.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LinearMap/End.lean
@@ -311,6 +311,7 @@ section SMulRight
 variable [Semiring R] [AddCommMonoid M] [AddCommMonoid M₁] [Module R M] [Module R M₁]
 variable [Semiring S] [Module R S] [Module S M] [IsScalarTower R S M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- When `f` is an `R`-linear map taking values in `S`, then `fun b ↦ f b • x` is an `R`-linear
 map. -/
 def smulRight (f : M₁ →ₗ[R] S) (x : M) : M₁ →ₗ[R] M where
@@ -379,6 +380,7 @@ variable [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [AddCommMonoid
 variable [Module R M] [Module R M₂] [Module R M₃]
 variable (f : M →ₗ[R] M₂)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Applying a linear map at `v : M`, seen as a linear map from `M →ₗ[R] M₂` to `M₂`.
 See also `LinearMap.applyₗ'` for a version that works with two different semirings.
 
diff --git a/mathlib4/Mathlib/Algebra/Module/LinearMap/Index.lean b/mathlib4/Mathlib/Algebra/Module/LinearMap/Index.lean
index 8da65af7f..cd8d91ce2 100644
--- a/mathlib4/Mathlib/Algebra/Module/LinearMap/Index.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LinearMap/Index.lean
@@ -65,6 +65,31 @@ public lemma index_of_surjective (hf : Surjective f) :
   rw [index_eq_finrank_sub, range_eq_top.mpr hf]
   simp [finrank_eq_zero_of_subsingleton]
 
+#adaptation_note
+/--
+We had to mark `LinearMap.ker` implicit-reducible locally to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`Module.Free R ↥⊥`
+It is needed by `finrank_eq_zero_of_subsingleton` in the closing `simp`.
+
+The failure happens while applying `Free.of_subsingleton`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `AddCommMonoid ↥⊥`, whereas the assigned value `id.ker.addCommMonoid` has type
+`AddCommMonoid ↥id.ker`. Lean falls back to synthesize an instance of the correct type, but the
+candidate is again not defeq to the result `⊥.addCommMonoid`. Both comparisons bottom out at
+`id.ker =?= ⊥`, and `ker` is semireducible, so it does not unfold at the `.instances` transparency
+that instance search runs at.
+
+The two spellings meet because `simp` mixes them: after `range_id`, the `@[simp]` `rfl`-lemma
+`ker_id` rewrites the carrier `↥(ker id)` to `↥⊥` but keeps the old `id.ker.*` instance arguments.
+Since `Free` stays unsynthesizable, `finrank R ↥⊥` is left unrewritten and the goal
+`finrank R ↥⊥ = 0` is not closed.
+
+Potential fix: mark `LinearMap.ker` implicit-reducible, then remove both backward compatibility
+options.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.types false in
 @[simp] public lemma index_id :
     (id : M →ₗ[R] M).index = 0 := by
diff --git a/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Basic.lean b/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Basic.lean
index 696e97105..f57adb880 100644
--- a/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Basic.lean
@@ -563,6 +563,7 @@ lemma IsLocalizedModule.injective_iff_isRegular [IsLocalizedModule S f] :
     Function.Injective f ↔ ∀ c : S, IsSMulRegular M c := by
   simp_rw [IsSMulRegular, Function.Injective, eq_iff_exists S, exists_imp, forall_comm (α := S)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance IsLocalizedModule.of_linearEquiv (e : M' ≃ₗ[R] M'') [hf : IsLocalizedModule S f] :
     IsLocalizedModule S (e ∘ₗ f : M →ₗ[R] M'') where
@@ -580,6 +581,7 @@ instance IsLocalizedModule.of_linearEquiv (e : M' ≃ₗ[R] M'') [hf : IsLocaliz
       EmbeddingLike.apply_eq_iff_eq] at h
     exact hf.exists_of_eq h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance IsLocalizedModule.of_linearEquiv_right (e : M'' ≃ₗ[R] M) [hf : IsLocalizedModule S f] :
     IsLocalizedModule S (f ∘ₗ e : M'' →ₗ[R] M') where
@@ -619,6 +621,7 @@ lemma isLocalizedModule_id (R') [CommSemiring R'] [Algebra R R'] [IsLocalization
 
 namespace LocalizedModule
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
 there is a linear map `LocalizedModule S M → M''`.
@@ -646,6 +649,7 @@ theorem lift'_mk (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Mo
     LocalizedModule.lift' S g h (LocalizedModule.mk m s) = (h s).unit⁻¹.val (g m) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem lift'_add (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
     (x y) :
     LocalizedModule.lift' S g h (x + y) =
@@ -665,6 +669,7 @@ theorem lift'_add (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (M
         rfl)
     x y
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem lift'_smul (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
     (r : R) (m) : r • LocalizedModule.lift' S g h m = LocalizedModule.lift' S g h (r • m) :=
   m.induction_on fun a b => by
@@ -807,6 +812,7 @@ namespace IsLocalizedModule
 
 variable [IsLocalizedModule S f]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `(M', f : M ⟶ M')` satisfies universal property of localized module, there is a canonical
 map `LocalizedModule S M ⟶ M'`.
 -/
@@ -825,6 +831,7 @@ theorem fromLocalizedModule'_mk (m : M) (s : S) :
       (IsLocalizedModule.map_units f s).unit⁻¹.val (f m) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem fromLocalizedModule'_add (x y : LocalizedModule S M) :
     fromLocalizedModule' S f (x + y) = fromLocalizedModule' S f x + fromLocalizedModule' S f y :=
   LocalizedModule.induction_on₂
@@ -839,6 +846,7 @@ theorem fromLocalizedModule'_add (x y : LocalizedModule S M) :
       · rw [Submonoid.coe_mul, LinearMap.map_smul_of_tower, mul_comm, mul_smul, Submonoid.smul_def])
     x y
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem fromLocalizedModule'_smul (r : R) (x : LocalizedModule S M) :
     r • fromLocalizedModule' S f x = fromLocalizedModule' S f (r • x) :=
   LocalizedModule.induction_on
@@ -861,6 +869,7 @@ theorem fromLocalizedModule_mk (m : M) (s : S) :
       (IsLocalizedModule.map_units f s).unit⁻¹.val (f m) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem fromLocalizedModule.inj : Function.Injective <| fromLocalizedModule S f := fun x y eq1 => by
   induction x with | _ a b
   induction y with | _ a' b'
@@ -1131,6 +1140,7 @@ theorem mk_eq_mk' (s : S) (m : M) :
   rw [eq_comm, mk'_eq_iff, Submonoid.smul_def, LocalizedModule.smul'_mk, ← Submonoid.smul_def,
     LocalizedModule.mk_cancel, LocalizedModule.mkLinearMap_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (A) in
 lemma mk'_smul_mk' (x : R) (m : M) (s t : S) :
@@ -1171,6 +1181,7 @@ lemma liftOfLE_comp : (liftOfLE S₁ S₂ h f₁ f₂).comp f₁ = f₂ := lift_
 
 @[simp] lemma liftOfLE_apply (x) : liftOfLE S₁ S₂ h f₁ f₂ (f₁ x) = f₂ x := lift_apply ..
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The image of `m/s` under `liftOfLE` is `m/s`. -/
 @[simp]
@@ -1197,6 +1208,7 @@ instance : IsLocalizedModule S₂ (liftOfLE S₁ S₂ h f₁ f₂) where
 
 end liftOfLE
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include S in
 lemma injective_of_map_eq {N : Type*} [AddCommMonoid N] [Module R N]
     {g : M' →ₗ[R] N} (H : ∀ {x y}, g (f x) = g (f y) → f x = f y) :
@@ -1326,6 +1338,7 @@ theorem map_comp' (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) :
 
 section Algebra
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem mkOfAlgebra {R S S' : Type*} [CommSemiring R] [Ring S] [Ring S'] [Algebra R S]
     [Algebra R S'] (M : Submonoid R) (f : S →ₐ[R] S') (h₁ : ∀ x ∈ M, IsUnit (algebraMap R S' x))
diff --git a/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Exact.lean b/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Exact.lean
index 1c058bc1c..d2d1f5f4c 100644
--- a/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Exact.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Exact.lean
@@ -32,6 +32,7 @@ variable (f₁ : M₁ →ₗ[R] M₁') [IsLocalizedModule S f₁]
 variable {M₂ M₂'} [AddCommMonoid M₂] [AddCommMonoid M₂'] [Module R M₂] [Module R M₂']
 variable (f₂ : M₂ →ₗ[R] M₂') [IsLocalizedModule S f₂]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Localization of modules is an exact functor, proven here for `LocalizedModule`.
 See `IsLocalizedModule.map_exact` for the more general version. -/
 lemma LocalizedModule.map_exact (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) (ex : Exact g h) :
diff --git a/mathlib4/Mathlib/Algebra/Module/PID.lean b/mathlib4/Mathlib/Algebra/Module/PID.lean
index 9b4a981df..c7518db61 100644
--- a/mathlib4/Mathlib/Algebra/Module/PID.lean
+++ b/mathlib4/Mathlib/Algebra/Module/PID.lean
@@ -269,6 +269,7 @@ theorem equiv_free_prod_directSum [h' : Module.Finite R M] :
           (h.prodCongr g).trans <| LinearEquiv.prodComm.{u, u} R _ (Fin n →₀ R) ⟩⟩
   rw [range_subtype, ker_mkQ]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open LinearMap in
 theorem exists_ker_toSpanSingleton_eq_annihilator [Module.Finite R M] :
diff --git a/mathlib4/Mathlib/Algebra/Module/Presentation/Differentials.lean b/mathlib4/Mathlib/Algebra/Module/Presentation/Differentials.lean
index 97d84e50e..160f6c542 100644
--- a/mathlib4/Mathlib/Algebra/Module/Presentation/Differentials.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Presentation/Differentials.lean
@@ -84,6 +84,30 @@ lemma hom₁_single (r : σ) :
     hom₁ pres (Finsupp.single r 1) = Extension.Cotangent.mk ⟨pres.relation r, by simp⟩ := by
   simp [hom₁]
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`RingHomSurjective (RingHom.id pres.Ring)`
+It is needed by the `rw [Submodule.map_span_le]` below.
+
+The failure happens while applying `@RingHomSurjective.ids`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type is
+`Semiring pres.Ring`, whereas the assigned value `CommRing.toCommSemiring.toSemiring` has type
+`Semiring pres.toExtension.Ring`. The comparison bottoms out at
+`AddMonoidAlgebra R (ι →₀ ℕ) =?= pres.toExtension.1`: the left-hand side is what `pres.Ring` reduces
+to, while the right-hand side is stuck, since `Generators.toExtension` is a semireducible `def` and
+therefore does not unfold at the `.instances` transparency instance search runs at. Lean
+falls back to synthesize an instance of the correct type, which succeeds and returns
+`AddMonoidAlgebra.semiring`, but that is again not defeq to the assigned value, stalling at the same
+boundary. That comparison, too, runs at `.instances`, since `respectTransparency false` suppresses
+the transparency bump that instance-implicit arguments would otherwise receive.
+
+Potential fix: Mark `Generators.toExtension` implicit-reducible; then `respectTransparency false`
+and `instanceTypes false` can both go.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 lemma surjective_hom₁ : Function.Surjective (hom₁ pres) := by
diff --git a/mathlib4/Mathlib/Algebra/Module/Presentation/RestrictScalars.lean b/mathlib4/Mathlib/Algebra/Module/Presentation/RestrictScalars.lean
index 151e13dbf..c6a8c438d 100644
--- a/mathlib4/Mathlib/Algebra/Module/Presentation/RestrictScalars.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Presentation/RestrictScalars.lean
@@ -42,6 +42,7 @@ abbrev RestrictScalarsData : Type _ :=
 
 variable (data : presM.RestrictScalarsData presB)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A presentation of the restriction of scalars from `B` to `A` of a `B`-module `M`,
 given a presentation of `M` as a `B`-module, a presentation of `B` as an `A`-module,
 and an additional data. -/
diff --git a/mathlib4/Mathlib/Algebra/Module/SnakeLemma.lean b/mathlib4/Mathlib/Algebra/Module/SnakeLemma.lean
index 6c18efd98..7bbe581d1 100644
--- a/mathlib4/Mathlib/Algebra/Module/SnakeLemma.lean
+++ b/mathlib4/Mathlib/Algebra/Module/SnakeLemma.lean
@@ -82,6 +82,7 @@ lemma SnakeLemma.eq_of_eq (x : K₃)
   rw [← sub_eq_zero, ← map_sub, hz₁, hπ₁]
   exact ⟨_, rfl⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /--
 **Snake Lemma**
@@ -122,11 +123,13 @@ def SnakeLemma.δ : K₃ →ₗ[R] C₁ :=
       apply eq_of_eq i₁ i₂ f₁ f₂ hf g₁ h₁ ρ hρ ι₃ π₁ hπ₁ (r • x) _ (H₁ _) _ (H₂ _)
         (r • σ (ι₃ x)) (by simp only [map_smul, H₁]) _ (by simp only [map_smul, H₂]) }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma SnakeLemma.δ_eq (x : K₃) (y) (hy : f₂ y = ι₃ x) (z) (hz : g₁ z = i₂ y) :
     δ i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ σ hσ ρ hρ ι₃ hι₃ π₁ hπ₁ x = π₁ z :=
   eq_of_eq i₁ i₂ f₁ f₂ hf g₁ h₁ ρ hρ ι₃ π₁ hπ₁ x _ (congr_fun hσ _) _
     (δ_aux i₂ i₃ f₂ g₁ g₂ hg h₂ σ hσ ρ hρ ι₃ hι₃ _) y hy z hz
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hι₂ in
 /--
 Suppose we have an exact commutative diagram
@@ -166,6 +169,7 @@ lemma SnakeLemma.exact_δ_right (F : K₂ →ₗ[R] K₃) (hF : f₂.comp ι₂
     exact (δ_eq i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ σ hσ ρ hρ ι₃ hι₃ π₁ hπ₁ _ (ι₂ y) congr($hF y)
       _ (by rw [map_zero, hι₂.apply_apply_eq_zero])).trans π₁.map_zero
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hπ₂ in
 /--
 Suppose we have an exact commutative diagram
@@ -203,6 +207,7 @@ lemma SnakeLemma.exact_δ_left (G : C₁ →ₗ[R] C₂) (hF : G.comp π₁ = π
     simp only [δ, coe_mk, AddHom.coe_mk]
     rw [← G.comp_apply, hF, π₂.comp_apply, H₂, hπ₂.apply_apply_eq_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 Suppose we have an exact commutative diagram
 ```
@@ -229,11 +234,13 @@ Also see `SnakeLemma.δ` for a computable version.
 noncomputable def SnakeLemma.δ' (hf₂ : Surjective f₂) (hg₁ : Injective g₁) : K₃ →ₗ[R] C₁ :=
   δ i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ _ (funext (surjInv_eq hf₂)) _ (invFun_comp hg₁) ι₃ hι₃ π₁ hπ₁
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma SnakeLemma.δ'_eq (hf₂ : Surjective f₂) (hg₁ : Injective g₁)
     (x : K₃) (y) (hy : f₂ y = ι₃ x) (z) (hz : g₁ z = i₂ y) :
     δ' i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ ι₃ hι₃ π₁ hπ₁ hf₂ hg₁ x = π₁ z :=
   SnakeLemma.δ_eq _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ‹_› ‹_› _ ‹_›
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hι₂ in
 /--
 Suppose we have an exact commutative diagram
@@ -261,6 +268,7 @@ lemma SnakeLemma.exact_δ'_right (hf₂ : Surjective f₂) (hg₁ : Injective g
     Exact F (δ' i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ ι₃ hι₃ π₁ hπ₁ hf₂ hg₁) :=
   SnakeLemma.exact_δ_right _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ‹_› _ _ _ _ _ ‹_› ‹_›
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hπ₂ in
 /--
 Suppose we have an exact commutative diagram
diff --git a/mathlib4/Mathlib/Algebra/Module/Submodule/Bilinear.lean b/mathlib4/Mathlib/Algebra/Module/Submodule/Bilinear.lean
index 658cfd25f..b51c565c1 100644
--- a/mathlib4/Mathlib/Algebra/Module/Submodule/Bilinear.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Submodule/Bilinear.lean
@@ -57,6 +57,7 @@ theorem map₂_le {f : M →ₗ[R] N →ₗ[R] P} {p : Submodule R M} {q : Submo
   ⟨fun H _m hm _n hn => H <| apply_mem_map₂ _ hm hn, fun H =>
     iSup_le fun ⟨m, hm⟩ => map_le_iff_le_comap.2 fun n hn => H m hm n hn⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (R) in
 theorem map₂_span_span (f : M →ₗ[R] N →ₗ[R] P) (s : Set M) (t : Set N) :
diff --git a/mathlib4/Mathlib/Algebra/Module/Submodule/LinearMap.lean b/mathlib4/Mathlib/Algebra/Module/Submodule/LinearMap.lean
index af088ed60..43bcb0528 100644
--- a/mathlib4/Mathlib/Algebra/Module/Submodule/LinearMap.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Submodule/LinearMap.lean
@@ -185,6 +185,7 @@ section
 variable {M₂' : Type*} [AddCommMonoid M₂'] [Module R₂ M₂']
   (p : M₂' →ₗ[R₂] M₂) (hp : Injective p) (h : ∀ c, f c ∈ range p)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A linear map `f : M → M₂` whose values lie in the image of an injective linear map
 `p : M₂' → M₂` admits a unique lift to a linear map `M → M₂'`. -/
@@ -194,6 +195,7 @@ noncomputable def codLift :
   map_add' b c := by apply hp; simp_rw [map_add, (h _).choose_spec, ← map_add, (h _).choose_spec]
   map_smul' r c := by apply hp; simp_rw [map_smul, (h _).choose_spec, map_smulₛₗ]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] theorem codLift_apply (x : M) :
     (f.codLift p hp h x) = (h x).choose :=
   rfl
diff --git a/mathlib4/Mathlib/Algebra/Module/Torsion/PrimaryComponent.lean b/mathlib4/Mathlib/Algebra/Module/Torsion/PrimaryComponent.lean
index b5e35a5f8..5fc63e747 100644
--- a/mathlib4/Mathlib/Algebra/Module/Torsion/PrimaryComponent.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Torsion/PrimaryComponent.lean
@@ -61,6 +61,7 @@ theorem primaryComponent_mem (x : M) :
       simp [torsionBySet_le_torsionBySet_pow]
   · aesop (add safe Submodule.mem_iSup_of_mem)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem primaryComponent_map_mem (φ : M₁ →ₗ[A] M₂) (c : primaryComponent M₁ I) :
     φ c ∈ primaryComponent M₂ I := by
   obtain ⟨c, hc⟩ := c
diff --git a/mathlib4/Mathlib/Algebra/Module/TransferInstance.lean b/mathlib4/Mathlib/Algebra/Module/TransferInstance.lean
index 39c5d5b39..de31c2add 100644
--- a/mathlib4/Mathlib/Algebra/Module/TransferInstance.lean
+++ b/mathlib4/Mathlib/Algebra/Module/TransferInstance.lean
@@ -73,6 +73,7 @@ lemma linearEquiv_symm_apply (b : β) [AddCommMonoid β] [Module R β] :
     letI := Equiv.module R e
     (e.linearEquiv R).symm b = e.symm b := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (R) in
 /-- Transfer `Module.IsTorsionFree` across an `Equiv` -/
diff --git a/mathlib4/Mathlib/Algebra/Module/ZLattice/Covolume.lean b/mathlib4/Mathlib/Algebra/Module/ZLattice/Covolume.lean
index dcdd7b8ea..4384ef603 100644
--- a/mathlib4/Mathlib/Algebra/Module/ZLattice/Covolume.lean
+++ b/mathlib4/Mathlib/Algebra/Module/ZLattice/Covolume.lean
@@ -222,6 +222,7 @@ variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
 variable {L : Submodule ℤ E} [DiscreteTopology L] [IsZLattice ℝ L]
 variable {ι : Type*} [Fintype ι] (b : Basis ι ℤ L)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- A version of `ZLattice.covolume.tendsto_card_div_pow` for the general case;
 see the `Naming convention` section in the introduction. -/
@@ -253,6 +254,7 @@ private theorem tendsto_card_le_div''_aux
     (inv_pos_of_pos hc).le, inv_pow, inv_mul_le_iff₀ (pow_pos hc _), mul_one, and_congr_left_iff]
   exact fun _ ↦ ⟨fun h ↦ (smul_inv_smul₀ hc.ne' x) ▸ hX h hc, fun h ↦ hX h (inv_pos_of_pos hc)⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A version of `ZLattice.covolume.tendsto_card_le_div` for the general case;
 see the `Naming conventions` section in the introduction. -/
 theorem tendsto_card_le_div'' [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
diff --git a/mathlib4/Mathlib/Algebra/Order/Module/HahnEmbedding.lean b/mathlib4/Mathlib/Algebra/Order/Module/HahnEmbedding.lean
index 0f551ec4d..b56451a46 100644
--- a/mathlib4/Mathlib/Algebra/Order/Module/HahnEmbedding.lean
+++ b/mathlib4/Mathlib/Algebra/Order/Module/HahnEmbedding.lean
@@ -819,6 +819,7 @@ theorem truncLT_eval_mem_range_extendFun [IsOrderedAddMonoid R] [Archimedean R]
     obtain ⟨y, hy⟩ := h
     exact ⟨y, Set.mem_of_mem_of_subset hy (by simpa using (ball_strictAnti K).antitone hdc)⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem truncLT_mem_range_extendFun [IsOrderedAddMonoid R] [Archimedean R] {x : M}
     (hx : x ∉ f.val.domain) (y : (f.extendFun hx).domain) (c : FiniteArchimedeanClass M) :
     toLex (HahnSeries.truncLTLinearMap K c (ofLex (f.extendFun hx y))) ∈
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Bivariate.lean b/mathlib4/Mathlib/Algebra/Polynomial/Bivariate.lean
index 33d87021a..665fe594e 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Bivariate.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Bivariate.lean
@@ -342,6 +342,7 @@ lemma equivMvPolynomial_symm_X_1 : (equivMvPolynomial R).symm (.X 1) = X := by
 lemma equivMvPolynomial_symm_C (a : R) : (equivMvPolynomial R).symm (.C a) = C (C a) := by
   simp [equivMvPolynomial]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma pderiv_zero_equivMvPolynomial {R : Type*} [CommRing R] (p : R[X][Y]) :
     (equivMvPolynomial R p).pderiv 0 = equivMvPolynomial R
       (PolynomialModule.equivPolynomialSelf (derivative'.mapCoeffs p)) := by
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Coeff.lean b/mathlib4/Mathlib/Algebra/Polynomial/Coeff.lean
index 83b0733ca..6f5aa67b1 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Coeff.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Coeff.lean
@@ -64,6 +64,7 @@ theorem card_support_mul_le : #(p * q).support ≤ #p.support * #q.support := by
       grw [AddMonoidAlgebra.support_coeff_mul_subset]
     _ ≤ #p.support * #q.support := Finset.card_image₂_le ..
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `Polynomial.sum` as a linear map. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Derivation.lean b/mathlib4/Mathlib/Algebra/Polynomial/Derivation.lean
index 41dbee4c2..190eb6682 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Derivation.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Derivation.lean
@@ -110,6 +110,7 @@ open Polynomial Module
 
 set_option backward.isDefEq.respectTransparency false in
 set_option linter.style.whitespace false in -- manual alignment is not recognised
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 For a derivation `d : A → M` and an element `a : A`, `d.compAEval a` is the
 derivation of `R[X]` which takes a polynomial `f` to `d(aeval a f)`.
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Expand.lean b/mathlib4/Mathlib/Algebra/Polynomial/Expand.lean
index 75ea931ca..f6161eef2 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Expand.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Expand.lean
@@ -59,6 +59,7 @@ theorem expand_C (r : R) : expand R p (C r) = C r :=
 theorem expand_X : expand R p X = X ^ p :=
   eval₂_X _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem expand_monomial (r : R) : expand R p (monomial q r) = monomial (q * p) r := by
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Module/AEval.lean b/mathlib4/Mathlib/Algebra/Polynomial/Module/AEval.lean
index e92faff4d..6124c1804 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Module/AEval.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Module/AEval.lean
@@ -70,6 +70,7 @@ lemma of_aeval_smul (f : R[X]) (m : M) : of R M a (aeval a f • m) = f • of R
 @[simp] lemma of_symm_smul (f : R[X]) (m : AEval R M a) :
     (of R M a).symm (f • m) = aeval a f • (of R M a).symm m := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma C_smul (t : R) (m : AEval R M a) : C t • m = t • m :=
   (of R M a).symm.injective <| by simp
@@ -84,6 +85,7 @@ lemma of_symm_X_smul (m : AEval R M a) :
     (of R M a).symm ((X : R[X]) • m) = a • (of R M a).symm m := by
   rw [of_symm_smul, aeval_X]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance instIsScalarTowerOrigPolynomial : IsScalarTower R R[X] <| AEval R M a where
   smul_assoc r f m := by
     apply (of R M a).symm.injective
diff --git a/mathlib4/Mathlib/Algebra/QuadraticAlgebra/Basic.lean b/mathlib4/Mathlib/Algebra/QuadraticAlgebra/Basic.lean
index 9eed3c5bf..c3d25768d 100644
--- a/mathlib4/Mathlib/Algebra/QuadraticAlgebra/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/QuadraticAlgebra/Basic.lean
@@ -90,6 +90,7 @@ theorem mk_eq_add_smul_omega (x y : R) :
 
 variable {A : Type*} [Ring A] [Algebra R A]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[ext]
 theorem algHom_ext {f g : QuadraticAlgebra R a b →ₐ[R] A}
@@ -97,6 +98,7 @@ theorem algHom_ext {f g : QuadraticAlgebra R a b →ₐ[R] A}
   ext ⟨x, y⟩
   simp [mk_eq_add_smul_omega, h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The unique `AlgHom` from `QuadraticAlgebra R a b` to an `R`-algebra `A`,
 constructed by replacing `ω` with the provided root.
diff --git a/mathlib4/Mathlib/Algebra/QuaternionBasis.lean b/mathlib4/Mathlib/Algebra/QuaternionBasis.lean
index 925163a09..9499ffe35 100644
--- a/mathlib4/Mathlib/Algebra/QuaternionBasis.lean
+++ b/mathlib4/Mathlib/Algebra/QuaternionBasis.lean
@@ -161,6 +161,7 @@ theorem range_liftHom (B : Basis A c₁ c₂ c₃) :
       <;> [use (Basis.self R).i; use (Basis.self R).j; use (Basis.self R).k]
     all_goals simp [lift]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Transform a `QuaternionAlgebra.Basis` through an `AlgHom`. -/
 @[simps i j k]
 def compHom (F : A →ₐ[R] B) : Basis B c₁ c₂ c₃ where
@@ -174,6 +175,7 @@ def compHom (F : A →ₐ[R] B) : Basis B c₁ c₂ c₃ where
 
 end Basis
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 /-- A quaternionic basis on `A` is equivalent to a map from the quaternion algebra to `A`. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Algebra/RingQuot.lean b/mathlib4/Mathlib/Algebra/RingQuot.lean
index 3fe3f3b96..28140f5f6 100644
--- a/mathlib4/Mathlib/Algebra/RingQuot.lean
+++ b/mathlib4/Mathlib/Algebra/RingQuot.lean
@@ -491,6 +491,7 @@ theorem ringQuot_ext' {s : A → A → Prop} (f g : RingQuot s →ₐ[S] B)
 set_option backward.isDefEq.respectTransparency false in
 irreducible_def preLiftAlgHom {s : A → A → Prop} {f : A →ₐ[S] B}
   (h : ∀ ⦃x y⦄, s x y → f x = f y) : RingQuot s →ₐ[S] B :=
+set_option backward.isDefEq.respectTransparency.outParams false in
 { toFun := fun x ↦ Quot.lift f
             (by
               rintro _ _ r
@@ -512,6 +513,7 @@ irreducible_def preLiftAlgHom {s : A → A → Prop} {f : A →ₐ[S] B}
     rintro x
     simp [← one_quot, smul_quot, Algebra.algebraMap_eq_smul_one] }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Any `S`-algebra homomorphism `f : A →ₐ[S] B` which respects a relation `s : A → A → Prop`
 factors uniquely through a morphism `RingQuot s →ₐ[S] B`.
 -/
@@ -530,6 +532,7 @@ irreducible_def liftAlgHom {s : A → A → Prop} :
                  AlgHom.coe_comp, AlgHom.coe_mk, RingHom.coe_mk,
                  MonoidHom.coe_mk, OneHom.coe_mk, Function.comp_apply] }
 
+set_option backward.isDefEq.respectTransparency.instances false in
 @[simp]
 theorem liftAlgHom_mkAlgHom_apply (f : A →ₐ[S] B) {s : A → A → Prop}
     (w : ∀ ⦃x y⦄, s x y → f x = f y) (x) : (liftAlgHom S ⟨f, w⟩) ((mkAlgHom S s) x) = f x := by
@@ -537,11 +540,13 @@ theorem liftAlgHom_mkAlgHom_apply (f : A →ₐ[S] B) {s : A → A → Prop}
   rfl
 
 -- note this is essentially `(liftAlgHom S).symm_apply_eq.mp h`
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem liftAlgHom_unique (f : A →ₐ[S] B) {s : A → A → Prop} (w : ∀ ⦃x y⦄, s x y → f x = f y)
     (g : RingQuot s →ₐ[S] B) (h : g.comp (mkAlgHom S s) = f) : g = liftAlgHom S ⟨f, w⟩ := by
   ext
   simp [h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem eq_liftAlgHom_comp_mkAlgHom {s : A → A → Prop} (f : RingQuot s →ₐ[S] B) :
     f = liftAlgHom S ⟨f.comp (mkAlgHom S s), fun _ _ h ↦ congr_arg f (mkAlgHom_rel S h)⟩ :=
   liftAlgHom_unique S (f.comp (mkAlgHom S s)) (fun _ _ h ↦ congr_arg (⇑f) (mkAlgHom_rel S h)) f rfl
@@ -550,6 +555,7 @@ open scoped Function -- required for scoped `on` notation
 
 variable {S}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If two `S`-algebras are `S`-equivalent and their quotients by a relation `rel` are defined,
 then their quotients are also `S`-equivalent.
 
diff --git a/mathlib4/Mathlib/Algebra/Star/NonUnitalSubalgebra.lean b/mathlib4/Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
index 4f9e0b65f..71441edb2 100644
--- a/mathlib4/Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
+++ b/mathlib4/Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@@ -1049,6 +1049,7 @@ instance instIsMulCommutative_iSup [Nonempty ι] [Preorder ι] [IsDirectedOrder
     IsMulCommutative (⨆ i, S i : NonUnitalStarSubalgebra R A) :=
   isMulCommutative_iSup S.monotone.directed_le
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Define a non-unital star algebra homomorphism on a directed supremum of non-unital star
 subalgebras by defining it on each non-unital star subalgebra, and proving that it agrees on the
diff --git a/mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean b/mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean
index 1ab72e19f..371c1a638 100644
--- a/mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean
+++ b/mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean
@@ -128,6 +128,7 @@ theorem coe_toNonUnitalAlgHom {f : A →⋆ₙₐ[R] B} : (f.toNonUnitalAlgHom :
 theorem ext {f g : A →⋆ₙₐ[R] B} (h : ∀ x, f x = g x) : f = g :=
   DFunLike.ext _ _ h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Copy of a `NonUnitalStarAlgHom` with a new `toFun` equal to the old one. Useful
 to fix definitional equalities. -/
 protected def copy (f : A →⋆ₙₐ[R] B) (f' : A → B) (h : f' = f) : A →⋆ₙₐ[R] B where
@@ -451,6 +452,7 @@ instance : Monoid (A →⋆ₐ[R] A) where
   one_mul := id_comp
   mul_one := comp_id
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A unital morphism of ⋆-algebras is a `NonUnitalStarAlgHom`. -/
 def toNonUnitalStarAlgHom (f : A →⋆ₐ[R] B) : A →⋆ₙₐ[R] B :=
   { f with map_smul' := map_smul f }
@@ -650,6 +652,7 @@ class NonUnitalAlgEquivClass (F : Type*) (R A B : outParam Type*)
   extends RingEquivClass F A B, MulActionSemiHomClass F (@id R) A B where
 
 -- See note [lower instance priority]
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) {F R A B : Type*} [Monoid R] [NonUnitalNonAssocSemiring A]
     [DistribMulAction R A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [EquivLike F A B]
     [NonUnitalAlgEquivClass F R A B] :
@@ -658,6 +661,7 @@ instance (priority := 100) {F R A B : Type*} [Monoid R] [NonUnitalNonAssocSemiri
 
 set_option backward.isDefEq.respectTransparency false in
 -- See note [lower instance priority]
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) (F R A B : Type*) [CommSemiring R] [Semiring A]
     [Algebra R A] [Semiring B] [Algebra R B] [EquivLike F A B] [NonUnitalAlgEquivClass F R A B] :
     AlgEquivClass F R A B :=
@@ -1038,6 +1042,7 @@ theorem symm_arrowCongr (e₁ : A₁ ≃⋆ₐ[R] A₁') (e₂ : A₂ ≃⋆ₐ[
     (arrowCongr e₁ e₂).symm = arrowCongr e₁.symm e₂.symm :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Construct a star algebra equivalence from a pair of star algebra homomorphisms. -/
 @[simps]
 def ofStarAlgHom {R A B : Type*} [CommSemiring R]
@@ -1078,6 +1083,7 @@ variable [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [Star B]
 variable [FunLike F A B] [NonUnitalAlgHomClass F R A B] [StarHomClass F A B]
 variable [FunLike G B A] [NonUnitalAlgHomClass G R B A] [StarHomClass G B A]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Promote a bijective star algebra homomorphism to a star algebra equivalence. -/
 noncomputable def ofBijective (f : F) (hf : Function.Bijective f) : A ≃⋆ₐ[R] B :=
   {
diff --git a/mathlib4/Mathlib/Algebra/Star/Subalgebra.lean b/mathlib4/Mathlib/Algebra/Star/Subalgebra.lean
index c9039e2bb..e6a726eeb 100644
--- a/mathlib4/Mathlib/Algebra/Star/Subalgebra.lean
+++ b/mathlib4/Mathlib/Algebra/Star/Subalgebra.lean
@@ -857,6 +857,7 @@ theorem injective_codRestrict (f : A →⋆ₐ[R] B) (S : StarSubalgebra R B) (h
 def rangeRestrict (f : A →⋆ₐ[R] B) : A →⋆ₐ[R] f.range :=
   StarAlgHom.codRestrict f _ fun x => ⟨x, rfl⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The `StarAlgEquiv` onto the range corresponding to an injective `StarAlgHom`. -/
 @[simps]
 noncomputable def _root_.StarAlgEquiv.ofInjective (f : A →⋆ₐ[R] B)
diff --git a/mathlib4/Mathlib/Algebra/Vertex/HVertexOperator.lean b/mathlib4/Mathlib/Algebra/Vertex/HVertexOperator.lean
index 457307099..2df773e79 100644
--- a/mathlib4/Mathlib/Algebra/Vertex/HVertexOperator.lean
+++ b/mathlib4/Mathlib/Algebra/Vertex/HVertexOperator.lean
@@ -129,6 +129,7 @@ theorem compHahnSeries_add (u v : U) :
   simp only [compHahnSeries_coeff, map_add, coeff_apply_apply, HahnSeries.coeff_add', Pi.add_apply]
   rw [← HahnSeries.coeff_add]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem compHahnSeries_smul (r : R) (u : U) :
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/EffectiveEpi.lean b/mathlib4/Mathlib/AlgebraicGeometry/EffectiveEpi.lean
index faf69c1b8..a1a36cf33 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/EffectiveEpi.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/EffectiveEpi.lean
@@ -53,6 +53,8 @@ instance effectiveEpi_base_of_flat {X Y : Scheme.{u}} {f : X ⟶ Y} [Flat f] [Su
 
 namespace EffectiveEpiConstruction
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `π : X ⟶ Y` is a surjective and flat morphism between affine schemes, then any morphism
 `f : X ⟶ S` to an affine scheme `S` whose two pullbacks to `X ×[Y] X` agree descends to a morphism
 `u : Y ⟶ S` with `π ≫ u = f`. -/
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean b/mathlib4/Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean
index 31a412369..e5e0211ce 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean
@@ -406,6 +406,7 @@ lemma mk_XYIdeal'_mul_mk_XYIdeal' [DecidableEq F] {x₁ x₂ y₁ y₂ : F} (h
 
 /-! ## Norms on the affine coordinate ring -/
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma norm_smul_basis (p q : R[X]) : Algebra.norm R[X] (p • (1 : W'.CoordinateRing) + q • mk W' Y) =
     p ^ 2 - p * q * (C W'.a₁ * X + C W'.a₃) -
       q ^ 2 * (X ^ 3 + C W'.a₂ * X ^ 2 + C W'.a₄ * X + C W'.a₆) := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Connected.lean b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Connected.lean
index 060f36132..7ae613dca 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Connected.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Connected.lean
@@ -63,6 +63,8 @@ instance (s : S) [GeometricallyConnected f] :
     GeometricallyConnected (f.fiberToSpecResidueField s) :=
   MorphismProperty.pullback_snd _ _ inferInstance
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (s : S) [GeometricallyConnected f] : ConnectedSpace (f.fiber s) :=
   GeometricallyConnected.geometrically_connectedSpace _ _ _ (.of_hasPullback _ _)
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Integral.lean b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Integral.lean
index 2dc55ece5..16a2e65e8 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Integral.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Integral.lean
@@ -82,6 +82,8 @@ instance (s : S) [GeometricallyIntegral f] :
     GeometricallyIntegral (f.fiberToSpecResidueField s) :=
   MorphismProperty.pullback_snd _ _ inferInstance
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (s : S) [GeometricallyIntegral f] : IsIntegral (f.fiber s) :=
   GeometricallyIntegral.geometrically_isIntegral _ _ _ (.of_hasPullback _ _)
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Irreducible.lean b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Irreducible.lean
index 0a421c973..62392544d 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Irreducible.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Irreducible.lean
@@ -65,6 +65,8 @@ instance (s : S) [GeometricallyIrreducible f] :
     GeometricallyIrreducible (f.fiberToSpecResidueField s) :=
   MorphismProperty.pullback_snd _ _ inferInstance
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (s : S) [GeometricallyIrreducible f] : IrreducibleSpace (f.fiber s) :=
   GeometricallyIrreducible.geometrically_irreducibleSpace _ _ _ (.of_hasPullback _ _)
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Reduced.lean b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Reduced.lean
index 5934193fc..731487df8 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Reduced.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Reduced.lean
@@ -67,6 +67,8 @@ instance (s : S) [GeometricallyReduced f] :
     GeometricallyReduced (f.fiberToSpecResidueField s) :=
   MorphismProperty.pullback_snd _ _ inferInstance
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (s : S) [GeometricallyReduced f] : IsReduced (f.fiber s) :=
   GeometricallyReduced.geometrically_isReduced _ _ _ (.of_hasPullback _ _)
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Limits.lean b/mathlib4/Mathlib/AlgebraicGeometry/Limits.lean
index fe1f9c51d..ec5de63a6 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Limits.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Limits.lean
@@ -232,9 +232,38 @@ noncomputable instance [Small.{u} σ] : CoproductsOfShapeDisjoint Scheme.{u} σ
 instance : HasFiniteCoproducts Scheme.{u} where
   out := inferInstance
 
+set_option linter.style.longLine false in
+#adaptation_note
+/--
+We had to add `(X := X)` in the `inferInstanceAs` below to make an instance search succeed.
+
+Was:
+```lean
 set_option backward.isDefEq.respectTransparency.types false in
 instance : MonoCoprod Scheme.{u} :=
-  .mk' fun X Y ↦ ⟨.mk coprod.inl coprod.inr, coprodIsCoprod X Y, inferInstanceAs <| Mono coprod.inl⟩
+  .mk' fun X Y ↦
+    ⟨.mk coprod.inl coprod.inr, coprodIsCoprod X Y, inferInstanceAs <| Mono coprod.inl⟩
+```
+Concretely, without the pin the following instance cannot be synthesized:
+`Mono coprod.inl`
+
+The failure happens while applying `@Mono.inl_of_binaryCoproductDisjoint`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `HasBinaryCoproduct ((pair X Y).obj { as := WalkingPair.left }) Y`, whereas the assigned value
+`Scheme.IsLocallyDirected.instHasColimit (pair X Y)` has type `HasColimit (pair X Y)`. Lean falls
+back to synthesize an instance of the correct type, which succeeds, but the candidate is again not
+defeq to the result. The direct check bottoms out at
+`(pair X Y).obj { as := WalkingPair.left } =?= X` and the fallback comparison at the same pair the
+other way around, so `pair` unfolds neither at `.instances` nor at `.implicit`.
+
+The unpinned `inferInstanceAs` leaves the elaborator free to spell the coproduct leg as
+`(pair X Y).obj { as := WalkingPair.left }` rather than `X`; pinning `(X := X)` fixes that
+spelling up front. An alternative fix is to make `pair` implicit-reducible.
+-/
+instance : MonoCoprod Scheme.{u} :=
+  .mk' fun X Y ↦
+    ⟨.mk coprod.inl coprod.inr, coprodIsCoprod X Y, inferInstanceAs <| Mono coprod.inl (X := X)⟩
 
 /-- The cover of `∐ X` by the `Xᵢ`. -/
 @[simps!]
@@ -328,15 +357,21 @@ lemma nonempty_isColimit_cofanMk_of [Small.{u} σ]
 
 variable (X Y : Scheme.{u})
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- (Implementation Detail)
 The coproduct of the two schemes is given by indexed coproducts over `WalkingPair`. -/
 noncomputable
 def coprodIsoSigma : X ⨿ Y ≅ ∐ fun i : ULift.{u} WalkingPair ↦ i.1.casesOn X Y :=
   Sigma.whiskerEquiv Equiv.ulift.symm (fun _ ↦ by exact Iso.refl _)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ι_left_coprodIsoSigma_inv : Sigma.ι _ ⟨.left⟩ ≫ (coprodIsoSigma X Y).inv = coprod.inl :=
   Sigma.ι_comp_map' _ _ _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ι_right_coprodIsoSigma_inv : Sigma.ι _ ⟨.right⟩ ≫ (coprodIsoSigma X Y).inv = coprod.inr :=
   Sigma.ι_comp_map' _ _ _
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Modules/Tilde.lean b/mathlib4/Mathlib/AlgebraicGeometry/Modules/Tilde.lean
index dee5b8e11..fe84ee3e8 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Modules/Tilde.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Modules/Tilde.lean
@@ -423,6 +423,8 @@ def tildeSelf : tilde (ModuleCat.of R R) ≅ SheafOfModules.unit.{u} _ := .refl
 instance : IsIso (Scheme.Modules.fromTildeΓ (SheafOfModules.unit.{u} (Spec R).ringCatSheaf)) :=
   isIso_fromTildeΓ_iff.mpr ⟨_, ⟨tildeSelf⟩⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Tilde of direct sums of `R` as an `R`-module is isomorphic to the free sheaf. -/
 noncomputable
 def tildeFinsupp (ι : Type u) : tilde (ModuleCat.of R (ι →₀ R)) ≅ SheafOfModules.free.{u} ι :=
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Flat.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Flat.lean
index d1c1232c4..f9db1af6e 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Flat.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Flat.lean
@@ -336,6 +336,7 @@ lemma mono_pushoutSection_of_iSup_eq {ι : Type*} [Finite ι] (VX : ι → X.Ope
     ext x j
     simp [ψY, H₂, -CommRingCat.hom_comp, ← CategoryTheory.comp_apply, pushoutSection, ψ]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 lemma isIso_pushoutSection_of_iSup_eq
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Sites/Etale.lean b/mathlib4/Mathlib/AlgebraicGeometry/Sites/Etale.lean
index 9b790dbf9..942d366c9 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Sites/Etale.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Sites/Etale.lean
@@ -56,6 +56,7 @@ set_option backward.isDefEq.respectTransparency.types false in
 def smallEtalePretopology (X : Scheme.{u}) : Pretopology X.Etale :=
   X.smallPretopology (Q := @Etale) (P := @Etale)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 lemma ofArrows_mem_smallEtaleTopology_iff
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Sites/EtalePoint.lean b/mathlib4/Mathlib/AlgebraicGeometry/Sites/EtalePoint.lean
index 0bbd1ed50..3e4865b51 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Sites/EtalePoint.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Sites/EtalePoint.lean
@@ -93,6 +93,7 @@ noncomputable def pointSmallEtale : (smallEtaleTopology S).Point where
 
 variable {s₀ : S} (hs₀ : s default = s₀)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a morphism `s : Spec (.of Ω) ⟶ S` with image `s₀ : S` where `Ω` is a
 separably closed field, this is the canonical map
 `(pointSmallEtale s).fiber.obj X ⟶ X.hom ⁻¹' {s₀}` for `X : S.Etale`. -/
@@ -110,6 +111,7 @@ instance {Y X : Scheme.{u}} (f : Y ⟶ X) [Etale f] (x : X) :
   dsimp [Hom.fiberToSpecResidueField]
   infer_instance
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma pointSmallEtaleFiberObjToPreimage_surjective (X : S.Etale) :
     Function.Surjective (pointSmallEtaleFiberObjToPreimage s hs₀ (X := X)) := by
@@ -122,6 +124,7 @@ lemma pointSmallEtaleFiberObjToPreimage_surjective (X : S.Etale) :
   refine ⟨Over.homMk (l ≫ X.hom.fiberι t) ?_, rfl⟩
   simp [X.hom.fiber_fac, reassoc_of% hl]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isConservative_pointSmallEtale
     {ι : Type*} {S : Scheme.{u}}
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean b/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
index 7ac7f34b6..a5434f420 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
@@ -47,7 +47,6 @@ boundaries.
 
 -/
 
-
 universe u
 
 noncomputable section
@@ -415,6 +414,7 @@ def toBasicOpenₗ (f : R) :
     exact Submonoid.powers_le (P := (IsUnit.submonoid _).comap (algebraMap R _)).mpr
       (isUnit_basicOpen_end ..)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 @[simp]
 theorem toBasicOpenₗ_mk (s : R) (f : M) (g : Submonoid.powers s) :
@@ -494,6 +494,33 @@ theorem exists_le_iSup_basicOpen_and_smul_eq_smul_and_eq_const
       simp [Submonoid.smul_def, pow_succ', mul_smul]
     · simp
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`IsConcreteLE (Opens (PrimeSpectrum R)) ↑(PrimeSpectrum.Top R)`
+It is needed by `← SetLike.coe_subset_coe` in the `simpa … using iU` below.
+
+The failure happens while applying `instIsConcreteLE`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `SetLike (Opens (PrimeSpectrum R)) ↑(PrimeSpectrum.Top R)`, whereas the assigned value
+`Opens.instSetLike` has type `SetLike (Opens ↑(PrimeSpectrum.Top R)) ↑(PrimeSpectrum.Top R)`. The
+two differ in the first argument, and comparing them bottoms out at
+`PrimeSpectrum R =?= (PrimeSpectrum.Top R).1`, where `PrimeSpectrum.Top` is semireducible and hence
+does not unfold at the `.instances` transparency that instance search runs at. Lean falls back to
+synthesize an instance of the correct type, but that synthesis fails as well: it hits the very same
+problem one level down, for the assignment of a metavariable of type
+`TopologicalSpace (PrimeSpectrum R)` to `(PrimeSpectrum.Top R).str`, whose own fallback returns
+`PrimeSpectrum.zariskiTopology`; again not defeq to `(PrimeSpectrum.Top R).str` at `.instances`.
+
+With no `IsConcreteLE` instance found, `← SetLike.coe_subset_coe` never fires and `simpa` reports a
+type mismatch for `iU`.
+
+Potential fix: mark `PrimeSpectrum.Top` implicit-reducible, then remove both backward compatibility
+options.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 theorem toBasicOpenₗ_surjective (f : R) : Function.Surjective (toBasicOpenₗ R M f) := by
   intro s
@@ -599,6 +626,7 @@ instance (x : PrimeSpectrum.Top R) :
       ↑(TopCat.Presheaf.stalk (moduleStructurePresheaf R M).presheaf x) :=
   .of_algebraMap_smul fun _ _ ↦ rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 variable (R M) in
 def modulePresheafStalkIso (x : PrimeSpectrum.Top R) :
@@ -632,6 +660,7 @@ instance (x : PrimeSpectrum.Top R) :
       ((structurePresheafInModuleCat R M).stalk x) :=
   (modulePresheafStalkIso R M x).toAddEquiv.symm.module _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma toStalk_smul (x : PrimeSpectrum.Top R) (r : R)
     (m : (structurePresheafInModuleCat R M).stalk x) :
     toStalk R x r • m = r • m := by
@@ -684,6 +713,7 @@ def localizationtoStalkₗ (x : PrimeSpectrum.Top R) :
     (LocalizedModule.mkLinearMap x.asIdeal.primeCompl M)
     (toStalkₗ' R M x).hom fun f ↦ isUnit_toStalkₗ' x f.1 f.2 :)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem localizationtoStalkₗ_mk (x : PrimeSpectrum.Top R) (f : M) (s) :
@@ -797,6 +827,7 @@ instance (x : PrimeSpectrum.Top R) :
   rw! [PrimeSpectrum.basicOpen_one]
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (R M) in
 /-- The canonical ring homomorphism interpreting an element of `R` as an element of
diff --git a/mathlib4/Mathlib/AlgebraicTopology/DoldKan/Projections.lean b/mathlib4/Mathlib/AlgebraicTopology/DoldKan/Projections.lean
index e960ff9b0..4e67f4f89 100644
--- a/mathlib4/Mathlib/AlgebraicTopology/DoldKan/Projections.lean
+++ b/mathlib4/Mathlib/AlgebraicTopology/DoldKan/Projections.lean
@@ -71,6 +71,7 @@ theorem P_add_Q (q : ℕ) : P q + Q q = 𝟙 K[X] := by
   rw [Q]
   abel
 
+set_option backward.isDefEq.respectTransparency.instances false in
 theorem P_add_Q_f (q n : ℕ) : (P q).f n + (Q q).f n = 𝟙 (X _⦋n⦌) :=
   HomologicalComplex.congr_hom (P_add_Q q) n
 
diff --git a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/AnodyneExtensions/UnionProd.lean b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/AnodyneExtensions/UnionProd.lean
index 791c67365..939b41ae3 100644
--- a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/AnodyneExtensions/UnionProd.lean
+++ b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/AnodyneExtensions/UnionProd.lean
@@ -595,6 +595,7 @@ lemma type₁_pairingCore {m : ℕ} (k : Fin (m + 1)) {n : ℕ}
     (pairingCore k n).type₁ s = s.x :=
   Subcomplex.N.cast_eq_self _ s.hd
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
 /-- A weak rank function for `pairingCore k n`. -/
diff --git a/mathlib4/Mathlib/Analysis/Asymptotics/TVS.lean b/mathlib4/Mathlib/Analysis/Asymptotics/TVS.lean
index 941f097ec..f5bbb010e 100644
--- a/mathlib4/Mathlib/Analysis/Asymptotics/TVS.lean
+++ b/mathlib4/Mathlib/Analysis/Asymptotics/TVS.lean
@@ -417,6 +417,7 @@ lemma isLittleOTVS_sup : f =o[𝕜; l₁ ⊔ l₂] g ↔ f =o[𝕜; l₁] g ∧
 lemma IsLittleOTVS.sup (hf₁ : f =o[𝕜; l₁] g) (hf₂ : f =o[𝕜; l₂] g) : f =o[𝕜; l₁ ⊔ l₂] g :=
   isLittleOTVS_sup.mpr ⟨hf₁, hf₂⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma _root_.ContinuousLinearMap.isBigOTVS_id {l : Filter E} (f : E →L[𝕜] F) : f =O[𝕜; l] id :=
   ⟨fun U hU ↦ ⟨f ⁻¹' U, (map_continuous f).tendsto' 0 0 (map_zero f) hU, .of_forall <|
     (mapsTo_preimage f U).egauge_le 𝕜 f⟩⟩
@@ -427,6 +428,7 @@ lemma _root_.ContinuousLinearMap.isBigOTVS_comp (g : E →L[𝕜] F) : (g ∘ f)
 lemma _root_.ContinuousLinearMap.isBigOTVS_fun_comp (g : E →L[𝕜] F) : (g <| f ·) =O[𝕜; l] f :=
   g.isBigOTVS_comp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma _root_.LinearMap.isBigOTVS_rev_comp (g : E →ₗ[𝕜] F) (hg : comap g (𝓝 0) ≤ 𝓝 0) :
     f =O[𝕜; l] (g ∘ f) := by
   constructor
diff --git a/mathlib4/Mathlib/Analysis/BoxIntegral/Basic.lean b/mathlib4/Mathlib/Analysis/BoxIntegral/Basic.lean
index 39e9aba59..a58891581 100644
--- a/mathlib4/Mathlib/Analysis/BoxIntegral/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/BoxIntegral/Basic.lean
@@ -148,6 +148,7 @@ theorem integralSum_neg (f : ℝⁿ → E) (vol : ι →ᵇᵃ E →L[ℝ] F) (
     integralSum (-f) vol π = -integralSum f vol π := by
   simp only [integralSum, Pi.neg_apply, (vol _).map_neg, Finset.sum_neg_distrib]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem integralSum_smul (c : ℝ) (f : ℝⁿ → E) (vol : ι →ᵇᵃ E →L[ℝ] F) (π : TaggedPrepartition I) :
     integralSum (c • f) vol π = c • integralSum f vol π := by
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/CStarMatrix.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/CStarMatrix.lean
index 9d2e53320..e0c570e30 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/CStarMatrix.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/CStarMatrix.lean
@@ -587,6 +587,7 @@ lemma norm_def {M : CStarMatrix m n A} : ‖M‖ = ‖toCLM M‖ := rfl
 
 lemma norm_def' {M : CStarMatrix n n A} : ‖M‖ = ‖toCLMNonUnitalAlgHom (A := A) M‖ := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma normedSpaceCore : NormedSpace.Core ℂ (CStarMatrix m n A) where
   norm_nonneg M := (toCLM M).opNorm_nonneg
   norm_smul c M := by rw [norm_def, norm_def, map_smul, norm_smul _ (toCLM M)]
@@ -819,9 +820,11 @@ noncomputable instance instNormedRing : NormedRing (CStarMatrix n n A) where
   dist_eq _ _ := rfl
   norm_mul_le := norm_mul_le
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance instNormedAlgebra : NormedAlgebra ℂ (CStarMatrix n n A) where
   norm_smul_le r M := by simpa only [norm_def, map_smul] using (toCLM M).opNorm_smul_le r
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Matrices with entries in a unital C⋆-algebra form a unital C⋆-algebra. -/
 noncomputable instance instCStarAlgebra : CStarAlgebra (CStarMatrix n n A) where
 
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Commute.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Commute.lean
index d0ad5f139..f82e9f31f 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Commute.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Commute.lean
@@ -131,6 +131,7 @@ variable [NonUnitalContinuousFunctionalCalculus 𝕜 A p] [IsTopologicalRing A]
 
 open ContinuousMapZero
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open NonUnitalStarAlgebra.elemental in
 protected theorem Commute.cfcₙHom {a b : A} (ha : p a) (hb₁ : Commute a b)
     (hb₂ : Commute (star a) b) (f : C(quasispectrum 𝕜 a, 𝕜)₀) :
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Continuity.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Continuity.lean
index 7fd03a672..e7e13e562 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Continuity.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Continuity.lean
@@ -735,6 +735,7 @@ variable {X 𝕜 A : Type*} {p : A → Prop} [RCLike 𝕜] [NonUnitalNormedRing
     [NormedSpace 𝕜 A] [IsScalarTower 𝕜 A A] [SMulCommClass 𝕜 A A] [ContinuousStar A]
     [NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped NonUnitalContinuousFunctionalCalculus ContinuousMapZero in
 /-- `cfcₙHomSuperset` is continuous in the variable `a : A` when `s : Set 𝕜` is compact and `a`
 varies over elements whose spectrum is contained in `s`, all of which satisfy the predicate `p`. -/
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
index 9c1539fa6..fee27a742 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
@@ -191,6 +191,7 @@ end cfcₙHom
 
 section cfcₙL
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `cfcₙHom` bundled as a continuous linear map. -/
 @[simps apply]
 noncomputable def cfcₙL {a : A} (ha : p a) : C(σₙ R a, R)₀ →L[R] A :=
@@ -411,6 +412,7 @@ lemma cfcₙ_sum_univ {ι : Type*} [Fintype ι] (f : ι → R → R) (a : A)
     cfcₙ (∑ i, f i) a = ∑ i, cfcₙ (f i) a :=
   cfcₙ_sum f a _ (fun i _ ↦ hf i) (fun i _ ↦ hf0 i)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cfcₙ_smul {S : Type*} [SMulZeroClass S R] [ContinuousConstSMul S R]
     [SMulZeroClass S A] [IsScalarTower S R A] [IsScalarTower S R (R → R)]
     (s : S) (f : R → R) (a : A) (hf : ContinuousOn f (σₙ R a) := by cfc_cont_tac)
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unique.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unique.lean
index 45f381d02..8204209ff 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unique.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@@ -284,6 +284,7 @@ section IsTopologicalRing
 
 variable [TopologicalSpace A] [IsSemitopologicalRing A]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a non-unital star `ℝ≥0`-algebra homomorphism `φ` from `C(X, ℝ≥0)₀` into a non-unital
 `ℝ`-algebra `A`, this is the unique extension of `φ` from `C(X, ℝ)₀` to `A` as a non-unital
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean
index 9587d3ffd..536c43d33 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean
@@ -284,6 +284,7 @@ end cfcHom
 
 section cfcL
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `cfcHom` bundled as a continuous linear map. -/
 @[simps apply]
 noncomputable def cfcL {a : A} (ha : p a) : C(spectrum R a, R) →L[R] A :=
@@ -517,6 +518,7 @@ lemma cfc_sum_univ {ι : Type*} [Fintype ι] (f : ι → R → R) (a : A)
     cfc (∑ i, f i) a = ∑ i, cfc (f i) a :=
   cfc_sum f a _ fun i _ ↦ hf i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cfc_smul {S : Type*} [SMul S R] [ContinuousConstSMul S R]
     [SMulZeroClass S A] [IsScalarTower S R A] [IsScalarTower S R (R → R)]
     (s : S) (f : R → R) (a : A) (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac) :
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/GelfandNaimarkSegal.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/GelfandNaimarkSegal.lean
index 3a577b007..bb00cbac6 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/GelfandNaimarkSegal.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/GelfandNaimarkSegal.lean
@@ -69,6 +69,7 @@ lemma ofPreGNS_toPreGNS (a : A) : f.ofPreGNS (f.toPreGNS a) = a := rfl
 
 variable [StarOrderedRing A]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The (semi-)inner product space whose elements are the elements of `A`, but which has an
 inner product-induced norm that is different from the norm on `A` and which is induced by `f`.
@@ -85,12 +86,15 @@ noncomputable instance : SeminormedAddCommGroup f.PreGNS :=
 noncomputable instance : InnerProductSpace ℂ f.PreGNS :=
   InnerProductSpace.ofCore f.preGNSpreInnerProdSpace
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma preGNS_inner_def (a b : f.PreGNS) :
     ⟪a, b⟫_ℂ = f (star (f.ofPreGNS a) * f.ofPreGNS b) := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma preGNS_norm_def (a : f.PreGNS) :
     ‖a‖ = √(f (star (f.ofPreGNS a) * f.ofPreGNS a)).re := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma preGNS_norm_sq (a : f.PreGNS) :
     ‖a‖ ^ 2 = f (star (f.ofPreGNS a) * f.ofPreGNS a) := by
   have : 0 ≤ f (star (f.ofPreGNS a) * f.ofPreGNS a) := f.map_nonneg (star_mul_self_nonneg _)
@@ -129,6 +133,7 @@ lemma leftMulMapPreGNS_mul_eq_comp (a b : A) :
     f.leftMulMapPreGNS (a * b) = f.leftMulMapPreGNS a ∘L f.leftMulMapPreGNS b := by
   ext c; simp [mul_assoc]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 This proves map_smul' of gnsNonUnitalStarAlgHom so that map_zero' can be proven as a direct
 consequence.
@@ -143,6 +148,7 @@ private lemma completion_leftMulMapPreGNS_map_smul (m : ℂ) (x : A) :
       (m • (f.leftMulMapPreGNS x).completion).continuous
   | ih a => simp [smul_mul_assoc]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The non-unital ⋆-homomorphism/⋆-representation of `A` into the algebra of bounded operators on
 a Hilbert space that is constructed from a positive linear functional `f` on a possibly non-unital
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/Matrix.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/Matrix.lean
index 177e5295e..bc4bee359 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/Matrix.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/Matrix.lean
@@ -249,6 +249,7 @@ lemma l2_opNorm_diagonal (v : n → 𝕜) : ‖(diagonal v : Matrix n n 𝕜)‖
 lemma l2_opNNNorm_diagonal (v : n → 𝕜) : ‖(diagonal v : Matrix n n 𝕜)‖₊ = ‖v‖₊ :=
   Subtype.ext <| l2_opNorm_diagonal (n := n) (𝕜 := 𝕜) v
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The normed algebra structure on `Matrix n n 𝕜` arising from the operator norm given by the
 identification with (continuous) linear endomorphisms of `EuclideanSpace 𝕜 n`. -/
 @[instance_reducible]
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/Multiplier.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/Multiplier.lean
index 5ba03960d..c0b2526ac 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/Multiplier.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/Multiplier.lean
@@ -460,6 +460,7 @@ theorem coe_eq_algebraMap : (DoubleCentralizer.coe 𝕜 : 𝕜 → 𝓜(𝕜, 
   · refine ContinuousLinearMap.ext fun y => ?_
     exact mul_comm y x  -- `snd` multiplies on the wrong side
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The coercion of an algebra into its multiplier algebra as a non-unital star algebra
 homomorphism. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/PositiveLinearMap.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/PositiveLinearMap.lean
index 22ba7dd88..b0ee372fb 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/PositiveLinearMap.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/PositiveLinearMap.lean
@@ -56,6 +56,7 @@ lemma norm_apply_le_of_nonneg [StarOrderedRing B₂] (f : B₁ →ₚ[ℂ] B₂)
   rw [← Algebra.algebraMap_eq_smul_one]
   exact IsSelfAdjoint.le_algebraMap_norm_self <| .of_nonneg hx
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open Complex Filter in
 /--
 If `f` is a positive map, then it is bounded (and therefore continuous).
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/Spectrum.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/Spectrum.lean
index 951ea294c..55825c2da 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/Spectrum.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/Spectrum.lean
@@ -323,6 +323,7 @@ open scoped ComplexStarModule
 
 variable {F A : Type*} [CStarAlgebra A] [FunLike F A ℂ] [hF : AlgHomClass F ℂ A ℂ]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- This instance is provided instead of `StarHomClass` to avoid type class inference loops.
 See note [lower instance priority] -/
 noncomputable instance (priority := 100) Complex.instStarHomClass : StarHomClass F A ℂ where
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/Unitization.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/Unitization.lean
index 7416f4df1..68fef0820 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/Unitization.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/Unitization.lean
@@ -56,6 +56,7 @@ variable [DenselyNormedField 𝕜] [NonUnitalNormedRing E] [StarRing E] [CStarRi
 variable [NormedSpace 𝕜 E] [IsScalarTower 𝕜 E E] [SMulCommClass 𝕜 E E]
 variable (E)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A C⋆-algebra over a densely normed field is a regular normed algebra. -/
 instance CStarRing.instRegularNormedAlgebra : RegularNormedAlgebra 𝕜 E where
diff --git a/mathlib4/Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean b/mathlib4/Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean
index 084664a10..b9eb6b079 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean
@@ -979,6 +979,7 @@ lemma iteratedFDeriv_comp_sub (n : ℕ) (a : E) (x : E) :
     iteratedFDeriv 𝕜 n (fun z ↦ f (z - a)) x = iteratedFDeriv 𝕜 n f (x - a) := by
   simp [iteratedFDeriv_comp_sub']
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma iteratedFDerivWithin_comp_neg {f : 𝕜 → F} {s : Set 𝕜} (n : ℕ) (a : 𝕜) :
     iteratedFDerivWithin 𝕜 n (fun x ↦ f (-x)) s a
       = (-1 : 𝕜) ^ n • iteratedFDerivWithin 𝕜 n f (-s) (-a) := by
diff --git a/mathlib4/Mathlib/Analysis/Calculus/Deriv/Basic.lean b/mathlib4/Mathlib/Analysis/Calculus/Deriv/Basic.lean
index 99b298181..bb4df2f72 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/Deriv/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/Deriv/Basic.lean
@@ -456,6 +456,7 @@ theorem norm_derivWithin_eq_norm_fderivWithin : ‖derivWithin f s x‖ = ‖fde
 
 theorem fderiv_apply_one_eq_deriv : (fderiv 𝕜 f x : 𝕜 → F) 1 = deriv f x := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem fderiv_eq_smul_deriv (y : 𝕜) : (fderiv 𝕜 f x : 𝕜 → F) y = y • deriv f x := by
   rw [← fderiv_apply_one_eq_deriv, ← map_smul]
diff --git a/mathlib4/Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean b/mathlib4/Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean
index 513adb09e..600dd4cd3 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean
@@ -212,6 +212,7 @@ variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddComm
 section
 include s_conv hf xs hx
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Assume that `f` is differentiable inside a convex set `s`, and that its derivative `f'` is
 differentiable at a point `x`. Then, given two vectors `v` and `w` pointing inside `s`, one can
@@ -391,6 +392,7 @@ theorem Convex.second_derivative_within_at_symmetric_of_mem_interior {v w : E}
 
 end
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If a function is differentiable inside a convex set with nonempty interior, and has a second
 derivative at a point of this convex set, then this second derivative is symmetric. -/
diff --git a/mathlib4/Mathlib/Analysis/Calculus/Rademacher.lean b/mathlib4/Mathlib/Analysis/Calculus/Rademacher.lean
index fb1a49805..22c4169c9 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/Rademacher.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/Rademacher.lean
@@ -201,6 +201,7 @@ theorem integral_lineDeriv_mul_eq
     · exact h'g.mul_left
   · exact (hf.continuous.mul hg.continuous).integrable_of_hasCompactSupport h'g.mul_left
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The line derivative of a Lipschitz function is almost everywhere linear with respect to fixed
 coefficients. -/
 theorem ae_lineDeriv_sum_eq
diff --git a/mathlib4/Mathlib/Analysis/Complex/Harmonic/Analytic.lean b/mathlib4/Mathlib/Analysis/Complex/Harmonic/Analytic.lean
index bcf8efc29..a49864ae2 100644
--- a/mathlib4/Mathlib/Analysis/Complex/Harmonic/Analytic.lean
+++ b/mathlib4/Mathlib/Analysis/Complex/Harmonic/Analytic.lean
@@ -63,6 +63,7 @@ theorem HarmonicAt.analyticAt_complex_partial (hf : HarmonicAt f x) :
     (fun _ hy ↦ (HarmonicAt.differentiableAt_complex_partial hy).differentiableWithinAt)
     ((isOpen_setOfPred_harmonicAt f).mem_nhds hf)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-
 If a function `f : ℂ → ℝ` is harmonic on an open ball, then `f` is the real part of a function
 `F : ℂ → ℂ` that is holomorphic on the ball.
@@ -103,6 +104,7 @@ theorem InnerProductSpace.HarmonicOnNhd.exists_analyticOnNhd_ball_re_eq {z : ℂ
 alias harmonic_is_realOfHolomorphic :=
   InnerProductSpace.HarmonicOnNhd.exists_analyticOnNhd_ball_re_eq
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 If a function `f : ℂ → ℝ` is harmonic, then `f` is the real part of a holomorphic function.
 -/
diff --git a/mathlib4/Mathlib/Analysis/Convex/Approximation.lean b/mathlib4/Mathlib/Analysis/Convex/Approximation.lean
index 5ed0b00ca..2795408d5 100644
--- a/mathlib4/Mathlib/Analysis/Convex/Approximation.lean
+++ b/mathlib4/Mathlib/Analysis/Convex/Approximation.lean
@@ -62,6 +62,7 @@ section RCLike
 variable [AddCommGroup E] [Module ℝ E] [Module 𝕜 E] [IsScalarTower ℝ 𝕜 E] [IsTopologicalAddGroup E]
   [ContinuousSMul 𝕜 E] [LocallyConvexSpace ℝ E]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `φ : E → ℝ` be a convex and lower-semicontinuous function on a closed convex subset `s`. For
 any point `x ∈ s` and `a < φ x`, there exists a continuous affine linear function `f` in `E` such
 that `f ≤ φ` on `s` and `f x = a`. This is an auxiliary lemma used in the proof of
@@ -88,6 +89,7 @@ lemma exists_affine_le_of_lt {x : E} {a : ℝ} (hx : x ∈ s) (hax : a < φ x) (
       using mul_le_mul_of_nonneg_left (hine z.2).le hc.le
   · simp [u, c, smul_re]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma exists_affine_le_of_lt_real {s : Set ℝ} {f : ℝ → ℝ} {x : ℝ} {a : ℝ} (hx : x ∈ s)
     (hax : a < f x) (hsc : IsClosed s) (hfc : LowerSemicontinuousOn f s) (hf : ConvexOn ℝ s f) :
     ∃ (c c' : ℝ), (∀ y ∈ s, c * y + c' ≤ f y) ∧ c * x + c' = a := by
diff --git a/mathlib4/Mathlib/Analysis/Convex/EGauge.lean b/mathlib4/Mathlib/Analysis/Convex/EGauge.lean
index 92f81aab4..3117d7b35 100644
--- a/mathlib4/Mathlib/Analysis/Convex/EGauge.lean
+++ b/mathlib4/Mathlib/Analysis/Convex/EGauge.lean
@@ -225,6 +225,7 @@ theorem egauge_prod_mk {F : Type*} [AddCommGroup F] [Module 𝕜 F] {U : Set E}
   | inl hle => exact ⟨y, ⟨hU.smul_mono hle hx, hy⟩, hyr⟩
   | inr hle => exact ⟨x, ⟨hx, hV.smul_mono hle hy⟩, hxr⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem egauge_add_add_le {U V : Set E} (hU : Balanced 𝕜 U) (hV : Balanced 𝕜 V) (a b : E) :
     egauge 𝕜 (U + V) (a + b) ≤ max (egauge 𝕜 U a) (egauge 𝕜 V b) := by
   rw [← egauge_prod_mk hU hV a b, ← add_image_prod]
diff --git a/mathlib4/Mathlib/Analysis/Convex/Side.lean b/mathlib4/Mathlib/Analysis/Convex/Side.lean
index 46445050b..6d10df313 100644
--- a/mathlib4/Mathlib/Analysis/Convex/Side.lean
+++ b/mathlib4/Mathlib/Analysis/Convex/Side.lean
@@ -916,6 +916,7 @@ open AffineSubspace
 variable [Field R] [LinearOrder R] [IsStrictOrderedRing R] [AddCommGroup V] [Module R V]
 variable [AddTorsor V P] {n : ℕ} [NeZero n] (s : Simplex R P n)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma sSameSide_affineSpan_faceOpposite_of_sign_eq {w₁ w₂ : Fin (n + 1) → R} (hw₁ : ∑ j, w₁ j = 1)
     (hw₂ : ∑ j, w₂ j = 1) {i : Fin (n + 1)} (hs : SignType.sign (w₁ i) = SignType.sign (w₂ i))
diff --git a/mathlib4/Mathlib/Analysis/Distribution/ContDiffMapSupportedIn.lean b/mathlib4/Mathlib/Analysis/Distribution/ContDiffMapSupportedIn.lean
index e033d86ed..58bba13d7 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/ContDiffMapSupportedIn.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/ContDiffMapSupportedIn.lean
@@ -313,6 +313,7 @@ lemma toBoundedContinuousFunctionLM_eq_of_scalars (𝕜' : Type*) [NontriviallyN
     (toBoundedContinuousFunctionLM 𝕜 : 𝓓^{n}_{K}(E, F) → _) = toBoundedContinuousFunctionLM 𝕜' :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable {𝕜} in
 -- Note: generalizing this to a semilinear setting would require a semilinear version of
 -- `CompatibleSMul`.
@@ -540,6 +541,7 @@ instance isUniformAddGroup : IsUniformAddGroup 𝓓^{n}_{K}(E, F) := by
   rw [ContDiffMapSupportedIn.uniformSpace_eq_iInf]
   exact isUniformAddGroup_iInf fun _ ↦ IsUniformAddGroup.comap _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance continuousSMul : ContinuousSMul 𝕜 𝓓^{n}_{K}(E, F) :=
   continuousSMul_iInf fun i ↦ continuousSMul_induced (structureMapLM 𝕜 n i)
 
@@ -952,6 +954,7 @@ protected theorem integrable_bilin (B : F₁ →L[𝕜] F₂ →L[𝕜] F₃) {
 
 variable [SMulCommClass ℝ 𝕜 F₁] [NormedSpace ℝ F₃] [SMulCommClass ℝ 𝕜 F₃]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 -- TODO: semilinearize
 /-- Given a continuous `𝕜`-bilinear map `B : F₁ →L[𝕜] F₂ →L[𝕜] F₃`, a measure `μ` on `E`,
 and a function `φ : E → F₂` which is `μ`-integrable on `K`, this is the `𝕜`-linear map
diff --git a/mathlib4/Mathlib/Analysis/Distribution/Distribution.lean b/mathlib4/Mathlib/Analysis/Distribution/Distribution.lean
index 141a771d7..3b3bb6d47 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/Distribution.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/Distribution.lean
@@ -240,6 +240,7 @@ lemma lineDerivCLM_add {v₁ v₂ : E} :
   ext T f
   simp [lineDerivCLM_apply, TestFunction.lineDerivCLM_add, neg_add, -neg_add_rev]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma lineDerivCLM_smul {c : ℝ} {v : E} :
     (lineDerivCLM (c • v) : 𝓓'^{k}(Ω, F) →L[ℝ] 𝓓'^{n}(Ω, F)) =
       c • lineDerivCLM v := by
@@ -268,6 +269,7 @@ noncomputable instance : LineDerivAdd E 𝓓'(Ω, F) 𝓓'(Ω, F) where
   lineDerivOp_add v := map_add (lineDerivCLM v)
   lineDerivOp_left_add _ _ T := congr($lineDerivCLM_add T)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance : LineDerivSMul ℝ E 𝓓'(Ω, F) 𝓓'(Ω, F) where
   lineDerivOp_smul v := map_smul (lineDerivCLM v)
 
diff --git a/mathlib4/Mathlib/Analysis/Distribution/FourierMultiplier.lean b/mathlib4/Mathlib/Analysis/Distribution/FourierMultiplier.lean
index 3ea062996..8d4979d04 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/FourierMultiplier.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/FourierMultiplier.lean
@@ -104,6 +104,7 @@ theorem lineDeriv_eq_fourierMultiplierCLM (m : E) (f : 𝓢(E, F)) :
 
 open Laplacian
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem laplacian_eq_fourierMultiplierCLM (f : 𝓢(E, F)) :
     Δ f = -(2 * π) ^ 2 • fourierMultiplierCLM F (‖·‖ ^ 2) f := by
   let ι := Fin (Module.finrank ℝ E)
@@ -152,6 +153,7 @@ theorem fourierMultiplierCLM_apply_apply (g : E → ℂ) (f : 𝓢'(E, F)) (u :
     fourierMultiplierCLM F g f u = f (𝓕 (SchwartzMap.smulLeftCLM ℂ g (𝓕⁻ u))) := by
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem fourierMultiplierCLM_const (c : ℂ) :
     fourierMultiplierCLM F (fun (_ : E) ↦ c) = c • ContinuousLinearMap.id _ _ := by
@@ -205,6 +207,7 @@ theorem lineDeriv_eq_fourierMultiplierCLM (m : E) (f : 𝓢'(E, F)) :
 
 open Laplacian
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem laplacian_eq_fourierMultiplierCLM (f : 𝓢'(E, F)) :
     Δ f = -(2 * π) ^ 2 • fourierMultiplierCLM F (fun x ↦ Complex.ofReal (‖x‖ ^ 2)) f := by
   let ι := Fin (Module.finrank ℝ E)
diff --git a/mathlib4/Mathlib/Analysis/Distribution/TemperedDistribution.lean b/mathlib4/Mathlib/Analysis/Distribution/TemperedDistribution.lean
index 3bbfd1242..5836b0478 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/TemperedDistribution.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/TemperedDistribution.lean
@@ -253,6 +253,7 @@ theorem smulLeftCLM_apply_apply (g : E → ℂ) (f : 𝓢'(E, F)) (f' : 𝓢(E,
     smulLeftCLM F g f f' = f (SchwartzMap.smulLeftCLM ℂ g f') := by
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem smulLeftCLM_const (c : ℂ) (f : 𝓢'(E, F)) : smulLeftCLM F (fun _ : E ↦ c) f = c • f := by
   ext1; simp
@@ -269,6 +270,7 @@ theorem smulLeftCLM_compL_smulLeftCLM {g₁ g₂ : E → ℂ} (hg₁ : g₁.HasT
   ext1 f
   simp [hg₁, hg₂]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem smulLeftCLM_smul {g : E → ℂ} (hg : g.HasTemperateGrowth) (c : ℂ) :
     smulLeftCLM F (c • g) = c • smulLeftCLM F g := by
   ext f u
@@ -555,6 +557,7 @@ open LineDeriv Real
 
 variable [NormedAddCommGroup F] [NormedSpace ℂ F]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The line derivative in direction `m` of the Fourier transform is given by the Fourier transform
 of the multiplication with `-(2 * π * Complex.I) • (inner ℝ · m)`. -/
 theorem lineDerivOp_fourier_eq (f : 𝓢'(E, F)) (m : E) :
@@ -563,6 +566,7 @@ theorem lineDerivOp_fourier_eq (f : 𝓢'(E, F)) (m : E) :
   have : (inner ℝ · m).HasTemperateGrowth := by fun_prop
   simp [SchwartzMap.fourier_lineDerivOp_eq, ← smulLeftCLM_ofReal ℂ this]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The Fourier transform of line derivative in direction `m` is given by multiplication of
 `(2 * π * Complex.I) • (inner ℝ · m)` with the Fourier transform. -/
 theorem fourier_lineDerivOp_eq (f : 𝓢'(E, F)) (m : E) :
@@ -571,6 +575,7 @@ theorem fourier_lineDerivOp_eq (f : 𝓢'(E, F)) (m : E) :
   have : (inner ℝ · m).HasTemperateGrowth := by fun_prop
   simp [SchwartzMap.lineDerivOp_fourier_eq, ← smulLeftCLM_ofReal ℂ this]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The line derivative in direction `m` of the inverse Fourier transform is given by the inverse
 Fourier transform of the multiplication with `(2 * π * Complex.I) • (inner ℝ · m)`. -/
 theorem lineDerivOp_fourierInv_eq (f : 𝓢'(E, F)) (m : E) :
@@ -579,6 +584,7 @@ theorem lineDerivOp_fourierInv_eq (f : 𝓢'(E, F)) (m : E) :
   have : (inner ℝ · m).HasTemperateGrowth := by fun_prop
   simp [SchwartzMap.fourierInv_lineDerivOp_eq, ← smulLeftCLM_ofReal ℂ this]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The inverse Fourier transform of line derivative in direction `m` is given by multiplication of
 `-(2 * π * Complex.I) • (inner ℝ · m)` with the inverse Fourier transform. -/
 theorem fourierInv_lineDerivOp_eq (f : 𝓢'(E, F)) (m : E) :
diff --git a/mathlib4/Mathlib/Analysis/Distribution/TestFunction.lean b/mathlib4/Mathlib/Analysis/Distribution/TestFunction.lean
index 93e58459d..226ca7081 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/TestFunction.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/TestFunction.lean
@@ -328,6 +328,7 @@ noncomputable def ofSupportedInCLM [SMulCommClass ℝ 𝕜 F] {K : Compacts E}
     (ofSupportedInCLM 𝕜 K_sub_Ω : 𝓓^{n}_{K}(E, F) → 𝓓^{n}(Ω, F)) = ofSupportedIn K_sub_Ω :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The **universal property** of the topology on `𝓓^{n}(Ω, F)`: a **linear** map from
 `𝓓^{n}(Ω, F)` to a locally convex topological vector space is continuous if and only if its
 precomposition with the inclusion `ofSupportedIn K_sub_Ω : 𝓓^{n}_{K}(E, F) → 𝓓^{n}(Ω, F)` is
@@ -627,6 +628,7 @@ noncomputable instance : LineDerivAdd E 𝓓(Ω, F) 𝓓(Ω, F) where
   lineDerivOp_add v := map_add (lineDerivCLM ℝ v)
   lineDerivOp_left_add _ _ f := congr($lineDerivCLM_add f)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance : LineDerivSMul 𝕜 E 𝓓(Ω, F) 𝓓(Ω, F) where
   lineDerivOp_smul v := map_smul (lineDerivCLM 𝕜 v)
 
diff --git a/mathlib4/Mathlib/Analysis/Fourier/BoundedContinuousFunctionChar.lean b/mathlib4/Mathlib/Analysis/Fourier/BoundedContinuousFunctionChar.lean
index 508771150..407a0c1b4 100644
--- a/mathlib4/Mathlib/Analysis/Fourier/BoundedContinuousFunctionChar.lean
+++ b/mathlib4/Mathlib/Analysis/Fourier/BoundedContinuousFunctionChar.lean
@@ -77,6 +77,7 @@ lemma char_add_eq_mul (x y : W) :
 lemma char_neg (w : W) :
     char he hL (-w) = star (char he hL w) := by ext; simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `e` and `L` are non-trivial, then `char he hL w, w : W` separates points in `V`. -/
 theorem ext_of_char_eq (he : Continuous e) (he' : e ≠ 1)
diff --git a/mathlib4/Mathlib/Analysis/Fourier/FourierTransformDeriv.lean b/mathlib4/Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
index 0a07d0093..38d7bfe74 100644
--- a/mathlib4/Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
+++ b/mathlib4/Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
@@ -760,6 +760,7 @@ lemma pow_mul_norm_iteratedFDeriv_fourier_le
   gcongr
   exact norm_innerSL_le _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma hasDerivAt_fourier
     {f : ℝ → E} (hf : Integrable f) (hf' : Integrable (fun x : ℝ ↦ x • f x)) (w : ℝ) :
     HasDerivAt (𝓕 f) (𝓕 (fun x : ℝ ↦ (-2 * π * I * x) • f x) w) w := by
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
index 56f6dc9ef..e25b8ee03 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
@@ -923,6 +923,7 @@ theorem conjStarAlgEquiv_trans {G : Type*} [NormedAddCommGroup G] [InnerProductS
     [CompleteSpace G] (e : H ≃ₗᵢ[𝕜] K) (f : K ≃ₗᵢ[𝕜] G) :
     (e.trans f).conjStarAlgEquiv = e.conjStarAlgEquiv.trans f.conjStarAlgEquiv := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open ContinuousLinearEquiv ContinuousLinearMap in
 theorem conjStarAlgEquiv_ext_iff (f g : H ≃ₗᵢ[𝕜] K) :
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Basic.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Basic.lean
index df294ad3a..d2bd50b21 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Basic.lean
@@ -874,6 +874,7 @@ section Induced
 variable {G : Type*} [SeminormedAddCommGroup E] [InnerProductSpace 𝕜 E] [AddCommGroup G]
     [Module 𝕜 G]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear map from a `Module` to an `InnerProductSpace` induces an `InnerProductSpace`
 structure on the domain using the `SeminormedAddCommGroup.induced` norm.
 
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Coalgebra.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Coalgebra.lean
index a4e67bc0f..eff1a9519 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Coalgebra.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Coalgebra.lean
@@ -138,6 +138,7 @@ noncomputable abbrev ringOfCoalgebra :
       adjoint_toLinearMap_eq_symm]
     exact one_smul _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] InnerProductSpace.ringOfCoalgebra in
 /-- A finite-dimensional inner product space with a coalgebra structure induces an algebra
 structure, where `x * y = (adjoint comul) (x ⊗ₜ y)`, `1 = (adjoint counit) 1` and
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Dual.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Dual.lean
index 03916c4cf..03ee4e4f0 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Dual.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Dual.lean
@@ -129,6 +129,7 @@ theorem ext_inner_right_basis {ι : Type*} {x y : E} (b : Basis ι 𝕜 E)
 variable (𝕜) (E)
 variable [CompleteSpace E]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- **Fréchet-Riesz representation**: any `ℓ` in the dual of a Hilbert space `E` is of the form
 `fun u => ⟪y, u⟫` for some `y : E`, i.e. `toDualMap` is surjective.
 -/
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearMap.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearMap.lean
index 16e5a58b1..8e676b6a0 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearMap.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearMap.lean
@@ -49,6 +49,7 @@ section Complex_Seminormed
 
 variable {V : Type*} [SeminormedAddCommGroup V] [InnerProductSpace ℂ V]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A complex polarization identity, with a linear map. -/
 theorem inner_map_polarization (T : V →ₗ[ℂ] V) (x y : V) :
@@ -62,6 +63,7 @@ theorem inner_map_polarization (T : V →ₗ[ℂ] V) (x y : V) :
     mul_add, ← mul_assoc, mul_neg, neg_neg, one_mul, neg_one_mul, mul_sub, sub_sub]
   ring
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem inner_map_polarization' (T : V →ₗ[ℂ] V) (x y : V) :
     ⟪T x, y⟫_ℂ =
@@ -109,6 +111,7 @@ variable {ι : Type*} {ι' : Type*} {ι'' : Type*}
 variable {E' : Type*} [SeminormedAddCommGroup E'] [InnerProductSpace 𝕜 E']
 variable {E'' : Type*} [SeminormedAddCommGroup E''] [InnerProductSpace 𝕜 E'']
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A linear isometry preserves the inner product. -/
 @[simp]
@@ -281,6 +284,7 @@ theorem ContinuousLinearMap.reApplyInnerSelf_continuous (T : E →L[𝕜] E) :
     Continuous T.reApplyInnerSelf :=
   reCLM.continuous.comp <| T.continuous.inner continuous_id
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem ContinuousLinearMap.reApplyInnerSelf_smul (T : E →L[𝕜] E) (x : E) {c : 𝕜} :
     T.reApplyInnerSelf (c • x) = ‖c‖ ^ 2 * T.reApplyInnerSelf x := by
@@ -360,6 +364,7 @@ variable {F H : Type*} [NormedAddCommGroup F] [InnerProductSpace 𝕜 F]
 lemma rankOne_ne_zero {x : E} {y : F} (hx : x ≠ 0) (hy : y ≠ 0) : rankOne 𝕜 x y ≠ 0 := by
   grind [rankOne_eq_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem isIdempotentElem_rankOne_self_iff {x : F} (hx : x ≠ 0) :
     IsIdempotentElem (rankOne 𝕜 x x) ↔ ‖x‖ = 1 := by
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/NormDet.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/NormDet.lean
index 4647f2e64..3ee5f9199 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/NormDet.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/NormDet.lean
@@ -238,6 +238,7 @@ theorem normDet_zero : (0 : U →ₗ[𝕜] V).normDet = 0 ^ finrank 𝕜 U := by
   nontriviality U
   simp [zero_pow finrank_pos.ne.symm, normDet_eq_zero_iff_ker_ne_bot]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem normDet_smul (f : U →ₗ[𝕜] V) (c : 𝕜) :
     (c • f).normDet = ‖c‖ ^ finrank 𝕜 U * f.normDet := by
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/OfNorm.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/OfNorm.lean
index b68ffaac4..81a290d1c 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/OfNorm.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/OfNorm.lean
@@ -159,6 +159,7 @@ theorem add_left (x y z : E) : inner_ 𝕜 (x + y) z = inner_ 𝕜 x z + inner_
   abel_nf at * -- TODO this should be `module_nf` (then the `smul_add` above can go)
   linear_combination (- h1 + h2 + h3 - h4 + I * (- h5 + h6 + h7 - h8)) / 8
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
   intro x y
   let hom : 𝕜 →ₗ[ℚ] 𝕜 := AddMonoidHom.toRatLinearMap <|
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/PiL2.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/PiL2.lean
index a938a909f..36800d9bf 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/PiL2.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/PiL2.lean
@@ -403,6 +403,7 @@ theorem repr_injective :
   cases g
   congr
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `b i` is the `i`th basis vector. -/
 instance instFunLike : FunLike (OrthonormalBasis ι 𝕜 E) ι E where
@@ -421,6 +422,7 @@ instance instFunLike : FunLike (OrthonormalBasis ι 𝕜 E) ι E where
           LinearIsometryEquiv.coe_symm_toLinearEquiv] at h ⊢
         rw [h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_ofRepr [DecidableEq ι] (e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι) :
     ⇑(OrthonormalBasis.ofRepr e) = fun i => e.symm (EuclideanSpace.single i (1 : 𝕜)) := by
@@ -428,23 +430,27 @@ theorem coe_ofRepr [DecidableEq ι] (e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 
   funext
   congr!
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem repr_symm_single [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     b.repr.symm (EuclideanSpace.single i (1 : 𝕜)) = b i := by
   dsimp only [DFunLike.coe]
   congr!
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem repr_self [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     b.repr (b i) = EuclideanSpace.single i (1 : 𝕜) := by
   rw [← b.repr_symm_single i, LinearIsometryEquiv.apply_symm_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem repr_apply_apply (b : OrthonormalBasis ι 𝕜 E) (v : E) (i : ι) :
     b.repr v i = ⟪b i, v⟫ := by
   classical
     rw [← b.repr.inner_map_map (b i) v, b.repr_self i, EuclideanSpace.inner_single_left]
     simp only [one_mul, map_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem orthonormal (b : OrthonormalBasis ι 𝕜 E) : Orthonormal 𝕜 b := by
   classical
@@ -453,25 +459,31 @@ protected theorem orthonormal (b : OrthonormalBasis ι 𝕜 E) : Orthonormal 
     rw [← b.repr.inner_map_map (b i) (b j), b.repr_self i, b.repr_self j,
       EuclideanSpace.inner_single_left, PiLp.single_apply, map_one, one_mul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma norm_eq_one (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     ‖b i‖ = 1 := b.orthonormal.norm_eq_one i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma nnnorm_eq_one (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     ‖b i‖₊ = 1 := b.orthonormal.nnnorm_eq_one i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma enorm_eq_one (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     ‖b i‖ₑ = 1 := b.orthonormal.enorm_eq_one i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma inner_eq_zero (b : OrthonormalBasis ι 𝕜 E) {i j : ι} (hij : i ≠ j) :
     ⟪b i, b j⟫ = 0 := b.orthonormal.inner_eq_zero hij
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma inner_eq_one (b : OrthonormalBasis ι 𝕜 E) (i : ι) : ⟪b i, b i⟫ = 1 := by
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma inner_eq_ite [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i j : ι) :
     ⟪b i, b j⟫ = if i = j then 1 else 0 := by
   by_cases h : i = j <;> simp [h]
@@ -480,6 +492,7 @@ lemma inner_eq_ite [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i j : ι)
 protected def toBasis (b : OrthonormalBasis ι 𝕜 E) : Basis ι 𝕜 E :=
   Basis.ofEquivFun (b.repr.toLinearEquiv.trans (WithLp.linearEquiv 2 𝕜 (ι → 𝕜)))
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem coe_toBasis (b : OrthonormalBasis ι 𝕜 E) : (⇑b.toBasis : ι → E) = ⇑b := rfl
 
@@ -493,18 +506,22 @@ protected theorem coe_toBasis_repr_apply (b : OrthonormalBasis ι 𝕜 E) (x : E
     b.toBasis.repr x i = b.repr x i := by
   simp [← Basis.equivFun_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem sum_repr (b : OrthonormalBasis ι 𝕜 E) (x : E) : ∑ i, b.repr x i • b i = x := by
   simp_rw [← b.coe_toBasis_repr_apply, ← b.coe_toBasis]
   exact b.toBasis.sum_repr x
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped InnerProductSpace in
 protected theorem sum_repr' (b : OrthonormalBasis ι 𝕜 E) (x : E) : ∑ i, ⟪b i, x⟫_𝕜 • b i = x := by
   nth_rw 2 [← (b.sum_repr x)]
   simp_rw [b.repr_apply_apply x]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem sum_repr_symm (b : OrthonormalBasis ι 𝕜 E) (v : EuclideanSpace 𝕜 ι) :
     ∑ i, v i • b i = b.repr.symm v := by simpa using (b.toBasis.equivFun_symm_apply v).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem sum_inner_mul_inner (b : OrthonormalBasis ι 𝕜 E) (x y : E) :
     ∑ i, ⟪x, b i⟫ * ⟪b i, y⟫ = ⟪x, y⟫ := by
   have := congr_arg (innerSL 𝕜 x) (b.sum_repr y)
@@ -513,6 +530,7 @@ protected theorem sum_inner_mul_inner (b : OrthonormalBasis ι 𝕜 E) (x y : E)
   rw [map_smul, b.repr_apply_apply, mul_comm]
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma sum_sq_norm_inner_right (b : OrthonormalBasis ι 𝕜 E) (x : E) :
     ∑ i, ‖⟪b i, x⟫‖ ^ 2 = ‖x‖ ^ 2 := by
   rw [@norm_eq_sqrt_re_inner 𝕜, ← OrthonormalBasis.sum_inner_mul_inner b x x, map_sum]
@@ -521,11 +539,13 @@ lemma sum_sq_norm_inner_right (b : OrthonormalBasis ι 𝕜 E) (x : E) :
   rw [Real.sq_sqrt]
   exact Fintype.sum_nonneg fun _ ↦ by positivity
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma sum_sq_norm_inner_left (b : OrthonormalBasis ι 𝕜 E) (x : E) :
     ∑ i, ‖⟪x, b i⟫‖ ^ 2 = ‖x‖ ^ 2 := by
   convert! sum_sq_norm_inner_right b x using 2 with i -
   rw [← inner_conj_symm, RCLike.norm_conj]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped RealInnerProductSpace in
 theorem sum_sq_inner_right {E : Type*} [NormedAddCommGroup E]
     [InnerProductSpace ℝ E] (b : OrthonormalBasis ι ℝ E) (x : E) :
@@ -533,12 +553,14 @@ theorem sum_sq_inner_right {E : Type*} [NormedAddCommGroup E]
   rw [← b.sum_sq_norm_inner_right]
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped RealInnerProductSpace in
 theorem sum_sq_inner_left {ι E : Type*} [NormedAddCommGroup E]
     [InnerProductSpace ℝ E] [Fintype ι] (b : OrthonormalBasis ι ℝ E) (x : E) :
     ∑ i : ι, ⟪x, b i⟫ ^ 2 = ‖x‖ ^ 2 := by
   simp_rw [← b.sum_sq_inner_right, real_inner_comm]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma norm_le_card_mul_iSup_norm_inner (b : OrthonormalBasis ι 𝕜 E) (x : E) :
     ‖x‖ ≤ √(Fintype.card ι) * ⨆ i, ‖⟪b i, x⟫‖ := by
   calc ‖x‖
@@ -554,28 +576,34 @@ lemma norm_le_card_mul_iSup_norm_inner (b : OrthonormalBasis ι 𝕜 E) (x : E)
     · simp
     · exact le_ciSup_of_le (by simp) (Nonempty.some inferInstance) (by positivity)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem orthogonalProjectionOnto_apply_eq_sum {U : Submodule 𝕜 E}
     [U.HasOrthogonalProjection] (b : OrthonormalBasis ι 𝕜 U) (x : E) :
     U.orthogonalProjectionOnto x = ∑ i, ⟪(b i : E), x⟫ • b i := by
   simpa only [b.repr_apply_apply, inner_orthogonalProjectionOnto_eq_of_mem_left] using
     (b.sum_repr (U.orthogonalProjectionOnto x)).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[deprecated (since := "2026-05-05")] alias orthogonalProjection_apply_eq_sum :=
   OrthonormalBasis.orthogonalProjectionOnto_apply_eq_sum
 
+set_option backward.isDefEq.respectTransparency.instances false in
 protected theorem orthogonalProjectionOnto_eq_sum_rankOne {U : Submodule 𝕜 E}
     [U.HasOrthogonalProjection] (b : OrthonormalBasis ι 𝕜 U) :
     U.orthogonalProjectionOnto = ∑ i, InnerProductSpace.rankOne 𝕜 (b i) (b i : E) := by
   ext; simp [b.orthogonalProjectionOnto_apply_eq_sum]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[deprecated (since := "2026-05-05")] alias orthogonalProjection_eq_sum_rankOne :=
   OrthonormalBasis.orthogonalProjectionOnto_eq_sum_rankOne
 
+set_option backward.isDefEq.respectTransparency.instances false in
 protected theorem starProjection_eq_sum_rankOne {U : Submodule 𝕜 E} [U.HasOrthogonalProjection]
     (b : OrthonormalBasis ι 𝕜 U) :
     U.starProjection = ∑ i, InnerProductSpace.rankOne 𝕜 (b i : E) (b i : E) := by
   ext; simp [starProjection, b.orthogonalProjectionOnto_eq_sum_rankOne]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma sum_rankOne_eq_id (b : OrthonormalBasis ι 𝕜 E) :
     ∑ i, InnerProductSpace.rankOne 𝕜 (b i) (b i) = .id 𝕜 E := by ext; simp [b.sum_repr']
 
@@ -584,11 +612,13 @@ protected def map {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
     (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) : OrthonormalBasis ι 𝕜 G where
   repr := L.symm.trans b.repr
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem map_apply {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
     (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) (i : ι) : b.map L i = L (b i) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma coe_map {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
     (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) : ⇑(b.map L) = L ∘ b := rfl
 
@@ -633,6 +663,7 @@ theorem _root_.Module.Basis.toBasis_toOrthonormalBasis (v : Basis ι 𝕜 E) (hv
     LinearEquiv.isometryOfInner_toLinearEquiv]
   exact v.ofEquivFun_equivFun
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem _root_.Module.Basis.coe_toOrthonormalBasis (v : Basis ι 𝕜 E) (hv : Orthonormal 𝕜 v) :
     (v.toOrthonormalBasis hv : ι → E) = (v : ι → E) :=
@@ -650,6 +681,7 @@ variable (ι 𝕜) in
 protected noncomputable def singleton : OrthonormalBasis ι 𝕜 𝕜 :=
   (Basis.singleton ι 𝕜).toOrthonormalBasis (by simp)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem singleton_apply (i) : OrthonormalBasis.singleton ι 𝕜 i = 1 := Basis.singleton_apply _ _ _
 
@@ -657,6 +689,7 @@ theorem singleton_apply (i) : OrthonormalBasis.singleton ι 𝕜 i = 1 := Basis.
 theorem singleton_repr (x i) : (OrthonormalBasis.singleton ι 𝕜).repr x i = x :=
   Basis.singleton_repr _ _ _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_singleton : ⇑(OrthonormalBasis.singleton ι 𝕜) = 1 := by
   ext; simp
@@ -683,6 +716,7 @@ theorem _root_.Pi.orthonormalBasis.toBasis {η : Type*} [Fintype η] {ι : η 
     (Pi.orthonormalBasis B).toBasis =
       ((Pi.basis fun i : η ↦ (B i).toBasis).map (WithLp.linearEquiv 2 _ _).symm) := by ext; rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem _root_.Pi.orthonormalBasis_apply {η : Type*} [Fintype η] [DecidableEq η] {ι : η → Type*}
     [∀ i, Fintype (ι i)] {𝕜 : Type*} [RCLike 𝕜] {E : η → Type*} [∀ i, NormedAddCommGroup (E i)]
@@ -715,6 +749,7 @@ protected def mk (hon : Orthonormal 𝕜 v) (hsp : ⊤ ≤ Submodule.span 𝕜 (
     OrthonormalBasis ι 𝕜 E :=
   (Basis.mk (Orthonormal.linearIndependent hon) hsp).toOrthonormalBasis (by rwa [Basis.coe_mk])
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem coe_mk (hon : Orthonormal 𝕜 v) (hsp : ⊤ ≤ Submodule.span 𝕜 (Set.range v)) :
     ⇑(OrthonormalBasis.mk hon hsp) = v := by
@@ -738,6 +773,7 @@ protected def span [DecidableEq E] {v' : ι' → E} (h : Orthonormal 𝕜 v') (s
         rfl)
   e₀.map φ.symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem span_apply [DecidableEq E] {v' : ι' → E} (h : Orthonormal 𝕜 v') (s : Finset ι')
     (i : s) : (OrthonormalBasis.span h s i : E) = v' i := by
@@ -759,6 +795,7 @@ protected def mkOfOrthogonalEqBot (hon : Orthonormal 𝕜 v) (hsp : (span 𝕜 (
       have : CompleteSpace (span 𝕜 (range v)) := FiniteDimensional.complete 𝕜 _
       rwa [orthogonal_eq_bot_iff] at hsp)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem coe_of_orthogonal_eq_bot_mk (hon : Orthonormal 𝕜 v)
     (hsp : (span 𝕜 (Set.range v))ᗮ = ⊥) : ⇑(OrthonormalBasis.mkOfOrthogonalEqBot hon hsp) = v :=
@@ -770,6 +807,7 @@ variable [Fintype ι']
 def reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') : OrthonormalBasis ι' 𝕜 E :=
   OrthonormalBasis.ofRepr (b.repr.trans (LinearIsometryEquiv.piLpCongrLeft 2 𝕜 𝕜 e))
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem reindex_apply (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') (i' : ι') :
     (b.reindex e) i' = b (e.symm i') := by
   classical
@@ -783,11 +821,13 @@ protected theorem reindex_apply (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι'
 theorem reindex_toBasis (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') :
     (b.reindex e).toBasis = b.toBasis.reindex e := Basis.eq_ofRepr_eq_repr fun _ ↦ congr_fun rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem coe_reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') :
     ⇑(b.reindex e) = b ∘ e.symm :=
   funext (b.reindex_apply e)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem repr_reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') (x : E) (i' : ι') :
     (b.reindex e).repr x i' = b.repr x (e.symm i') := by
@@ -804,6 +844,7 @@ variable (𝕜 ι)
 noncomputable def basisFun : OrthonormalBasis ι 𝕜 (EuclideanSpace 𝕜 ι) :=
   ⟨LinearIsometryEquiv.refl _ _⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem basisFun_apply [DecidableEq ι] (i : ι) : basisFun ι 𝕜 i = EuclideanSpace.single i 1 :=
   PiLp.basisFun_apply _ _ _ _
@@ -811,10 +852,12 @@ theorem basisFun_apply [DecidableEq ι] (i : ι) : basisFun ι 𝕜 i = Euclidea
 @[simp]
 theorem basisFun_repr (x : EuclideanSpace 𝕜 ι) (i : ι) : (basisFun ι 𝕜).repr x i = x i := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem basisFun_inner (x : EuclideanSpace 𝕜 ι) (i : ι) : ⟪basisFun ι 𝕜 i, x⟫ = x i := by
   simp [← OrthonormalBasis.repr_apply_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem inner_basisFun_real (x : EuclideanSpace ℝ ι) (i : ι) :
     inner ℝ x (basisFun ι ℝ i) = x i := by
@@ -842,6 +885,7 @@ lemma equiv_symm : (b.equiv b' e).symm = b'.equiv b e.symm := by
   apply b'.toBasis.ext_linearIsometryEquiv
   simp [OrthonormalBasis.equiv]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma equiv_apply_basis (i : ι) : b.equiv b' e (b i) = b' (e i) := by
   classical
@@ -850,20 +894,24 @@ lemma equiv_apply_basis (i : ι) : b.equiv b' e (b i) = b' (e i) := by
   ext j
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma equiv_self_rfl : b.equiv b (.refl ι) = .refl 𝕜 E := by
   apply b.toBasis.ext_linearIsometryEquiv
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma equiv_apply (x : E) : b.equiv b' e x = ∑ i, b.repr x i • b' (e i) := by
   nth_rw 1 [← b.sum_repr x, map_sum]
   simp_rw [map_smul, equiv_apply_basis]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma equiv_apply_euclideanSpace (x : EuclideanSpace 𝕜 ι) :
     (EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι) x = ∑ i, x i • b i := by
   simp_rw [equiv_apply, EuclideanSpace.basisFun_repr, Equiv.refl_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma coe_equiv_euclideanSpace :
     ⇑((EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι)) = fun x ↦ ∑ i, x i • b i := by
   simp_rw [← equiv_apply_euclideanSpace]
@@ -894,6 +942,7 @@ theorem Complex.toBasis_orthonormalBasisOneI :
     Complex.orthonormalBasisOneI.toBasis = Complex.basisOneI :=
   Basis.toBasis_toOrthonormalBasis _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem Complex.coe_orthonormalBasisOneI :
     (Complex.orthonormalBasisOneI : Fin 2 → ℂ) = ![1, I] := by
@@ -916,6 +965,7 @@ theorem Complex.isometryOfOrthonormal_symm_apply (v : OrthonormalBasis (Fin 2) 
       (v.toBasis.coord 0 f : ℂ) + (v.toBasis.coord 1 f : ℂ) * I := by
   simp [Complex.isometryOfOrthonormal]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Complex.isometryOfOrthonormal_apply (v : OrthonormalBasis (Fin 2) ℝ F) (z : ℂ) :
     Complex.isometryOfOrthonormal v z = z.re • v 0 + z.im • v 1 := by
   simp [Complex.isometryOfOrthonormal, ← v.sum_repr_symm]
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Positive.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Positive.lean
index 578903d59..f216d8bb3 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Positive.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Positive.lean
@@ -539,6 +539,7 @@ theorem LinearMap.IsPositive.toLinearMap_symm {T : E ≃ₗ[𝕜] E} (hT : T.IsP
     inner_smul_left, RCLike.conj_mul, ← RCLike.ofReal_pow, RCLike.ofReal_nonneg]
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- In finite-dimensional spaces, a continuous linear map is positive iff it is equal to the sum
 of rank-one positive operators. -/
 theorem ContinuousLinearMap.isPositive_iff_eq_sum_rankOne [FiniteDimensional 𝕜 E] {T : E →L[𝕜] E} :
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/ProdL2.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/ProdL2.lean
index 263b0b741..61317299f 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/ProdL2.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/ProdL2.lean
@@ -139,6 +139,8 @@ theorem sndL_comp_coe_orthogonalDecomposition :
     WithLp.sndL 2 𝕜 K Kᗮ ∘L K.orthogonalDecomposition = Kᗮ.orthogonalProjectionOnto := by
   ext; simp
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a subspace `K` of an inner product space `E` admits an orthogonal projection, then the
 quotient `E ⧸ K` is isometrically isomorphic to the orthogonal complement `Kᗮ` of `K`. -/
 def quotientEquivOrthogonal : (E ⧸ K) ≃ₗᵢ[𝕜] ↥Kᗮ where
@@ -154,29 +156,41 @@ def quotientEquivOrthogonal : (E ⧸ K) ≃ₗᵢ[𝕜] ↥Kᗮ where
     · rw [sInf_image', ← Equiv.iInf_comp (Equiv.neg K)]
       simp
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_quotientEquivOrthogonal :
     ⇑K.quotientEquivOrthogonal = K.quotientEquivOfIsCompl Kᗮ K.isCompl_orthogonal :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_quotientEquivOrthogonal_symm :
     ⇑K.quotientEquivOrthogonal.symm = (K.quotientEquivOfIsCompl Kᗮ K.isCompl_orthogonal).symm :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma toLinearEquiv_quotientEquivOrthogonal :
     (quotientEquivOrthogonal K).toLinearEquiv = K.quotientEquivOfIsCompl _ K.isCompl_orthogonal :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem quotientEquivOrthogonal_mk (x : E) (hx : x ∈ Kᗮ) :
     K.quotientEquivOrthogonal (Quotient.mk x) = ⟨x, hx⟩ := by
   simp [← K.quotientEquivOfIsCompl_apply_mk_right K.isCompl_orthogonal ⟨x, hx⟩]
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem quotientEquivOrthogonal_symm_eq_mk (x : E) (hx : x ∈ Kᗮ) :
     K.quotientEquivOrthogonal.symm ⟨x, hx⟩ = Quotient.mk x := by
   simp
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance instQuotientInnerProductSpace :
     InnerProductSpace 𝕜 (E ⧸ K) where
   inner x y := ⟪K.quotientEquivOrthogonal x, K.quotientEquivOrthogonal y⟫_𝕜
@@ -185,11 +199,15 @@ noncomputable instance instQuotientInnerProductSpace :
   conj_inner_symm x y := inner_conj_symm _ _
   norm_sq_eq_re_inner y := by rw [inner_self_eq_norm_sq, LinearIsometryEquiv.norm_map]
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem inner_quotient_eq (x y : E ⧸ K) :
     ⟪x, y⟫_𝕜 = ⟪K.quotientEquivOrthogonal x, K.quotientEquivOrthogonal y⟫_𝕜 :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Quotient.inner_mk_mk (x y : E) (hx : x ∈ Kᗮ) (hy : y ∈ Kᗮ) :
     ⟪Quotient.mk (p := K) x, Quotient.mk y⟫_𝕜 = ⟪x, y⟫_𝕜 := by
   simp [K.quotientEquivOrthogonal_mk x hx, K.quotientEquivOrthogonal_mk y hy]
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Reproducing.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Reproducing.lean
index ae5f04b69..f57eb9995 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Reproducing.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Reproducing.lean
@@ -312,6 +312,7 @@ private abbrev kerFun (x : X) :
     _ ≤ ‖K x x‖ * ‖v‖ * ‖v‖ := by simp [mul_le_mul_of_nonneg_right, le_opNorm]
     _ ≤ _ := by simp [mul_pow, mul_assoc, ← sq]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[no_expose]
 instance instRKHS : RKHS 𝕜 (OfKernel K) X V where
   coeCLM := .pi fun x ↦ (OfKernel.kerFun K x).adjoint
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Spectrum.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Spectrum.lean
index b6eaae80d..61fe9c691 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Spectrum.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Spectrum.lean
@@ -326,6 +326,7 @@ theorem apply_eigenvectorBasis (hT : T.IsSymmetric) (hn : Module.finrank 𝕜 E
     T (hT.eigenvectorBasis hn i) = (hT.eigenvalues hn i : 𝕜) • hT.eigenvectorBasis hn i :=
   mem_eigenspace_iff.mp (hT.hasEigenvector_eigenvectorBasis hn i).1
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- *Diagonalization theorem*, *spectral theorem*; version 2: A self-adjoint operator `T` on a
 finite-dimensional inner product space `E` acts diagonally on the identification of `E` with
 Euclidean space induced by an orthonormal basis of eigenvectors of `T`. -/
@@ -346,6 +347,7 @@ theorem eigenvectorBasis_apply_self_apply (hT : T.IsSymmetric) (hn : Module.finr
   intro a
   rw [smul_smul, mul_comm, ofLp_toLp]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toMatrix_eigenvectorBasis (hT : T.IsSymmetric) (hn : Module.finrank 𝕜 E = n) :
     letI b := (hT.eigenvectorBasis hn).toBasis
     T.toMatrix b b = Matrix.diagonal (RCLike.ofReal ∘ hT.eigenvalues hn) := by
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Symmetric.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Symmetric.lean
index b24cdba21..b81061c85 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Symmetric.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Symmetric.lean
@@ -195,6 +195,7 @@ theorem isSymmetric_iff_inner_map_self_real (T : V →ₗ[ℂ] V) :
 
 end Complex
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Polarization identity for symmetric linear maps.
 See `inner_map_polarization` for the complex version without the symmetric assumption. -/
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/TwoDim.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/TwoDim.lean
index 9e6e5d472..9b781ee3a 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/TwoDim.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@@ -376,6 +376,7 @@ theorem inner_mul_areaForm_sub' (a x : E) : ⟪a, x⟫ • ω a - ω a x • inn
 theorem inner_mul_areaForm_sub (a x y : E) : ⟪a, x⟫ * ω a y - ω a x * ⟪a, y⟫ = ‖a‖ ^ 2 * ω x y :=
   congr_arg (fun f : E →ₗ[ℝ] ℝ => f y) (o.inner_mul_areaForm_sub' a x)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem nonneg_inner_and_areaForm_eq_zero_iff_sameRay (x y : E) :
     0 ≤ ⟪x, y⟫ ∧ ω x y = 0 ↔ SameRay ℝ x y := by
   by_cases hx : x = 0
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/l2Space.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/l2Space.lean
index e2bc31114..c84ea88e0 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/l2Space.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/l2Space.lean
@@ -426,6 +426,7 @@ protected theorem orthonormal (b : HilbertBasis ι 𝕜 E) : Orthonormal 𝕜 b
     lp.single_apply, Pi.single_apply]
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem hasSum_repr_symm (b : HilbertBasis ι 𝕜 E) (f : ℓ²(ι, 𝕜)) :
     HasSum (fun i => f i • b i) (b.repr.symm f) := by
   classical
diff --git a/mathlib4/Mathlib/Analysis/LocallyConvex/WeakDual.lean b/mathlib4/Mathlib/Analysis/LocallyConvex/WeakDual.lean
index 881346ba1..c66cf0749 100644
--- a/mathlib4/Mathlib/Analysis/LocallyConvex/WeakDual.lean
+++ b/mathlib4/Mathlib/Analysis/LocallyConvex/WeakDual.lean
@@ -130,6 +130,7 @@ section NontriviallyNormedField
 
 variable [NontriviallyNormedField 𝕜] [AddCommGroup E] [Module 𝕜 E]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear functional `φ` is in the span of a collection of linear functionals if and only if `φ`
 is continuous with respect to the topology induced by the collection of linear functionals. See
 `LinearMap.mem_span_iff_continuous_of_finite` for a result about finite collections of linear
diff --git a/mathlib4/Mathlib/Analysis/Normed/Algebra/Unitization.lean b/mathlib4/Mathlib/Analysis/Normed/Algebra/Unitization.lean
index 904ae7859..e10f2ca4f 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Algebra/Unitization.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Algebra/Unitization.lean
@@ -238,6 +238,7 @@ noncomputable instance instNormedRing : NormedRing (Unitization 𝕜 A) where
   norm_mul_le := normedRingAux.norm_mul_le
   norm := normedRingAux.norm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Pull back the normed algebra structure from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A` using the
 algebra homomorphism `Unitization.splitMul 𝕜 A`. -/
 instance instNormedAlgebra : NormedAlgebra 𝕜 (Unitization 𝕜 A) where
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/Bases.lean b/mathlib4/Mathlib/Analysis/Normed/Module/Bases.lean
index 7beeedeb5..9f5bdbf1b 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/Bases.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/Bases.lean
@@ -181,6 +181,7 @@ theorem range_proj_eq_span (A : Finset β) :
     use b i
     rw [ContinuousLinearMap.coe_coe, proj_apply_basis_mem, ite_eq_left (Finset.mem_coe.mp hi)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open scoped Classical in
 /-- Composition of projections: `proj A (proj B x) = proj (A ∩ B) x`. -/
@@ -475,6 +476,7 @@ lemma basisCoeff_spec (n : ℕ) (x : X) :
     basisCoeff D n x • D.e n = (succSub D.P n) x :=
   Classical.choose_spec (exists_coeff D n x)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Constructs a Schauder basis from rank one decomposition. -/
 def basis : SchauderBasis 𝕜 X :=
   let coeff := basisCoeff D
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/Basic.lean b/mathlib4/Mathlib/Analysis/Normed/Module/Basic.lean
index 0511218ab..1c01999f9 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/Basic.lean
@@ -179,6 +179,7 @@ instance (priority := 75) SubmoduleClass.toNormedSpace : NormedSpace 𝕜 s wher
 
 end SeminormedAddCommGroup
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear map from a `Module` to a `NormedSpace` induces a `NormedSpace` structure on the
 domain, using the `SeminormedAddCommGroup.induced` norm.
 
@@ -383,6 +384,7 @@ instance MulOpposite.instNormedAlgebra {E : Type*} [SeminormedRing E] [NormedAlg
 
 end NormedAlgebra
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A non-unital algebra homomorphism from an `Algebra` to a `NormedAlgebra` induces a
 `NormedAlgebra` structure on the domain, using the `SeminormedRing.induced` norm.
 
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/FiniteDimension.lean b/mathlib4/Mathlib/Analysis/Normed/Module/FiniteDimension.lean
index ac6832a0b..695101b57 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/FiniteDimension.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/FiniteDimension.lean
@@ -363,6 +363,7 @@ alias isOpen_setOf_affineIndependent := isOpen_setOfPred_affineIndependent
 
 namespace Module.Basis
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem opNNNorm_le {ι : Type*} [Fintype ι] (v : Basis ι 𝕜 E) {u : E →L[𝕜] F} (M : ℝ≥0)
     (hu : ∀ i, ‖u (v i)‖₊ ≤ M) : ‖u‖₊ ≤ Fintype.card ι • ‖v.equivFunL.toContinuousLinearMap‖₊ * M :=
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean b/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean
index c0e45f198..6e4e7e6d2 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean
@@ -101,6 +101,7 @@ theorem injectiveSeminorm_apply (x : ⨂[𝕜] i, E i) :
   simpa only [injectiveSeminorm, Set.coe_ofPred, Set.mem_ofPred_eq]
     using Seminorm.sSup_apply dualSeminorms_bounded
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 attribute [-instance] instSeminormedAddCommGroup in
 @[deprecated
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/ProjectiveSeminorm.lean b/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/ProjectiveSeminorm.lean
index 4e81a007e..b09dd22dd 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/ProjectiveSeminorm.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/ProjectiveSeminorm.lean
@@ -160,6 +160,7 @@ variable {F : Type*} [SeminormedAddCommGroup F] [NormedSpace 𝕜 F]
 
 variable (𝕜 E F)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The linear equivalence between `ContinuousMultilinearMap 𝕜 E F` and `(⨂[𝕜] i, Eᵢ) →L[𝕜] F`
 induced by `PiTensorProduct.lift`, for every normed space `F`.
 -/
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/RCLike/Basic.lean b/mathlib4/Mathlib/Analysis/Normed/Module/RCLike/Basic.lean
index 795450081..489633581 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/RCLike/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/RCLike/Basic.lean
@@ -59,6 +59,7 @@ theorem ContinuousLinearEquiv.coord_norm' {x : E} (h : x ≠ 0) :
 
 @[deprecated (since := "2026-02-01")] alias coord_norm' := ContinuousLinearEquiv.coord_norm'
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem LinearMap.bound_of_sphere_bound {r : ℝ} (r_pos : 0 < r) (c : ℝ) (f : E →ₗ[𝕜] 𝕜)
     (h : ∀ z ∈ sphere (0 : E) r, ‖f z‖ ≤ c) (z : E) : ‖f z‖ ≤ c / r * ‖z‖ := by
   by_cases z_zero : z = 0
diff --git a/mathlib4/Mathlib/Analysis/Normed/Operator/Compact/FredholmAlternative.lean b/mathlib4/Mathlib/Analysis/Normed/Operator/Compact/FredholmAlternative.lean
index 690de19e3..7f18b3f4f 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Operator/Compact/FredholmAlternative.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Operator/Compact/FredholmAlternative.lean
@@ -45,6 +45,7 @@ variable {T : X →L[𝕜] X} {μ : 𝕜}
 
 open Module End
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open Filter Topology in
 /-- If `T : X →L[𝕜] X` is a compact operator on a Banach space `X`, and `μ ≠ 0` is not an
 eigenvalue of `T`, then `T - μ • 1` is antilipschitz with positive constant.
diff --git a/mathlib4/Mathlib/Analysis/Normed/Operator/Extend.lean b/mathlib4/Mathlib/Analysis/Normed/Operator/Extend.lean
index 993ea9b00..7d9f8ba3e 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Operator/Extend.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Operator/Extend.lean
@@ -52,6 +52,7 @@ variable [AddCommGroup E] [UniformSpace E] [IsUniformAddGroup E]
   [ContinuousConstSMul 𝕜 Eₗ] [ContinuousConstSMul 𝕜₂ F]
   {σ₁₂ : 𝕜 →+* 𝕜₂} (f g : E →SL[σ₁₂] F) [CompleteSpace F] (e : E →L[𝕜] Eₗ)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped Classical in
 /-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
 complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Eₗ`. -/
diff --git a/mathlib4/Mathlib/Analysis/Normed/Unbundled/FiniteExtension.lean b/mathlib4/Mathlib/Analysis/Normed/Unbundled/FiniteExtension.lean
index 34ff6715a..565c0ec6a 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Unbundled/FiniteExtension.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Unbundled/FiniteExtension.lean
@@ -97,6 +97,7 @@ theorem norm_isNonarchimedean (hna : IsNonarchimedean (Norm.norm : K → ℝ)) :
   · exact le_max_of_le_left (le_trans hx (norm_repr_le_norm B ixy))
   · exact le_max_of_le_right (le_trans hy (norm_repr_le_norm B ixy))
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- For any `K`-basis of `L`, `B.norm` is bounded with respect to multiplication. That is,
   `∃ (c : ℝ), c > 0` such that ` ∀ (x y : L), B.norm (x * y) ≤ c * B.norm x * B.norm y`. -/
diff --git a/mathlib4/Mathlib/Analysis/Normed/Unbundled/InvariantExtension.lean b/mathlib4/Mathlib/Analysis/Normed/Unbundled/InvariantExtension.lean
index 5913651c6..51b9b47b6 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Unbundled/InvariantExtension.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Unbundled/InvariantExtension.lean
@@ -52,6 +52,7 @@ namespace IsUltrametricDist
 section algNormOfAlgEquiv
 
 set_option linter.style.whitespace false in -- manual alignment is not recognised
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a normed field `K`, a finite algebraic extension `L/K` and `σ : L ≃ₐ[K] L`, the function
 `L → ℝ` sending `x : L` to `‖ σ x ‖`, where `‖ ⬝ ‖` is any power-multiplicative algebra norm on `L`
 extending the norm on `K`, is an algebra norm on `K`. -/
@@ -66,11 +67,13 @@ def algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
   smul' x y   := by simp [map_smul σ, map_smul_eq_mul]
   eq_zero_of_map_eq_zero' x hx := EmbeddingLike.map_eq_zero_iff.mp (eq_zero_of_map_eq_zero _ hx)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem algNormOfAlgEquiv_apply (σ : L ≃ₐ[K] L) (x : L) :
     algNormOfAlgEquiv σ x =
       Classical.choose (exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional h_fin
         hu.isNonarchimedean_norm) (σ x) := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The algebra norm `algNormOfAlgEquiv` is power-multiplicative. -/
 theorem isPowMul_algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
     IsPowMul (algNormOfAlgEquiv σ) := by
@@ -79,6 +82,7 @@ theorem isPowMul_algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
   exact (Classical.choose_spec (exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional
     h_fin hu.isNonarchimedean_norm)).1 _ hn
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The algebra norm `algNormOfAlgEquiv` is nonarchimedean. -/
 theorem isNonarchimedean_algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
     IsNonarchimedean (algNormOfAlgEquiv σ) := by
@@ -87,6 +91,7 @@ theorem isNonarchimedean_algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
   exact (Classical.choose_spec (exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional
     h_fin hu.isNonarchimedean_norm)).2.2 _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The algebra norm `algNormOfAlgEquiv` extends the norm on `K`. -/
 theorem algNormOfAlgEquiv_extends (σ : L ≃ₐ[K] L) (x : K) :
     (algNormOfAlgEquiv σ) ((algebraMap K L) x) = ‖x‖ := by
diff --git a/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean b/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
index bbe74f3ee..214b4416c 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
@@ -696,6 +696,7 @@ variable {K : Type u} [NontriviallyNormedField K] {L : Type v} [Field L] [Algebr
 private def myId {α : Sort u} (a : α) : α :=
   a
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `K` is a field complete with respect to a nontrivial nonarchimedean multiplicative norm and
   `L/K` is an algebraic extension, then any power-multiplicative `K`-algebra norm on `L` coincides
   with the spectral norm. -/
diff --git a/mathlib4/Mathlib/Analysis/RCLike/Basic.lean b/mathlib4/Mathlib/Analysis/RCLike/Basic.lean
index 6dfc89e90..b1124a64b 100644
--- a/mathlib4/Mathlib/Analysis/RCLike/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/RCLike/Basic.lean
@@ -1378,6 +1378,7 @@ theorem symm_smul_apply (e : V ≃ₗᵢ[𝕜] W) (α : unitary 𝕜) (x : W) :
 @[simp] theorem toContinuousLinearEquiv_smul (e : G ≃ₗᵢ[𝕜] W) (α : unitary 𝕜) :
     (α • e).toContinuousLinearEquiv = Unitary.toUnits α • e.toContinuousLinearEquiv := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem smul_trans (α : unitary 𝕜) (e : V ≃ₗᵢ[𝕜] G) (f : G ≃ₗᵢ[𝕜] W) :
     (α • e).trans f = α • (e.trans f) := by ext; simp
diff --git a/mathlib4/Mathlib/Analysis/RCLike/Extend.lean b/mathlib4/Mathlib/Analysis/RCLike/Extend.lean
index f1edf6850..f48b7ef8e 100644
--- a/mathlib4/Mathlib/Analysis/RCLike/Extend.lean
+++ b/mathlib4/Mathlib/Analysis/RCLike/Extend.lean
@@ -77,6 +77,7 @@ lemma im_extendRCLike_apply (g : Dual ℝ F) (x : F) :
   obtain (h | h) := RCLike.I_eq_zero_or_im_I_eq_one (K := 𝕜)
   all_goals simp [h, extendRCLike_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem norm_extendRCLike_apply_sq (fr : Dual ℝ F) (x : F) :
     ‖(fr.extendRCLike x : 𝕜)‖ ^ 2 = fr (conj (fr.extendRCLike x : 𝕜) • x) := calc
   ‖(fr.extendRCLike x : 𝕜)‖ ^ 2 = re (conj (fr.extendRCLike x) * fr.extendRCLike x : 𝕜) := by
diff --git a/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean b/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean
index 5f22186bb..d33f8a3a1 100644
--- a/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean
@@ -203,6 +203,9 @@ lemma top_mem_range (A₀ : Subobject X) {J : Type w} [LinearOrder J] [OrderBot
   top_mem_range_transfiniteIterate (largerSubobject hG) A₀ (lt_largerSubobject hG) (by simp)
     (fun h ↦ by simpa [hasCardinalLT_iff_cardinal_mk_lt] using hJ.of_injective _ h)
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma exists_ordinal (A₀ : Subobject X) :
     ∃ (o : Ordinal.{w}) (j : o.ToType), transfiniteIterate (largerSubobject hG) j A₀ = ⊤ := by
   let κ := Order.succ (Cardinal.mk (Shrink.{w} (Subobject X)))
diff --git a/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/GabrielPopescu.lean b/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/GabrielPopescu.lean
index d9634c52c..f66dc3eab 100644
--- a/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/GabrielPopescu.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/GabrielPopescu.lean
@@ -73,6 +73,7 @@ theorem ι_d {G A : C} {M : ModuleCat (End G)ᵐᵒᵖ} (g : M ⟶ ModuleCat.of
     Sigma.ι _ m ≫ d g = g.hom m := by
   simp [d]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
 attribute [local instance] IsFiltered.isConnected in
diff --git a/mathlib4/Mathlib/CategoryTheory/Abelian/Pseudoelements.lean b/mathlib4/Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
index 716f26610..b9bd2f04d 100644
--- a/mathlib4/Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
@@ -205,6 +205,7 @@ section
 
 attribute [local instance] HasBinaryBiproducts.of_hasBinaryProducts
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The arrows pseudo-equal to a zero morphism are precisely the zero morphisms. -/
 theorem pseudoZero_aux {P : C} (Q : C) (f : Over P) : f ≈ (0 : Q ⟶ P) ↔ f.hom = 0 :=
diff --git a/mathlib4/Mathlib/CategoryTheory/Filtered/CostructuredArrow.lean b/mathlib4/Mathlib/CategoryTheory/Filtered/CostructuredArrow.lean
index b4d3226a7..b18ab8934 100644
--- a/mathlib4/Mathlib/CategoryTheory/Filtered/CostructuredArrow.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Filtered/CostructuredArrow.lean
@@ -34,8 +34,36 @@ section Small
 variable {A : Type u₁} [SmallCategory A] {B : Type u₁} [SmallCategory B]
 variable {T : Type u₁} [SmallCategory T]
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`HasColimitsOfShape (CostructuredArrow L (R.obj b)) (Type u₁)`
+It is needed by `filtered_colim_preservesFiniteLimits` in the `haveI` below. The `simp only`
+preceding it rewrites the shape of `colim` to `CostructuredArrow L (R.obj b)` via
+`Cat.of_α`, but leaves that `colim`'s `Category` instance typed at the old spelling
+`↑(Cat.of (CostructuredArrow L (R.obj b)))`, and the synthesis has to reproduce that mismatch.
+
+The failure happens while applying `@Types.hasColimitsOfShape`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type is
+`Category (CostructuredArrow L (R.obj b))`, whereas the assigned value
+`(Cat.of (CostructuredArrow L (R.obj b))).str` has type
+`Category ↑(Cat.of (CostructuredArrow L (R.obj b)))`. The comparison bottoms out at
+`CostructuredArrow L (R.obj b) =?= (Cat.of (CostructuredArrow L (R.obj b))).1`, where `Cat.of` is a
+plain semireducible `def` and therefore does not unfold at the `.instances` transparency that
+instance search runs at. Lean falls back to synthesize an instance of the correct type, which
+succeeds, but it returns `instCategoryCostructuredArrow_1 L (R.obj b)`, which is again not defeq to
+the assigned value: that comparison bottoms out at the same `Cat.of` boundary, and it too runs at
+`.instances`, since `respectTransparency false` suppresses the transparency bump that
+instance-implicit arguments would otherwise receive.
+
+Potential fix: Mark `Cat.of` and `Bundled.of` implicit-reducible and then remove
+`instanceTypes false` and `respectTransparency false`.
+-/
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
+set_option backward.isDefEq.instanceTypes false in
 private lemma isFiltered_of_isFiltered_costructuredArrow_small (L : A ⥤ T) (R : B ⥤ T)
     [IsFiltered B] [Final R] [∀ b, IsFiltered (CostructuredArrow L (R.obj b))] : IsFiltered A := by
   refine isFiltered_of_nonempty_limit_colimit_to_colimit_limit fun J {_ _} F => ⟨?_⟩
diff --git a/mathlib4/Mathlib/CategoryTheory/GradedObject/Monoidal.lean b/mathlib4/Mathlib/CategoryTheory/GradedObject/Monoidal.lean
index 738eb3784..33186089d 100644
--- a/mathlib4/Mathlib/CategoryTheory/GradedObject/Monoidal.lean
+++ b/mathlib4/Mathlib/CategoryTheory/GradedObject/Monoidal.lean
@@ -558,6 +558,8 @@ variable [DecidableEq I] [HasInitial C]
   [HasTensor (tensorObj X₁ tensorUnit) X₃] [HasTensor X₁ (tensorObj tensorUnit X₃)]
   [HasGoodTensor₁₂Tensor X₁ tensorUnit X₃] [HasGoodTensorTensor₂₃ X₁ tensorUnit X₃]
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 lemma triangle :
     (associator X₁ tensorUnit X₃).hom ≫ tensorHom (𝟙 X₁) (leftUnitor X₃).hom =
diff --git a/mathlib4/Mathlib/CategoryTheory/Limits/ConcreteCategory/WithAlgebraicStructures.lean b/mathlib4/Mathlib/CategoryTheory/Limits/ConcreteCategory/WithAlgebraicStructures.lean
index 44836198e..45f8e347f 100644
--- a/mathlib4/Mathlib/CategoryTheory/Limits/ConcreteCategory/WithAlgebraicStructures.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Limits/ConcreteCategory/WithAlgebraicStructures.lean
@@ -57,6 +57,7 @@ end zero
 
 section module
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 If `r` has no zero smul divisors for all small-enough sections, then `r` has no zero smul divisors
 in the colimit.
diff --git a/mathlib4/Mathlib/CategoryTheory/Monoidal/Bimod.lean b/mathlib4/Mathlib/CategoryTheory/Monoidal/Bimod.lean
index f97cef76e..a07d98aba 100644
--- a/mathlib4/Mathlib/CategoryTheory/Monoidal/Bimod.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Monoidal/Bimod.lean
@@ -622,6 +622,8 @@ set_option backward.defeqAttrib.useBackward true in
 noncomputable def hom : TensorBimod.X (regular R) P ⟶ P.X :=
   coequalizer.desc P.actLeft (by dsimp; rw [Category.assoc, left_assoc])
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The underlying morphism of the inverse component of the left unitor isomorphism. -/
 noncomputable def inv : P.X ⟶ TensorBimod.X (regular R) P :=
   (λ_ P.X).inv ≫ (η[R.X] ▷ _) ≫ coequalizer.π _ _
@@ -685,6 +687,8 @@ set_option backward.defeqAttrib.useBackward true in
 noncomputable def hom : TensorBimod.X P (regular S) ⟶ P.X :=
   coequalizer.desc P.actRight (by dsimp; rw [Category.assoc, right_assoc, Iso.hom_inv_id_assoc])
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The underlying morphism of the inverse component of the right unitor isomorphism. -/
 noncomputable def inv : P.X ⟶ TensorBimod.X P (regular S) :=
   (ρ_ P.X).inv ≫ (_ ◁ η[S.X]) ≫ coequalizer.π _ _
diff --git a/mathlib4/Mathlib/CategoryTheory/Sites/LocalSite.lean b/mathlib4/Mathlib/CategoryTheory/Sites/LocalSite.lean
index 426891151..b545204e8 100644
--- a/mathlib4/Mathlib/CategoryTheory/Sites/LocalSite.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Sites/LocalSite.lean
@@ -160,6 +160,7 @@ instance (A : Type u') [Category.{v'} A] [HasColimitsOfSize.{v, v} A]
 instance : (coconstantSheaf.{w} J A).IsRightAdjoint :=
   ⟨Γ J A, ⟨ΓCoconstantSheafAdj J A⟩⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
 set_option backward.defeqAttrib.useBackward true in
 /-- The global sections of the coconstant sheaf on a type are naturally isomorphic to that type. -/
 noncomputable def coconstantSheafΓNatIsoId :
diff --git a/mathlib4/Mathlib/CategoryTheory/SmallObject/IsCardinalForSmallObjectArgument.lean b/mathlib4/Mathlib/CategoryTheory/SmallObject/IsCardinalForSmallObjectArgument.lean
index 97112b1dc..e8c87a468 100644
--- a/mathlib4/Mathlib/CategoryTheory/SmallObject/IsCardinalForSmallObjectArgument.lean
+++ b/mathlib4/Mathlib/CategoryTheory/SmallObject/IsCardinalForSmallObjectArgument.lean
@@ -155,6 +155,30 @@ isomorphisms on the right side. -/
 def propArrow : MorphismProperty (Arrow C) := fun _ _ f ↦
   (coproducts.{w} I).pushouts f.left ∧ (isomorphisms C) f.right
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`Category.{max u v, max u v} (Comma (𝟭 C) (𝟭 C) ⥤ Comma (𝟭 C) (𝟭 C))`
+It is needed by the `⟨F⟩` pattern in the opening `intro`, which re-elaborates `ofHoms.mk F` against
+a goal where the carrier `Arrow C ⥤ Arrow C` is exposed at its `Comma (𝟭 C) (𝟭 C)` spelling.
+
+The failure happens while applying `@Functor.category`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `Category (Comma (𝟭 C) (𝟭 C))`, whereas the assigned value `instCategoryArrow` has type
+`Category (Arrow C)`. The comparison bottoms out at `Comma (𝟭 C) (𝟭 C) =?= Arrow C`, where `Arrow`
+is a plain semireducible `def` and therefore does not unfold at the `.instances` transparency that
+instance search runs at. Lean falls back to synthesize an instance of the correct type, but it
+returns `commaCategory`, which is again not defeq to `instCategoryArrow`: that comparison runs at
+`.implicit`, and `Arrow` does not unfold there either.
+
+With the metavariable unsolved, the `intro` argument `⟨F⟩` has type `ofHoms ?m.69 (?m.69 F)`,
+which fails to unify with `(succStruct I κ).prop f✝`.
+
+Potential fix: mark `Arrow` and `Arrow.Hom` implicit-reducible, then remove `instanceTypes false`.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
 lemma succStruct_prop_le_propArrow :
diff --git a/mathlib4/Mathlib/CategoryTheory/Subobject/Lattice.lean b/mathlib4/Mathlib/CategoryTheory/Subobject/Lattice.lean
index f89923ac3..fa8cda914 100644
--- a/mathlib4/Mathlib/CategoryTheory/Subobject/Lattice.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Subobject/Lattice.lean
@@ -66,6 +66,8 @@ def pullbackTop (f : X ⟶ Y) : (pullback f).obj ⊤ ≅ ⊤ :=
   iso_of_both_ways (leTop _)
     (homMk (pullback.lift f (𝟙 _) (by simp)) (pullback.lift_snd _ _ _))
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- There is a morphism from `⊤ : MonoOver A` to the pullback of a monomorphism along itself;
 as the category is thin this is an isomorphism. -/
 def topLEPullbackSelf {A B : C} (f : A ⟶ B) [Mono f] :
diff --git a/mathlib4/Mathlib/Combinatorics/Enumerative/Partition/GenFun.lean b/mathlib4/Mathlib/Combinatorics/Enumerative/Partition/GenFun.lean
index 1e6c4ad84..291a9de94 100644
--- a/mathlib4/Mathlib/Combinatorics/Enumerative/Partition/GenFun.lean
+++ b/mathlib4/Mathlib/Combinatorics/Enumerative/Partition/GenFun.lean
@@ -90,6 +90,7 @@ theorem summable_genFun_term' (f : ℕ → ℕ → R) {i : ℕ} (hi : i ≠ 0) :
 
 variable [T2Space R]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private theorem aux_dvd_of_coeff_ne_zero {f : ℕ → ℕ → R} {d : ℕ} {s : Finset ℕ} (hs0 : 0 ∉ s)
     {g : ℕ →₀ ℕ} (hg : g ∈ s.finsuppAntidiag d)
     (hprod : ∀ i ∈ s, (coeff (g i)) (1 + ∑' j, f i (j + 1) • X ^ (i * (j + 1))) ≠ (0 : R)) (x : ℕ) :
diff --git a/mathlib4/Mathlib/Combinatorics/SimpleGraph/Coloring/Vertex.lean b/mathlib4/Mathlib/Combinatorics/SimpleGraph/Coloring/Vertex.lean
index 8116036b0..d41a51701 100644
--- a/mathlib4/Mathlib/Combinatorics/SimpleGraph/Coloring/Vertex.lean
+++ b/mathlib4/Mathlib/Combinatorics/SimpleGraph/Coloring/Vertex.lean
@@ -112,6 +112,8 @@ theorem Coloring.mem_colorClasses {v : V} : C.colorClass (C v) ∈ C.colorClasse
 theorem Coloring.colorClasses_finite [Finite α] : C.colorClasses.Finite :=
   Setoid.finite_classes_ker _
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Coloring.card_colorClasses_le [Fintype α] [Fintype C.colorClasses] :
     Fintype.card C.colorClasses ≤ Fintype.card α := by
   simp only [colorClasses]
diff --git a/mathlib4/Mathlib/Condensed/TopCatAdjunction.lean b/mathlib4/Mathlib/Condensed/TopCatAdjunction.lean
index e5935ba38..3097c176b 100644
--- a/mathlib4/Mathlib/Condensed/TopCatAdjunction.lean
+++ b/mathlib4/Mathlib/Condensed/TopCatAdjunction.lean
@@ -91,7 +91,40 @@ noncomputable def topCatAdjunctionCounit (X : TopCat.{u + 1}) : X.toCondensedSet
       rw [continuous_coinduced_dom]
       continuity }
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`DFunLike C(C(PUnit, ↑X), ↑X) ?m ?m`
+It is needed by the `DFunLike.coe` below, whose `F` annotation leaves the topology on `C(PUnit, X)`
+to be determined by unification.
+
+The failure happens while applying `@ContinuousMap.instFunLike`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `TopologicalSpace C(PUnit, ↑X)`, whereas the assigned value `X.toCondensedSet.toTopCat.str` has
+type `TopologicalSpace ↑X.toCondensedSet.toTopCat`. The two carrier spellings are defeq at
+`.default`, but seeing that requires unfolding the whole `toCondensedSet`/`toTopCat` chain down to
+`ContinuousMap =?= X.toCondensedSet.obj.1`, which does not happen at `.instances`. Lean falls back
+to synthesize an instance of the correct type, which succeeds, but it returns
+`ContinuousMap.compactOpen`, which is a genuinely different topology from the coinduced one carried
+by `X.toCondensedSet.toTopCat.str`, so it is not defeq to the assigned value at any transparency
+(see the `apply_rfl` example below). Hence the fallback cannot repair this case, and only the direct
+check could: that would need the carrier chain to unfold at `.instances`.
+
+With the metavariable unsolved, `DFunLike` synthesis fails and `x` is no longer known to be a
+function.
+
+Potential fix: Unclear. With an explicit type on the `x : C(PUnit, X)` parameter, the explicit
+`F` argument is no longer needed to make the lemma elaborate. However, that would change the
+lemma's statement and also its discrimination key. A last resort is to explicitly supply the
+desired instance. Alternatively, one could investigate whether `ContinuousMap.compactOpen` and
+`X.toCondensedSet.toTopCat.str` can be made defeq at implicit transparency, but this should be done
+with care: If many declarations need to be made implicit-reducible, it might degrade performance
+in other places.
+-/
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.instanceTypes false in
 /-- `simp`-normal form of the lemma that `@[simps]` would generate. -/
 @[simp] lemma topCatAdjunctionCounit_hom_apply (X : TopCat) (x) :
     -- We have to specify here to not infer the `TopologicalSpace` instance on `C(PUnit, X)`,
diff --git a/mathlib4/Mathlib/FieldTheory/Fixed.lean b/mathlib4/Mathlib/FieldTheory/Fixed.lean
index 34cbc7826..175dc3b51 100644
--- a/mathlib4/Mathlib/FieldTheory/Fixed.lean
+++ b/mathlib4/Mathlib/FieldTheory/Fixed.lean
@@ -207,6 +207,7 @@ theorem ne_one : minpoly G F x ≠ (1 : Polynomial (FixedPoints.subfield G F)) :
   have := eval₂ G F x
   (one_ne_zero : (1 : F) ≠ 0) <| by rwa [H, Polynomial.eval₂_one] at this
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 theorem of_eval₂ (f : Polynomial (FixedPoints.subfield G F))
     (hf : Polynomial.eval₂ (Subfield.subtype <| FixedPoints.subfield G F) x f = 0) :
diff --git a/mathlib4/Mathlib/FieldTheory/KummerExtension.lean b/mathlib4/Mathlib/FieldTheory/KummerExtension.lean
index d4dad3dc7..ee68b53e3 100644
--- a/mathlib4/Mathlib/FieldTheory/KummerExtension.lean
+++ b/mathlib4/Mathlib/FieldTheory/KummerExtension.lean
@@ -195,6 +195,7 @@ theorem Polynomial.separable_X_pow_sub_C_of_irreducible : (X ^ n - C a).Separabl
 
 variable (n)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The natural embedding of the roots of unity of `K` into `Gal(K[ⁿ√a]/K)`, by sending
 `η ↦ (ⁿ√a ↦ η • ⁿ√a)`. Also see `autAdjoinRootXPowSubC` for the `AlgEquiv` version. -/
 noncomputable
@@ -392,6 +393,7 @@ def autEquivRootsOfUnity [NeZero n] :
   (AlgEquiv.autCongr (adjoinRootXPowSubCEquiv hζ H (rootOfSplitsXPowSubC_pow a L)).symm).trans
     (autAdjoinRootXPowSubCEquiv hζ H).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma autEquivRootsOfUnity_apply_rootOfSplit [NeZero n] (σ : Gal(L/K)) :
     σ (rootOfSplitsXPowSubC (NeZero.pos n) a L) =
       autEquivRootsOfUnity hζ H L σ • (rootOfSplitsXPowSubC (NeZero.pos n) a L) := by
@@ -403,6 +405,7 @@ lemma autEquivRootsOfUnity_apply_rootOfSplit [NeZero n] (σ : Gal(L/K)) :
     adjoinRootXPowSubCEquiv_root]
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hα in
 lemma autEquivRootsOfUnity_smul [NeZero n] (σ : Gal(L/K)) :
     autEquivRootsOfUnity hζ H L σ • α = σ α := by
diff --git a/mathlib4/Mathlib/FieldTheory/NormalizedTrace.lean b/mathlib4/Mathlib/FieldTheory/NormalizedTrace.lean
index 9947816d3..f540ecaff 100644
--- a/mathlib4/Mathlib/FieldTheory/NormalizedTrace.lean
+++ b/mathlib4/Mathlib/FieldTheory/NormalizedTrace.lean
@@ -75,6 +75,7 @@ private theorem normalizedTraceAux_eq_of_finiteDimensional [FiniteDimensional F
 
 variable [Algebra.IsIntegral F K]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.privateInPublic true in
 set_option backward.privateInPublic.warn false in
 /-- The normalized trace map from an algebraic extension `K` to the base field `F`. -/
@@ -180,6 +181,7 @@ theorem normalizedTrace_algebraMap_of_lifts [CharZero E] [Algebra.IsIntegral E K
   simp [normalizedTrace_minpoly F a, normalizedTrace_minpoly E a, ← minpoly.map_algebraMap ha h,
     (minpoly F a).nextCoeff_map_eq, map_mul, map_neg]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /- An auxiliary result to prove `normalizedTrace_trans_apply`. It differs from
 `normalizedTrace_trans_apply` only by the extra assumption about finiteness of `E` over `F`. -/
diff --git a/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean b/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
index 63bae2d34..2b3644ec4 100644
--- a/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
+++ b/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
@@ -135,6 +135,7 @@ theorem isAlgebraic_of_mem_vars_of_forall_totalDegree_le (hFa : F.aeval a = 0) (
       (Finsupp.mem_support_iff.mp hσi) ?_, aeval_toPolynomialAdjoinImageCompl_eq_zero hFa ..⟩
   rw [h, Polynomial.coeff_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 include hp H in
diff --git a/mathlib4/Mathlib/Geometry/Convex/Cone/Dual.lean b/mathlib4/Mathlib/Geometry/Convex/Cone/Dual.lean
index c1597d600..8180a305e 100644
--- a/mathlib4/Mathlib/Geometry/Convex/Cone/Dual.lean
+++ b/mathlib4/Mathlib/Geometry/Convex/Cone/Dual.lean
@@ -44,6 +44,7 @@ variable {p : M →ₗ[R] N →ₗ[R] R} {s t : Set M} {y : N}
 
 local notation3 "R≥0" => {c : R // 0 ≤ c}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (p) in
 /-- The dual cone of a set `s` with respect to a bilinear pairing `p` is the cone consisting of all
 points `y` such that for all points `x ∈ s` we have `0 ≤ p x y`. -/
diff --git a/mathlib4/Mathlib/Geometry/Convex/Cone/Face/Basic.lean b/mathlib4/Mathlib/Geometry/Convex/Cone/Face/Basic.lean
index 922db36ac..3a6fb06bb 100644
--- a/mathlib4/Mathlib/Geometry/Convex/Cone/Face/Basic.lean
+++ b/mathlib4/Mathlib/Geometry/Convex/Cone/Face/Basic.lean
@@ -150,6 +150,7 @@ section Map
 
 variable [AddCommGroup N] [Module R N]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The image of a face of a cone under an injective linear map is a face of the
 image of the cone. -/
 protected theorem map (f : M →ₗ[R] N) (hf : Function.Injective f) (hF : F.IsFaceOf C) :
@@ -176,6 +177,7 @@ theorem of_map_injective {f : M →ₗ[R] N} (hf : Function.Injective f)
     convert hx'
     exact hf hhx'.symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The comap of a face of a cone under a linear map is a face of the comap of the cone. -/
 protected theorem comap (f : N →ₗ[R] M) (hF : F.IsFaceOf C) : (F.comap f).IsFaceOf (C.comap f) := by
   refine ⟨comap_mono hF.le, ?_⟩
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
index 08b8c02e2..1f18edf3d 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
@@ -467,6 +467,7 @@ theorem oangle_add_right_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ
       LinearIsometryEquiv.norm_map, mul_div_assoc, div_self (norm_ne_zero_iff.2 h), mul_one,
       Real.norm_eq_abs, abs_of_pos hr]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An angle in a right-angled triangle expressed using `arctan`, where one side is a multiple
 of a rotation of another by `π / 2`. -/
 theorem oangle_add_left_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ) :
@@ -493,6 +494,7 @@ theorem tan_oangle_add_left_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r :
       r⁻¹ := by
   rw [o.oangle_add_left_smul_rotation_pi_div_two h, Real.Angle.tan_coe, Real.tan_arctan]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An angle in a right-angled triangle expressed using `arctan`, where one side is a multiple
 of a rotation of another by `π / 2`, version subtracting vectors. -/
 theorem oangle_sub_right_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ) :
@@ -504,6 +506,7 @@ theorem oangle_sub_right_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ
   rw [sub_eq_add_neg, hx, o.oangle_add_right_smul_rotation_pi_div_two]
   simpa [hr] using h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An angle in a right-angled triangle expressed using `arctan`, where one side is a multiple
 of a rotation of another by `π / 2`, version subtracting vectors. -/
 theorem oangle_sub_left_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ) :
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
index 495f17778..7b31e3d1e 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
@@ -58,6 +58,7 @@ theorem rotationAux_apply (θ : Real.Angle) (x : V) :
     o.rotationAux θ x = Real.Angle.cos θ • x + Real.Angle.sin θ • J x :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A rotation by the oriented angle `θ`. -/
 def rotation (θ : Real.Angle) : V ≃ₗᵢ[ℝ] V :=
   LinearIsometryEquiv.ofLinearIsometry (o.rotationAux θ)
@@ -140,6 +141,7 @@ theorem rotation_pi_div_two : o.rotation (π / 2 : ℝ) = J := by
   ext x
   simp [rotation]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Rotating twice is equivalent to rotating by the sum of the angles. -/
 @[simp]
 theorem rotation_rotation (θ₁ θ₂ : Real.Angle) (x : V) :
@@ -275,6 +277,7 @@ theorem rotation_oangle_eq_iff_norm_eq (x y : V) : o.rotation (o.oangle x y) x =
   · intro h
     rw [o.eq_iff_oangle_eq_zero_of_norm_eq] <;> simp [h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The angle between two nonzero vectors is `θ` if and only if the second vector is the first
 rotated by `θ` and scaled by the ratio of the norms. -/
 theorem oangle_eq_iff_eq_norm_div_norm_smul_rotation_of_ne_zero {x y : V} (hx : x ≠ 0) (hy : y ≠ 0)
@@ -344,6 +347,7 @@ theorem exists_linearIsometryEquiv_eq_of_det_pos {f : V ≃ₗᵢ[ℝ] V}
       o.kahler_comp_rightAngleRotation]
   simp [← this]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem rotation_map (θ : Real.Angle) (f : V ≃ₗᵢ[ℝ] V') (x : V') :
     (Orientation.map (Fin 2) f.toLinearEquiv o).rotation θ x = f (o.rotation θ (f.symm x)) := by
   simp [rotation_apply, o.rightAngleRotation_map]
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Sphere.lean b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Sphere.lean
index 82667ad14..7858310cf 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Sphere.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Sphere.lean
@@ -259,6 +259,7 @@ theorem abs_oangle_center_right_toReal_lt_pi_div_two {s : Sphere P} {p₁ p₂ :
   abs_oangle_left_toReal_lt_pi_div_two_of_dist_eq
     (dist_center_eq_dist_center_of_mem_sphere' hp₂ hp₁)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given two points on a circle, the center of that circle may be expressed explicitly as a
 multiple (by half the tangent of the angle between the chord and the radius at one of those
 points) of a `π / 2` rotation of the vector between those points, plus the midpoint of those
@@ -288,6 +289,7 @@ theorem inv_tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_center {s : Sp
   rw [add_comm,
     two_zsmul_oangle_center_add_two_zsmul_oangle_eq_pi hp₁ hp₂ hp₃ hp₁p₂.symm hp₂p₃ hp₁p₃]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given two points on a circle, the radius of that circle may be expressed explicitly as half
 the distance between those two points divided by the cosine of the angle between the chord and
 the radius at one of those points. -/
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/MongePoint.lean b/mathlib4/Mathlib/Geometry/Euclidean/MongePoint.lean
index 623a8dfd6..8205e4126 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/MongePoint.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/MongePoint.lean
@@ -93,6 +93,7 @@ theorem mongePoint_eq_smul_vsub_vadd_circumcenter {n : ℕ} (s : Simplex ℝ P n
   congr 3
   convert! Finset.univ.affineCombination_map e.toEmbedding _ _ <;> simp [Function.comp_assoc]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem mongePoint_map {V₂ P₂ : Type*} [NormedAddCommGroup V₂] [InnerProductSpace ℝ V₂]
@@ -154,6 +155,7 @@ theorem sum_mongePointWeightsWithCircumcenter (n : ℕ) :
   simp [field]
   ring
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The Monge point of an (n+2)-simplex, in terms of
 `pointsWithCircumcenter`. -/
 theorem mongePoint_eq_affineCombination_of_pointsWithCircumcenter {n : ℕ}
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/NinePointCircle.lean b/mathlib4/Mathlib/Geometry/Euclidean/NinePointCircle.lean
index f8647f77a..4280effab 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/NinePointCircle.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/NinePointCircle.lean
@@ -74,6 +74,7 @@ theorem ninePointCircle_reindex {m n : ℕ} (s : Simplex ℝ P n) (e : Fin (n +
   · simp [ninePointCircle_center, centroid_reindex, h]
   · simp [ninePointCircle_radius, h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem ninePointCircle_map {V₂ P₂ : Type*} [NormedAddCommGroup V₂] [InnerProductSpace ℝ V₂]
     [MetricSpace P₂] [NormedAddTorsor V₂ P₂]
     {n : ℕ} (s : Simplex ℝ P n) (f : P →ᵃⁱ[ℝ] P₂) :
@@ -127,6 +128,7 @@ theorem eulerPoint_reindex {m n : ℕ} (s : Simplex ℝ P n) (e : Fin (n + 1) 
   ext i
   simp [eulerPoint, h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem eulerPoint_map {V₂ P₂ : Type*} [NormedAddCommGroup V₂] [InnerProductSpace ℝ V₂]
     [MetricSpace P₂] [NormedAddTorsor V₂ P₂]
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean b/mathlib4/Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
index f9a599cc8..ee45e5624 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
@@ -43,6 +43,7 @@ the second intersection with the sphere through `p` and with center `s.center`.
 def Sphere.secondInter (s : Sphere P) (p : P) (v : V) : P :=
   (-2 * ⟪v, p -ᵥ s.center⟫ / ⟪v, v⟫) • v +ᵥ p
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma Sphere.secondInter_map (s : Sphere P) (p : P) (v : V) (f : P →ᵃⁱ[ℝ] P₂) :
     Sphere.secondInter ⟨f s.center, s.radius⟩ (f p) (f.linearIsometry v) =
diff --git a/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean b/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
index b4b354c63..3a46e82f9 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@@ -66,6 +66,7 @@ instance : FunLike (LeftInvariantDerivation I G) C^∞⟮I, G; 𝕜⟯ C^∞⟮I
   coe f := f.toDerivation
   coe_injective _ _ h := toDerivation_injective <| DFunLike.ext' h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : LinearMapClass (LeftInvariantDerivation I G) 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯ where
   map_add f := map_add f.1
   map_smulₛₗ f := map_smul f.1.1
@@ -101,6 +102,7 @@ protected theorem map_neg : X (-f) = -X f := by simp
 
 protected theorem map_sub : X (f - f') = X f - X f' := by simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 protected theorem map_smul : X (r • f) = r • X f := by simp
 
@@ -254,6 +256,7 @@ instance : LieRing (LeftInvariantDerivation I G) where
     simp only [commutator_apply, coe_add, map_sub, Pi.add_apply]
     ring
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance : LieAlgebra 𝕜 (LeftInvariantDerivation I G) where
   lie_smul r Y Z := by
diff --git a/mathlib4/Mathlib/Geometry/Manifold/Instances/Sphere.lean b/mathlib4/Mathlib/Geometry/Manifold/Instances/Sphere.lean
index 7c5f1327d..549323104 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/Instances/Sphere.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/Instances/Sphere.lean
@@ -232,6 +232,7 @@ theorem stereo_left_inv (hv : ‖v‖ = 1) {x : sphere (0 : E) 1} (hx : (x : E)
   · field_simp
     linear_combination 4 * (a - 1) * pythag
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem stereo_right_inv (hv : ‖v‖ = 1) (w : (ℝ ∙ v)ᗮ) : stereoToFun v (stereoInvFun hv w) = w := by
   simp only [stereoToFun, stereoInvFun, stereoInvFunAux, smul_add, map_add, map_smul,
     innerSL_apply_apply, Submodule.orthogonalProjectionOnto_mem_subspace_eq_self]
diff --git a/mathlib4/Mathlib/Geometry/Manifold/IntegralCurve/Basic.lean b/mathlib4/Mathlib/Geometry/Manifold/IntegralCurve/Basic.lean
index be0efc65d..7c85771bd 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/IntegralCurve/Basic.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/IntegralCurve/Basic.lean
@@ -164,6 +164,7 @@ lemma IsMIntegralCurve.continuous (hγ : IsMIntegralCurve γ v) : Continuous γ
 
 variable [IsManifold I 1 M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `γ` is an integral curve of a vector field `v`, then `γ t` is tangent to `v (γ t)` when
 expressed in the local chart around the initial point `γ t₀`. -/
@@ -184,6 +185,7 @@ lemma IsMIntegralCurveOn.hasDerivWithinAt (hγ : IsMIntegralCurveOn γ v s) {t :
     mfderiv_chartAt_eq_tangentCoordChange hsrc]
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma IsMIntegralCurveAt.eventually_hasDerivAt (hγ : IsMIntegralCurveAt γ v t₀) :
     ∀ᶠ t in 𝓝 t₀, HasDerivAt ((extChartAt I (γ t₀)) ∘ γ)
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
index c9465be03..12a41f73d 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
@@ -311,6 +311,11 @@ lemma mfderivWithin_extChartAt_symm_comp_mfderiv_extChartAt
     simp only [Function.comp_def, PartialEquiv.left_inv (extChartAt I x) hz, id_eq]
   · simp only [Function.comp_def, PartialEquiv.right_inv (extChartAt I x) hy, id_eq]
 
+#adaptation_note
+/--
+Suggested fix: Make `TangentSpace` implicit-reducible, then remove `respectTransparency false`.
+-/
+set_option backward.isDefEq.respectTransparency false in
 /-- The composition of the derivative of the inverse of `extChartAt` with the derivative of
 `extChartAt` gives the identity.
 Version where the basepoint belongs to `(extChartAt I x).source`. -/
@@ -320,7 +325,6 @@ lemma mfderivWithin_extChartAt_symm_comp_mfderiv_extChartAt'
       = ContinuousLinearMap.id _ _ := by
   have : y = (extChartAt I x).symm (extChartAt I x y) := ((extChartAt I x).left_inv hy).symm
   convert! mfderivWithin_extChartAt_symm_comp_mfderiv_extChartAt ((extChartAt I x).map_source hy)
-  rw [(extChartAt I x).left_inv (by simpa using hy)]
 
 lemma isInvertible_mfderivWithin_extChartAt_symm {y : E} (hy : y ∈ (extChartAt I x).target) :
     (mfderiv[range I] (extChartAt I x).symm y).IsInvertible :=
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Basic.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
index 007db3b21..11a7c910e 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
@@ -493,6 +493,12 @@ theorem writtenInExtChartAt_comp (h : ContinuousWithinAt f s x) :
 variable {f' f₀' f₁' : TangentSpace% x →L[𝕜] TangentSpace% (f x)}
   {g' : TangentSpace% (f x) →L[𝕜] TangentSpace% (g (f x))}
 
+#adaptation_note
+/--
+Suggested fix: Make `TangentSpace` implicit-reducible, then remove `respectTransparency false`.
+After that, `instanceTypes false` can be removed, too.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `UniqueMDiffWithinAt` achieves its goal: it implies the uniqueness of the derivative. -/
 protected nonrec theorem UniqueMDiffWithinAt.eq (U : UniqueMDiffAt[s] x)
@@ -516,11 +522,23 @@ theorem mfderivWithin_univ : mfderiv[univ] f = mfderiv% f := by
   simp only [mfderivWithin, mfderiv, mfld_simps]
   rw [mdifferentiableWithinAt_univ]
 
+#adaptation_note
+/--
+Suggested fix: Make `TangentSpace` implicit-reducible, then remove `respectTransparency false`.
+After that, `instanceTypes false` can be removed, too.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 theorem mfderivWithin_zero_of_not_mdifferentiableWithinAt (h : ¬MDiffAt[s] f x) :
     mfderiv[s] f x = 0 := by
   simp only [mfderivWithin, h, ite_eq_right, not_false_iff]
 
+#adaptation_note
+/--
+Suggested fix: Make `TangentSpace` implicit-reducible, then remove `respectTransparency false`.
+After that, `instanceTypes false` can be removed, too.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 theorem mfderiv_zero_of_not_mdifferentiableAt (h : ¬MDiffAt f x) :
     mfderiv% f x = 0 := by simp only [mfderiv, h, ite_eq_right, not_false_iff]
@@ -587,6 +605,12 @@ theorem hasMFDerivAt_unique (h₀ : HasMFDerivAt% f x f₀') (h₁ : HasMFDerivA
   rw [← hasMFDerivWithinAt_univ] at h₀ h₁
   exact (uniqueMDiffWithinAt_univ I).eq h₀ h₁
 
+#adaptation_note
+/--
+Suggested fix: Make `TangentSpace` implicit-reducible, then remove `respectTransparency false`.
+After that, `instanceTypes false` can be removed, too.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 theorem hasMFDerivWithinAt_inter' (h : t ∈ 𝓝[s] x) :
     HasMFDerivAt[s ∩ t] f x f' ↔ HasMFDerivAt[s] f x f' := by
@@ -594,6 +618,12 @@ theorem hasMFDerivWithinAt_inter' (h : t ∈ 𝓝[s] x) :
     hasFDerivWithinAt_inter', continuousWithinAt_inter' h]
   exact extChartAt_preimage_mem_nhdsWithin h
 
+#adaptation_note
+/--
+Suggested fix: Make `TangentSpace` implicit-reducible, then remove `respectTransparency false`.
+After that, `instanceTypes false` can be removed, too.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 theorem hasMFDerivWithinAt_inter (h : t ∈ 𝓝 x) :
     HasMFDerivAt[s ∩ t] f x f' ↔ HasMFDerivAt[s] f x f' := by
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
index 39d5c7eee..b67969a0f 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
@@ -579,6 +579,8 @@ lemma mvfderiv_smul {x : M} {a : M → 𝕜} (ha : MDiffAt a x) {g : M → F} (h
   ext v
   simp [mvfderiv, -Pi.smul_apply', fromTangentSpace_mfderiv_smul_apply ha hg]
 
+set_option allowUnsafeReducibility true in
+attribute [local semireducible] TangentSpace in
 @[simp, to_fun mvfderiv_fun_mul]
 lemma mvfderiv_mul {f g : M → 𝕜} {x : M} (hf : MDiffAt f x) (hg : MDiffAt g x) :
     d% (f * g) x = f x • d% g x + (g x) • (d% f x) := by
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
index 300d1246f..a15599f80 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
@@ -480,6 +480,8 @@ theorem MDifferentiableOn.prodMap (hf : MDiff[s] f) (hg : MDiff[r] g) :
 theorem MDifferentiable.prodMap (hf : MDiff f) (hg : MDiff g) : MDiff (Prod.map f g) := fun p ↦
   (hf p.1).prodMap' (hg p.2)
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma HasMFDerivWithinAt.prodMap {s : Set <| M × M'} {p : M × M'} {f : M → N} {g : M' → N'}
     {df : TangentSpace% p.1 →L[𝕜] TangentSpace% (f p.1)}
     (hf : HasMFDerivAt[Prod.fst '' s] f p.1 df)
diff --git a/mathlib4/Mathlib/Geometry/Manifold/Riemannian/PathELength.lean b/mathlib4/Mathlib/Geometry/Manifold/Riemannian/PathELength.lean
index f41e39caa..7a81fd909 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/Riemannian/PathELength.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/Riemannian/PathELength.lean
@@ -133,6 +133,7 @@ open MeasureTheory
 
 variable [∀ (x : M), ENormSMulClass ℝ (TangentSpace% x)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The length of a path in a manifold is invariant under a monotone reparametrization. -/
 lemma pathELength_comp_of_monotoneOn {f : ℝ → ℝ} (h : a ≤ b) (hf : MonotoneOn f (Icc a b))
@@ -165,6 +166,7 @@ lemma pathELength_comp_of_monotoneOn {f : ℝ → ℝ} (h : a ≤ b) (hf : Monot
   have : 0 ≤ derivWithin f (Icc a b) t := hf.derivWithin_nonneg
   simp only [map_smul, enorm_smul, ← Real.enorm_of_nonneg this, f_im]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The length of a path in a manifold is invariant under an antitone reparametrization. -/
 lemma pathELength_comp_of_antitoneOn {f : ℝ → ℝ} (h : a ≤ b) (hf : AntitoneOn f (Icc a b))
diff --git a/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean b/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
index 9c437a587..bb6c17cf7 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
@@ -460,6 +460,7 @@ variable [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
   {ι : Type*} (b : Basis ι 𝕜 F) {s : Π x : M, V x} {t : Set M} {k : ℕ∞ω} {x x' : M}
   [FiniteDimensional 𝕜 F] [CompleteSpace 𝕜] [ContMDiffVectorBundle k F V I]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `s` is `C^k` at `x`, so is its coefficient `b.localFrameCoeff e i` in the local frame
 near `x` induced by `e` and `b` -/
@@ -545,6 +546,7 @@ alias contMDiffOn_baseSet_iff_localFrame_coeff := contMDiffOn_baseSet_iff_localF
 -- Differentiability of a section can be checked in terms of its local frame coefficients
 section MDifferentiable
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `s` is differentiable at `x`, so is its coefficient `b.localFrameCoeff e i` in the local
 frame near `x` induced by `e` and `b` -/
diff --git a/mathlib4/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean b/mathlib4/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
index 2121cd479..14c60df12 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
@@ -103,6 +103,37 @@ lemma mlieBracketWithin_eq_lieBracketWithin {V W : Π (x : E), TangentSpace 𝓘
 @[simp] lemma mlieBracketWithin_univ :
     mlieBracketWithin I V W univ = mlieBracket I V W := (rfl)
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`FunLike (TangentSpace 𝓘(𝕜, E) (↑I (↑(chartAt H x) x)) →L[𝕜] TangentSpace I x) _ _`
+It is needed by `map_zero` in the first bullet's `simp only`. That same `simp only` unfolds
+`extChartAt`, which rewrites `↑(extChartAt I x) x` in the type index to `↑I (↑(chartAt H x) x)`,
+while the instance arguments inside the term keep the old spelling `↑(extChartAt I x) x`.
+
+The failure happens while applying `@ContinuousLinearMap.funLike`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type is
+`TopologicalSpace (TangentSpace 𝓘(𝕜, E) (↑I (↑(chartAt H x) x)))`, whereas the assigned value
+`instTopologicalSpaceTangentSpace 𝓘(𝕜, E) (↑(extChartAt I x) x)` has type
+`TopologicalSpace (TangentSpace 𝓘(𝕜, E) (↑(extChartAt I x) x))`. The comparison bottoms out at
+`(extChartAt I x).1 =?= @ModelWithCorners.toFun'`. Lean falls back to synthesize an instance of the
+correct type, which succeeds and returns
+`instTopologicalSpaceTangentSpace 𝓘(𝕜, E) (↑I (↑(chartAt H x) x))`, but that is again not defeq to
+the assigned value, stalling at the same comparison. It, too, runs at `.instances`, since
+`respectTransparency false` suppresses the transparency bump that instance-implicit arguments would
+otherwise receive.
+
+With no `FunLike` instance found, `map_zero` does not fire and the goal
+`(mfderiv% (↑I ∘ ↑(chartAt H x)) x).inverse 0 = 0` is left open.
+
+Potential fix: mark `TangentSpace` implicit-reducible, then remove `respectTransparency false`; the
+bumped comparison then unfolds both `TangentSpace`'s to `E`, so the point no longer
+matters. The annotation has to be at the definition site of `TangentSpace`; a `local` attribute here
+is not enough.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 lemma mlieBracketWithin_eq_zero_of_eq_zero (hV : V x = 0) (hW : W x = 0) :
     mlieBracketWithin I V W s x = 0 := by
@@ -135,6 +166,23 @@ lemma mlieBracket_swap_apply : mlieBracket I V W x = - mlieBracket I W V x :=
 lemma mlieBracket_swap : mlieBracket I V W = - mlieBracket I W V :=
   mlieBracketWithin_swap
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+This is the same failure as for `mlieBracketWithin_eq_zero_of_eq_zero` above, reached through the
+`simp` below instead: the instance
+`FunLike (TangentSpace 𝓘(𝕜, E) (↑I (↑(chartAt H x✝) x✝)) →L[𝕜] TangentSpace I x✝) _ _` cannot be
+synthesized, because while applying `@ContinuousLinearMap.funLike` the metavariable of type
+`TopologicalSpace (TangentSpace 𝓘(𝕜, E) (↑I (↑(chartAt H x✝) x✝)))` is assigned
+`instTopologicalSpaceTangentSpace 𝓘(𝕜, E) (↑(extChartAt I x✝) x✝)`, whose type spells the point as
+`↑(extChartAt I x✝) x✝`. Both the direct `.instances` check and the comparison against the
+re-synthesized instance bottom out at `(extChartAt I x✝).1 =?= @ModelWithCorners.toFun'`, and the
+goal `(mfderiv% (↑I ∘ ↑(chartAt H x✝)) x✝).inverse 0 = 0` is left open.
+
+Potential fix: mark `TangentSpace` implicit-reducible at its definition site, then remove
+`respectTransparency false`.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma mlieBracketWithin_self : mlieBracketWithin I V V = 0 := by
   ext x; simp [mlieBracketWithin, mpullback]
@@ -335,6 +383,45 @@ private lemma mfderiv_extChart_inverse_comp_aux :
       ((mfderiv[range I] φ.symm (φ x)).inverse) (W (φ.symm (φ x))) = W x := by
   rw [mfderiv_extChartAt_inverse_comp_mfderivWithin_extChartAT_symm, extChartAt_to_inv]
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`HSMul (TangentSpace 𝓘(𝕜, 𝕜) (f x)) (TangentSpace I x) ?m`
+It is needed for the `•` in the statement below, and reduces through the `instHSMul`/`SMul`/…/
+`Module` chain sketched in the section header to
+`Module (TangentSpace 𝓘(𝕜, 𝕜) (f x)) (TangentSpace I x)`.
+
+The failure happens while applying `@instModuleTangentSpace`. This seems to make sense
+mathematically: it makes `TangentSpace I x` a `𝕜`-module, but not a
+`TangentSpace 𝓘(𝕜, 𝕜) (f x)`-module as needed.
+
+Unlike for the two adaptations above, marking `TangentSpace` implicit-reducible at its definition
+site does not fix this one. It does make `respectTransparency false` removable, but
+`instanceTypes false` is still needed afterwards.
+
+The technical reason for the failure: assigning one of the instane's instance-implicit-argument
+metavariables is rejected because the metavariable's type and the type of the assigned value do not
+match at `.instances` transparency. The metavariable's expected type is
+`NontriviallyNormedField (TangentSpace 𝓘(𝕜, 𝕜) (f x))`, whereas the assigned value is the ambient
+instance of type `NontriviallyNormedField 𝕜`. The comparison bottoms out at
+`TangentSpace 𝓘(𝕜, 𝕜) (f x) =?= 𝕜`, where `TangentSpace` is a plain semireducible `def` and
+therefore does not unfold at the `.instances` transparency that instance search runs at. Lean falls
+back to synthesize an instance of the expected type, but that synthesis fails as well.
+
+Instance search follows this path:
+
+```
+  HSMul (TangentSpace 𝓘(𝕜,𝕜) (f x)) (TangentSpace I x) ?m.238
+    └ @instHSMul
+      └ @SMulZeroClass.toSMul
+        └ @SMulWithZero.toSMulZeroClass
+          └ MulActionWithZero.toSMulWithZero
+            └ @Module.toMulActionWithZero
+```
+-/
+set_option backward.isDefEq.respectTransparency.outParams false in
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Pulling back through `extChartAt` the scalar multiplication of a vector field by
 the derivative of a scalar function equals the scalar multiplication by the manifold derivative. -/
diff --git a/mathlib4/Mathlib/Geometry/RingedSpace/OpenImmersion.lean b/mathlib4/Mathlib/Geometry/RingedSpace/OpenImmersion.lean
index cc16fc4c4..7f803142f 100644
--- a/mathlib4/Mathlib/Geometry/RingedSpace/OpenImmersion.lean
+++ b/mathlib4/Mathlib/Geometry/RingedSpace/OpenImmersion.lean
@@ -194,7 +194,6 @@ theorem inv_naturality {U V : (Opens X)ᵒᵖ} (i : U ⟶ V) :
     TopCat.Presheaf.pushforward_obj_map]
   congr 1
 
-set_option backward.isDefEq.respectTransparency.types false in
 instance (U : Opens X) : IsIso (invApp f U) := by delta invApp; infer_instance
 
 set_option backward.isDefEq.respectTransparency.types false in
diff --git a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
index ecfbea3c3..7dc4f5425 100644
--- a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@@ -655,6 +655,7 @@ section arrowCongrₗ
 
 variable (e₁ : P₁ ≃ᵃ[R] P₂) (e₂ : V₃ ≃ₗ[R] V₄)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- An affine isomorphism between the domains and a linear isomorphism between the codomains of two
 spaces of affine maps give a linear isomorphism between the two function spaces.
diff --git a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean
index 199ab8efa..6054fedb0 100644
--- a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean
@@ -531,6 +531,7 @@ alias AffineMap.vectorSpan_image_eq_submodule_map := AffineMap.map_vectorSpan
 
 namespace AffineSubspace
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The image of an affine subspace under an affine map as an affine subspace. -/
 def map (s : AffineSubspace k P₁) : AffineSubspace k P₂ where
   carrier := f '' s
@@ -724,6 +725,7 @@ end
 
 namespace AffineSubspace
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The preimage of an affine subspace under an affine map as an affine subspace. -/
 def comap (f : P₁ →ᵃ[k] P₂) (s : AffineSubspace k P₂) : AffineSubspace k P₁ where
   carrier := f ⁻¹' s
diff --git a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Shift.lean b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Shift.lean
index e7ad342de..6c8017e08 100644
--- a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Shift.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Shift.lean
@@ -98,6 +98,7 @@ theorem shift_one (s : AffineSubspace k P) (c : P) : s.shift c 1 = s := by
   have h : Nonempty s := by simpa using! h
   simp [shift, h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Consider a point `A` with barycentric coordinates associated to a collection of points `P`.
 If the coordinate associated to one of the points `Pᵢ` is `r`, then the point `A` is on the span
 of `P \ {Pᵢ}` shifted towards `Pᵢ` with parameter `1 - r`. -/
@@ -120,6 +121,7 @@ theorem affineCombination_mem_shift {ι : Type*} [Fintype ι] [Nontrivial ι]
   refine affineCombination_mem_affineSpan_image ?_ (fun i' _ hi ↦ by aesop) _
   simp [sum_add_distrib, ← mul_sum, hw]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The iff version of `affineCombination_mem_shift` for affine independent points. -/
 theorem _root_.AffineIndependent.affineCombination_mem_shift_iff
     {ι : Type*} [Fintype ι] [Nontrivial ι] {p : ι → P}
diff --git a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/Combination.lean b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/Combination.lean
index c35688997..b60d92da3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/Combination.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/Combination.lean
@@ -594,6 +594,7 @@ lemma affineCombination_apply_eq_lineMap_sum [DecidableEq ι] (w : ι → k) (p
     simp [hp₁ i hi]
   · exact (hp₂ i hi).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Applying `AffineMap.lineMap` on two `Finset.affineCombination` over the same set of points
 is equivalent to applying `AffineMap.lineMap` to the weights. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Basic.lean
index 146f6352a..47e05541e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Basic.lean
@@ -289,6 +289,7 @@ section Module.IsTorsionFree
 
 set_option backward.isDefEq.respectTransparency false in
 -- Can't be an instance because the basis can't be inferred.
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected lemma isTorsionFree (b : Basis ι R M) :
     Module.IsTorsionFree R M := b.repr.injective.moduleIsTorsionFree _ (by simp)
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Bilinear.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Bilinear.lean
index 7ef6b390d..2772e7b94 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Bilinear.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Bilinear.lean
@@ -57,6 +57,7 @@ theorem sum_repr_mul_repr_mulₛₗ {B : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁
   conv_rhs => rw [← b₁.linearCombination_repr x, ← b₂.linearCombination_repr y]
   simp_rw [Finsupp.linearCombination_apply, Finsupp.sum, map_sum₂, map_sum, map_smulₛₗ₂, map_smulₛₗ]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Write out `B x y` as a sum over `B (b i) (b j)` if `b` is a basis.
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Cardinality.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Cardinality.lean
index 2e312c374..b9edc21bd 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Cardinality.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Cardinality.lean
@@ -65,6 +65,7 @@ variable [Semiring R] [AddCommMonoid M] [Nontrivial R] [Module R M]
 
 set_option backward.isDefEq.respectTransparency false in
 -- From [Les familles libres maximales d'un module ont-elles le meme cardinal?][lazarus1973]
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Over any ring `R`, if `b` is a basis for a module `M`,
 and `s` is a maximal linearly independent set,
 then the union of the supports of `x ∈ s` (when written out in the basis `b`) is all of `b`.
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Defs.lean
index 4428deb1f..036c191c2 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Defs.lean
@@ -122,6 +122,7 @@ protected theorem injective [Nontrivial R] : Injective b :=
 theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c • b i :=
   calc
     b.repr.symm (Finsupp.single i c) = b.repr.symm (c • Finsupp.single i (1 : R)) := by
@@ -434,6 +435,7 @@ theorem reindexRange_apply (x : range b) : b.reindexRange x = x := by
   rcases x with ⟨bi, ⟨i, rfl⟩⟩
   exact b.reindexRange_self i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem reindexRange_repr' (x : M) {bi : M} {i : ι} (h : b i = bi) :
     b.reindexRange.repr x ⟨bi, ⟨i, h⟩⟩ = b.repr x i := by
@@ -644,6 +646,7 @@ theorem equiv'_symm_apply (f : M → M') (g : M' → M) (hf hg hgf hfg) (i : ι'
     (b.equiv' b' f g hf hg hgf hfg).symm (b' i) = g (b' i) :=
   b'.constr_basis R _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem sum_repr_mul_repr {ι'} [Fintype ι'] (b' : Basis ι' R M) (x : M) (i : ι) :
     (∑ j : ι', b.repr (b' j) i * b'.repr x j) = b.repr x i := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Exact.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Exact.lean
index 53968a3f0..a33cc3dca 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Exact.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Exact.lean
@@ -52,6 +52,7 @@ lemma LinearIndependent.linearIndependent_of_exact_of_retraction
   simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.id_coe, id_eq] at hs
   rw [← hs, hz, map_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 private lemma top_le_span_of_aux (v : κ ⊕ σ → M)
     (hg : Function.Surjective g) (hslzero : ∀ i, s (v (.inl i)) = 0)
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/SMul.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/SMul.lean
index d48b6c6be..84fa928eb 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/SMul.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/SMul.lean
@@ -110,6 +110,7 @@ theorem unitsSMul_apply {v : Basis ι R M} {w : ι → Rˣ} (i : ι) : unitsSMul
 
 variable [CommSemiring R₂] [Module R₂ M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem coord_unitsSMul (e : Basis ι R₂ M) (w : ι → R₂ˣ) (i : ι) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/VectorSpace.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/VectorSpace.lean
index da1e7bed2..75ad17bb1 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/VectorSpace.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/VectorSpace.lean
@@ -342,6 +342,7 @@ variable {K : Type*} {V : Type*} [Field K] [AddCommGroup V] [Module K V]
 
 variable {f : V →ₗ[K] K} {v : V}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- In a vector space, given a nonzero linear form `f`,
 a nonzero vector `v` such that `f v ≠ 0`,
diff --git a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Basic.lean
index 1aa63f56c..f19129678 100644
--- a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Basic.lean
@@ -68,6 +68,7 @@ theorem smul_left (a : R) (x y : M) : B (a • x) y = a * B x y := map_smul₂ _
 
 theorem add_right (x y z : M) : B x (y + z) = B x y + B x z := map_add _ _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem smul_right (a : R) (x y : M) : B x (a • y) = a * B x y := map_smul _ _ _
 
 theorem zero_left (x : M) : B 0 x = 0 := map_zero₂ _ _
diff --git a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
index efc81f12a..259e92a02 100644
--- a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
@@ -89,6 +89,7 @@ lemma dualSubmoduleToDual_injective [IsDomain R] (hB : B.Nondegenerate) [IsTorsi
   intro z hz
   simpa using congr_arg (algebraMap R S) (LinearMap.congr_fun e ⟨z, hz⟩)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma dualSubmodule_span_of_basis {ι} [Finite ι] [DecidableEq ι]
     (hB : B.Nondegenerate) (b : Basis ι S M) :
     B.dualSubmodule (Submodule.span R (Set.range b)) =
diff --git a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
index f513825c0..fbb038f50 100644
--- a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
@@ -101,6 +101,7 @@ section
 variable {R₄ M₄ : Type*} [CommRing R₄] [IsDomain R₄]
 variable [AddCommGroup M₄] [Module R₄ M₄] {G : BilinForm R₄ M₄}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[deprecated "`BilinMap.IsOrtho` has been deprecated" (since := "2026-03-30")]
 theorem isOrtho_smul_left {x y : M₄} {a : R₄} (ha : a ≠ 0) :
     IsOrtho G (a • x) y ↔ IsOrtho G x y := by
@@ -109,6 +110,7 @@ theorem isOrtho_smul_left {x y : M₄} {a : R₄} (ha : a ≠ 0) :
   simp only [LinearMap.smul_apply, smul_eq_mul, mul_eq_zero, or_iff_right_iff_imp]
   exact fun a ↦ (ha a).elim
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[deprecated "`BilinMap.IsOrtho` has been deprecated" (since := "2026-03-30")]
 theorem isOrtho_smul_right {x y : M₄} {a : R₄} (ha : a ≠ 0) :
     IsOrtho G x (a • y) ↔ IsOrtho G x y := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Properties.lean b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Properties.lean
index fa737f807..7819af7b7 100644
--- a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Properties.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@@ -157,6 +157,7 @@ lemma ext_iff_of_isSymm (hB : IsSymm B) (hC : IsSymm C) :
 
 end polarization
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isSymm_iff_basis {ι : Type*} (b : Basis ι R M) :
     IsSymm B ↔ ∀ i j, B (b i) (b j) = B (b j) (b i) where
diff --git a/mathlib4/Mathlib/LinearAlgebra/Center.lean b/mathlib4/Mathlib/LinearAlgebra/Center.lean
index 8e8d25428..ee51b56e8 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Center.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Center.lean
@@ -95,6 +95,7 @@ theorem commute_transvections_iff_of_basis
   intro j _
   simp [Subring.smul_def, h_allEq i j, hcomm j]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Over a domain, an endomorphism `f` of a free module `V`
 of rank ≠ 1 such that `f v` and `v` are collinear, for all `v : V`,
 consists of homotheties with central ratio.
diff --git a/mathlib4/Mathlib/LinearAlgebra/Charpoly/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Charpoly/Basic.lean
index bd9cfef21..f22fcee53 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Charpoly/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Charpoly/Basic.lean
@@ -61,6 +61,7 @@ theorem charpoly_one [StrongRankCondition R] :
     (1 : M →ₗ[R] M).charpoly = (X - 1) ^ Module.finrank R M := by
   simp [charpoly, Module.finrank_eq_card_chooseBasisIndex, Matrix.charpoly_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem charpoly_sub_smul (f : Module.End R M) (μ : R) :
     (f - μ • 1).charpoly = f.charpoly.comp (X + C μ) := by
   simpa [LinearMap.charpoly, smul_eq_mul_diagonal] using Matrix.charpoly_sub_scalar ..
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
index 49a9a2c7b..e6446e09b 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
@@ -67,6 +67,7 @@ def ofBaseChange (Q : QuadraticForm R V) :
   Algebra.TensorProduct.lift (Algebra.ofId _ _) (ofBaseChangeAux A Q)
     fun _a _x => Algebra.commutes _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] theorem ofBaseChange_tmul_ι (Q : QuadraticForm R V) (z : A) (v : V) :
     ofBaseChange A Q (z ⊗ₜ ι Q v) = ι (Q.baseChange A) (z ⊗ₜ v) := by
   change algebraMap _ _ z * ofBaseChangeAux A Q (ι Q v) = ι (Q.baseChange A) (z ⊗ₜ[R] v)
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
index ba26f5739..25056008f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
@@ -306,6 +306,7 @@ theorem mul_ι_mul_ι_mul_comm_of_isOrtho
 
 end isOrtho
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- $aba$ is a vector. -/
 theorem ι_mul_ι_mul_ι (a b : M) :
     ι Q a * ι Q b * ι Q a = ι Q (QuadraticMap.polar Q a b • a - Q a • b) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
index 1cf62573a..363df7e9d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
@@ -128,12 +128,14 @@ theorem contractLeft_ι_mul (a : M) (b : CliffordAlgebra Q) :
   refine foldr'_ι_mul _ _ ?_ _ _ _
   exact fun m x fx ↦ contractLeftAux_contractLeftAux Q d m x fx
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- This is [grinberg_clifford_2016] Theorem 12 -/
 theorem contractRight_mul_ι (a : M) (b : CliffordAlgebra Q) :
     b * ι Q a⌊d = d a • b - b⌊d * ι Q a := by
   rw [contractRight_eq, reverse.map_mul, reverse_ι, contractLeft_ι_mul, map_sub, map_smul,
     reverse_reverse, reverse.map_mul, reverse_ι, contractRight_eq]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem contractLeft_algebraMap_mul (r : R) (b : CliffordAlgebra Q) :
     d⌋(algebraMap _ _ r * b) = algebraMap _ _ r * (d⌋b) := by
   rw [← Algebra.smul_def, map_smul, Algebra.smul_def]
@@ -184,6 +186,7 @@ theorem contractRight_one : (1 : CliffordAlgebra Q)⌊d = 0 := by
 
 variable {Q}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- This is [grinberg_clifford_2016] Theorem 7 -/
 theorem contractLeft_contractLeft (x : CliffordAlgebra Q) : d⌋(d⌋x) = 0 := by
   induction x using CliffordAlgebra.left_induction with
@@ -196,6 +199,7 @@ theorem contractLeft_contractLeft (x : CliffordAlgebra Q) : d⌋(d⌋x) = 0 := b
 theorem contractRight_contractRight (x : CliffordAlgebra Q) : x⌊d⌊d = 0 := by
   rw [contractRight_eq, contractRight_eq, reverse_reverse, contractLeft_contractLeft, map_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- This is [grinberg_clifford_2016] Theorem 8 -/
 theorem contractLeft_comm (x : CliffordAlgebra Q) : d⌋(d'⌋x) = -(d'⌋(d⌋x)) := by
   induction x using CliffordAlgebra.left_induction with
@@ -286,6 +290,7 @@ theorem changeForm_ι_mul_ι (m₁ m₂ : M) :
     changeForm h (ι Q m₁ * ι Q m₂) = ι Q' m₁ * ι Q' m₂ - algebraMap _ _ (B m₁ m₂) := by
   rw [changeForm_ι_mul, changeForm_ι, contractLeft_ι]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Theorem 23 of [grinberg_clifford_2016] -/
 theorem changeForm_contractLeft (d : Module.Dual R M) (x : CliffordAlgebra Q) :
     changeForm h (d⌋x) = d⌋(changeForm h x) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
index 69383a1c5..b568ae87e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@@ -339,6 +339,7 @@ open DualNumber TrivSqZeroExt
 
 variable {R : Type*} [CommRing R]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem ι_mul_ι (r₁ r₂) : ι (0 : QuadraticForm R R) r₁ * ι (0 : QuadraticForm R R) r₂ = 0 := by
   rw [← mul_one r₁, ← mul_one r₂, ← smul_eq_mul r₁, ← smul_eq_mul r₂, map_smul, map_smul,
     smul_mul_smul_comm, ι_sq_scalar, zero_apply, map_zero, smul_zero]
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
index eb3939dd0..343751420 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
@@ -70,6 +70,7 @@ structure EvenHom where
 
 variable {A Q}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Compose an `EvenHom` with an `AlgHom` on the output. -/
 @[simps]
 def EvenHom.compr₂ (g : EvenHom Q A) (f : A →ₐ[R] B) : EvenHom Q B where
@@ -80,6 +81,7 @@ def EvenHom.compr₂ (g : EvenHom Q A) (f : A →ₐ[R] B) : EvenHom Q B where
 
 variable (Q)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The embedding of pairs of vectors into the even subalgebra, as a bilinear map. -/
 nonrec def even.ι : EvenHom Q (even Q) where
   bilin :=
@@ -101,6 +103,7 @@ instance : Inhabited (EvenHom Q (even Q)) :=
 
 variable (f : EvenHom Q A)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Two algebra morphisms from the even subalgebra are equal if they agree on pairs of generators.
 
 See note [partially-applied ext lemmas]. -/
@@ -130,6 +133,7 @@ private def S : Submodule R (M →ₗ[R] A) :=
   Submodule.span R
     {f' | ∃ x m₂, f' = LinearMap.lcomp R _ (f.bilin.flip m₂) (LinearMap.mulRight R x)}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.privateInPublic true in
 /-- An auxiliary bilinear map that is later passed into `CliffordAlgebra.foldr`. Our desired result
 is stored in the `A` part of the accumulator, while auxiliary recursion state is stored in the `S f`
@@ -202,6 +206,7 @@ def aux (f : EvenHom Q A) : CliffordAlgebra.even Q →ₗ[R] A := by
 theorem aux_one : aux f 1 = 1 :=
   congr_arg Prod.fst (foldr_one _ _ _ _)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem aux_ι (m₁ m₂ : M) : aux f ((even.ι Q).bilin m₁ m₂) = f.bilin m₁ m₂ := by
   rw [CliffordAlgebra.even.lift.aux_apply]
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
index 5dbfba999..e65e8b2ed 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
@@ -61,6 +61,7 @@ def e0 : CliffordAlgebra (Q' Q) :=
 def v : M →ₗ[R] CliffordAlgebra (Q' Q) :=
   ι (Q' Q) ∘ₗ LinearMap.inl _ _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem ι_eq_v_add_smul_e0 (m : M) (r : R) : ι (Q' Q) (m, r) = v Q m + r • e0 Q := by
   rw [e0, v, LinearMap.comp_apply, LinearMap.inl_apply, ← map_smul, Prod.smul_mk,
     smul_zero, smul_eq_mul, mul_one, ← map_add, Prod.mk_add_mk, zero_add, add_zero]
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
index 9b54663a4..a73952ed2 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
@@ -22,6 +22,7 @@ namespace CliffordAlgebra
 
 variable (Q)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If the quadratic form of a vector is invertible, then so is that vector. -/
 @[instance_reducible]
 def invertibleιOfInvertible (m : M) [Invertible (Q m)] : Invertible (ι Q m) where
@@ -42,12 +43,14 @@ theorem isUnit_ι_of_isUnit {m : M} (h : IsUnit (Q m)) : IsUnit (ι Q m) := by
   let := invertibleιOfInvertible Q m
   exact isUnit_of_invertible (ι Q m)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- $aba^{-1}$ is a vector. -/
 theorem ι_mul_ι_mul_invOf_ι (a b : M) [Invertible (ι Q a)] [Invertible (Q a)] :
     ι Q a * ι Q b * ⅟(ι Q a) = ι Q ((⅟(Q a) * QuadraticMap.polar Q a b) • a - b) := by
   rw [invOf_ι, map_smul, mul_smul_comm, ι_mul_ι_mul_ι, ← map_smul, smul_sub, smul_smul, smul_smul,
     invOf_mul_self, one_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- $a^{-1}ba$ is a vector. -/
 theorem invOf_ι_mul_ι_mul_ι (a b : M) [Invertible (ι Q a)] [Invertible (Q a)] :
     ⅟(ι Q a) * ι Q b * ι Q a = ι Q ((⅟(Q a) * QuadraticMap.polar Q a b) • a - b) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
index ddb5782d8..349e9dc3d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
@@ -49,6 +49,7 @@ theorem star_def' (x : CliffordAlgebra Q) : star x = involute (reverse x) :=
 @[simp]
 theorem star_ι (m : M) : star (ι Q m) = -ι Q m := by rw [star_def, involute_ι, map_neg, reverse_ι]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Note that this not match the `star_smul` implied by `StarModule`; it certainly could if we
 also conjugated all the scalars, but there appears to be nothing in the literature that advocates
 doing this. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Complex/Module.lean b/mathlib4/Mathlib/LinearAlgebra/Complex/Module.lean
index ce14d98da..5b0d962a8 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Complex/Module.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Complex/Module.lean
@@ -497,9 +497,11 @@ section StarHomClass
 variable {B F : Type*} [AddCommGroup B] [Module ℂ B] [StarAddMonoid B] [StarModule ℂ B]
     [FunLike F A B] [StarHomClass F A B] [LinearMapClass F ℂ A B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma map_realPart (f : F) (x : A) : f (ℜ x) = ℜ (f x) := by
   simp [realPart_apply_coe, ← Complex.coe_smul, map_star]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma map_imaginaryPart (f : F) (x : A) : f (ℑ x) = ℑ (f x) := by
   simp [imaginaryPart_apply_coe, ← Complex.coe_smul, map_star]
 
@@ -653,6 +655,7 @@ lemma mem_unitary_iff_isStarNormal_and_realPart_sq_add_imaginaryPart_sq_eq_one [
     exact ⟨this, by simp [sq, ← star_mul_self_eq_realPart_sq_add_imaginaryPart_sq x, h]⟩
   · simp [← hx.star_comm_self.eq, star_mul_self_eq_realPart_sq_add_imaginaryPart_sq, ← sq, h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance {F E A : Type*} [AddCommGroup E] [PartialOrder E]
     [StarAddMonoid E] [SelfAdjointDecompose E] [Module ℂ E] [StarModule ℂ E]
     [NonUnitalRing A] [PartialOrder A] [StarRing A]
diff --git a/mathlib4/Mathlib/LinearAlgebra/Contraction.lean b/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
index d6a838fd4..254d24938 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
@@ -112,6 +112,7 @@ theorem map_dualTensorHom (f : Module.Dual R M) (p : P) (g : Module.Dual R N) (q
   simp only [compr₂ₛₗ_apply, mk_apply, map_tmul, dualTensorHom_apply, dualDistrib_apply,
     ← smul_tmul_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem comp_dualTensorHom (f : Module.Dual R M) (n : N) (g : Module.Dual R N) (p : P) :
@@ -121,6 +122,7 @@ theorem comp_dualTensorHom (f : Module.Dual R M) (n : N) (g : Module.Dual R N) (
   simp only [coe_comp, Function.comp_apply, dualTensorHom_apply, map_smul, LinearMap.smul_apply]
   rw [smul_comm]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- As a matrix, `dualTensorHom` evaluated on a basis element of `M* ⊗ N` is a matrix with a
 single one and zeros elsewhere -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/CrossProduct.lean b/mathlib4/Mathlib/LinearAlgebra/CrossProduct.lean
index c66be92db..1602b7c69 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CrossProduct.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CrossProduct.lean
@@ -150,6 +150,7 @@ end LeibnizProperties
 
 -- this can also be proved via `dotProduct_eq_zero_iff` and `triple_product_eq_det`, but
 -- that would require much heavier imports.
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma crossProduct_ne_zero_iff_linearIndependent {F : Type*} [Field F] {v w : Fin 3 → F} :
     crossProduct v w ≠ 0 ↔ LinearIndependent F ![v, w] := by
   rw [not_iff_comm]
diff --git a/mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean b/mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean
index 1f226ab34..ca722c2be 100644
--- a/mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean
@@ -147,6 +147,7 @@ def linearEquivFunOnFintype [Fintype ι] : (Π₀ i, M i) ≃ₗ[R] (Π i, M i)
   map_add' _ _ := by ext; rfl
   map_smul' _ _ := by ext; rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The `DFinsupp` version of `Finsupp.lsum`.
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/Determinant.lean b/mathlib4/Mathlib/LinearAlgebra/Determinant.lean
index c7a9c3852..ac44a4ae8 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Determinant.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Determinant.lean
@@ -250,6 +250,7 @@ theorem det_comp (f g : M →ₗ[A] M) :
 theorem det_id : LinearMap.det (LinearMap.id : M →ₗ[A] M) = 1 :=
   LinearMap.det.map_one
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Multiplying a map by a scalar `c` multiplies its determinant by `c ^ dim M`. -/
 @[simp]
@@ -343,6 +344,7 @@ theorem finite_of_det_ne_one {f : M →ₗ[R] M} (hf : f.det ≠ 1) : Module.Fin
     exact Module.Finite.of_basis hs
   · classical simp [LinearMap.coe_det, H] at hf
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If the determinant of a map vanishes, then the map is not injective. -/
 theorem bot_lt_ker_of_det_eq_zero [IsDomain R] [Free R M] {f : M →ₗ[R] M} (hf : f.det = 0) :
@@ -593,6 +595,7 @@ theorem LinearMap.associated_det_comp_equiv {N : Type*} [AddCommGroup N] [Module
 
 namespace Module.Basis
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- The determinant of a family of vectors with respect to some basis, as an alternating
@@ -613,24 +616,30 @@ nonrec def det : M [⋀^ι]→ₗ[R] R where
     apply det_zero_of_row_eq hij
     rw [updateRow_ne hij.symm, updateRow_self]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_apply (v : ι → M) : e.det v = Matrix.det (e.toMatrix v) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_self : e.det e = 1 := by simp [e.det_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_isEmpty [IsEmpty ι] : e.det = AlternatingMap.constOfIsEmpty R M ι 1 := by
   ext v
   exact Matrix.det_isEmpty
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `Basis.det` is not the zero map. -/
 theorem det_ne_zero [Nontrivial R] : e.det ≠ 0 := fun h => by simpa [h] using e.det_self
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem smul_det {G} [Group G] [DistribMulAction G M] [SMulCommClass G R M]
     (g : G) (v : ι → M) :
     (g • e).det v = e.det (g⁻¹ • v) := by
   simp_rw [det_apply, toMatrix_smul_left]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem is_basis_iff_det {v : ι → M} :
     LinearIndependent R v ∧ span R (Set.range v) = ⊤ ↔ IsUnit (e.det v) := by
   constructor
@@ -649,11 +658,13 @@ theorem is_basis_iff_det {v : ι → M} :
     rw [← this]
     exact ⟨v'.linearIndependent, v'.span_eq⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isUnit_det (e' : Basis ι R M) : IsUnit (e.det e') :=
   (is_basis_iff_det e).mp ⟨e'.linearIndependent, e'.span_eq⟩
 
 end Module.Basis
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Any alternating map to `R` where `ι` has the cardinality of a basis equals the determinant
 map with respect to that basis, multiplied by the value of that alternating map on that basis. -/
 theorem AlternatingMap.eq_smul_basis_det (f : M [⋀^ι]→ₗ[R] R) : f = f e • e.det := by
@@ -679,6 +690,7 @@ variable {A : Type*} [CommRing A] [Module A M]
 
 namespace Module.Basis
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_comp (e : Basis ι A M) (f : M →ₗ[A] M) (v : ι → M) :
     e.det (f ∘ v) = (LinearMap.det f) * e.det v := by
@@ -686,6 +698,7 @@ theorem det_comp (e : Basis ι A M) (f : M →ₗ[A] M) (v : ι → M) :
     e.toMatrix_eq_toMatrix_constr (f ∘ v), e.toMatrix_eq_toMatrix_constr v, ← toMatrix_comp,
     e.constr_comp]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_comp_basis [Module A M'] (b : Basis ι A M) (b' : Basis ι A M') (f : M →ₗ[A] M') :
     b'.det (f ∘ b) = LinearMap.det (f ∘ₗ (b'.equiv b (Equiv.refl ι) : M' →ₗ[A] M)) := by
@@ -694,11 +707,13 @@ theorem det_comp_basis [Module A M'] (b : Basis ι A M) (b' : Basis ι A M') (f
   congr 1; ext i j
   rw [toMatrix_apply, LinearMap.toMatrix_apply, Function.comp_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_basis (b : Basis ι A M) (b' : Basis ι A M) :
     LinearMap.det (b'.equiv b (Equiv.refl ι)).toLinearMap = b'.det b :=
   (b.det_comp_basis b' (LinearMap.id)).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_mul_det (b b' b'' : Basis ι A M) :
     b.det b' * b'.det b'' = b.det b'' := by
   have : b'' = (b'.equiv b'' (Equiv.refl ι)).toLinearMap ∘ b' := by
@@ -706,40 +721,48 @@ theorem det_mul_det (b b' b'' : Basis ι A M) :
   conv_rhs =>
     rw [this, Basis.det_comp, det_basis, mul_comm]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_inv (b : Basis ι A M) (b' : Basis ι A M) :
     (b.isUnit_det b').unit⁻¹ = b'.det b := by
   rw [← Units.mul_eq_one_iff_inv_eq, IsUnit.unit_spec, ← det_basis, ← det_basis]
   exact LinearEquiv.det_mul_det_symm _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_reindex {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M) (v : ι' → M)
     (e : ι ≃ ι') : (b.reindex e).det v = b.det (v ∘ e) := by
   rw [det_apply, toMatrix_reindex', det_reindexAlgEquiv, det_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_reindex' {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M)
     (e : ι ≃ ι') : (b.reindex e).det = b.det.domDomCongr e :=
   AlternatingMap.ext fun _ => det_reindex _ _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_reindex_symm {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M)
     (v : ι → M) (e : ι' ≃ ι) : (b.reindex e.symm).det (v ∘ e) = b.det v := by
   rw [det_reindex, Function.comp_assoc, e.self_comp_symm, Function.comp_id]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_map (b : Basis ι R M) (f : M ≃ₗ[R] M') (v : ι → M') :
     (b.map f).det v = b.det (f.symm ∘ v) := by
   rw [det_apply, toMatrix_map, det_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_map' (b : Basis ι R M) (f : M ≃ₗ[R] M') :
     (b.map f).det = b.det.compLinearMap f.symm :=
   AlternatingMap.ext <| b.det_map f
 
 end Module.Basis
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem Pi.basisFun_det : (Pi.basisFun R ι).det = Matrix.detRowAlternating := by
   ext M
   rw [Basis.det_apply, Basis.coePiBasisFun.toMatrix_eq_transpose, det_transpose, det]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Pi.basisFun_det_apply (v : ι → ι → R) :
     (Pi.basisFun R ι).det v = (Matrix.of v).det := by
   rw [Pi.basisFun_det]
@@ -747,6 +770,7 @@ theorem Pi.basisFun_det_apply (v : ι → ι → R) :
 
 namespace Module.Basis
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If we fix a background basis `e`, then for any other basis `v`, we can characterise the
 coordinates provided by `v` in terms of determinants relative to `e`. -/
 theorem det_smul_mk_coord_eq_det_update {v : ι → M} (hli : LinearIndependent R v)
@@ -762,6 +786,7 @@ theorem det_smul_mk_coord_eq_det_update {v : ι → M} (hli : LinearIndependent
   · rw [mk_coord_apply_ne hik, mul_zero, eq_comm]
     exact e.det.map_eq_zero_of_eq _ (by simp [hik]) hik
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a basis is multiplied columnwise by scalars `w : ι → Rˣ`, then the determinant with respect
 to this basis is multiplied by the product of the inverse of these scalars. -/
 theorem det_unitsSMul (e : Basis ι R M) (w : ι → Rˣ) :
@@ -774,11 +799,13 @@ theorem det_unitsSMul (e : Basis ι R M) (w : ι → Rˣ) :
   convert! Matrix.det_mul_column (fun i => (↑(w i)⁻¹ : R)) fun i j => e.repr (f j) i
   simp [← Finset.prod_inv_distrib]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The determinant of a basis constructed by `unitsSMul` is the product of the given units. -/
 @[simp]
 theorem det_unitsSMul_self (w : ι → Rˣ) : e.det (e.unitsSMul w) = ∏ i, (w i : R) := by
   simp [det_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The determinant of a basis constructed by `isUnitSMul` is the product of the given units. -/
 @[simp]
 theorem det_isUnitSMul {w : ι → R} (hw : ∀ i, IsUnit (w i)) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Basic.lean
index f6e875d4f..f078a60e2 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Basic.lean
@@ -176,6 +176,7 @@ theorem Module.one_le_rank_iff : 1 ≤ Module.rank R M ↔ ∃ f : R →ₗ[R] M
   · exact ⟨f ∘ₗ _, by apply hf.comp (LinearEquiv.piUnique R ..).symm.injective⟩
   · exact ⟨f ∘ₗ _, hf.comp (LinearEquiv.piUnique R ..).injective⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Module.rank_eq_zero_of_not_faithfulSMul (h : ¬ FaithfulSMul R M) : Module.rank R M = 0 := by
   contrapose! h
   obtain ⟨f, hf⟩ := by rwa [← Cardinal.one_le_iff_ne_zero, one_le_rank_iff] at h
@@ -249,6 +250,7 @@ theorem rank_eq_of_equiv_equiv (i : R → R') (j : M ≃+ M₁)
 end
 end Semiring
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- TODO: prove that nontrivial commutative semirings satisfy the strong rank condition,
 following *Free sets and free subsemimodules in a semimodule* by Yi-Jia Tan, Theorem 3.2.
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Constructions.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Constructions.lean
index b3f30440e..c7db4e09e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Constructions.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Constructions.lean
@@ -48,6 +48,7 @@ section Quotient
 variable [Ring R] [CommRing S] [AddCommGroup M] [AddCommGroup M'] [AddCommGroup M₁]
 variable [Module R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem LinearIndependent.sumElim_of_quotient
     {M' : Submodule R M} {ι₁ ι₂} {f : ι₁ → M'} (hf : LinearIndependent R f) (g : ι₂ → M)
@@ -604,6 +605,7 @@ theorem sumQuot_repr_left (i : m) :
     (sumQuot bW bQ).repr (bW i) = Finsupp.single (Sum.inl i) 1 := by
   rw [← Module.Basis.apply_eq_iff, sumQuot_inl]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem sumQuot_repr_inl (w : W) (i : m) :
     (sumQuot bW bQ).repr w (Sum.inl i) = bW.repr w i := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Free.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Free.lean
index 0f0b6dcf8..99a672166 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Free.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Free.lean
@@ -385,6 +385,7 @@ theorem _root_.OrzechProperty.bijective_of_surjective_of_finrank_le
 variable {R : Type*} [CommSemiring R] [StrongRankCondition R]
     {M : Type*} [AddCommMonoid M] [Module R M] [Module.Free R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem _root_.LinearMap.existsUnique_eq_smul_id_of_finrank_eq_one
     (d1 : Module.finrank R M = 1) (u : M →ₗ[R] M) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/RankNullity.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/RankNullity.lean
index b3575ffea..e96c64c24 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/RankNullity.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/RankNullity.lean
@@ -187,6 +187,7 @@ theorem exists_linearIndependent_pair_of_one_lt_rank [IsDomain R] [StrongRankCon
   rw [this] at hy
   exact ⟨y, hy⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem Submodule.exists_smul_notMem_of_rank_lt {N : Submodule R M}
     (h : Module.rank R N < Module.rank R M) : ∃ m : M, ∀ r : R, r ≠ 0 → r • m ∉ N := by
@@ -277,6 +278,7 @@ open Submodule Module
 
 variable [StrongRankCondition R] [Module.Finite R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Submodule.exists_of_finrank_lt (N : Submodule R M) (h : finrank R N < finrank R M) :
     ∃ m : M, ∀ r : R, r ≠ 0 → r • m ∉ N := by
   obtain ⟨s, hs, hs'⟩ :=
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Basic.lean
index 4cb0e2591..c85f92225 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Basic.lean
@@ -24,6 +24,7 @@ public section
 
 open Submodule
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem rank_quotient_eq_of_le_torsion {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
     {M' : Submodule R M} (hN : M' ≤ torsion R M) : Module.rank R (M ⧸ M') = Module.rank R M :=
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Finite.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Finite.lean
index edeb022d8..cccb40e4c 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Finite.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Finite.lean
@@ -15,6 +15,7 @@ public import Mathlib.LinearAlgebra.Dimension.Finite
 
 public section
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A torsion module has rank zero. -/
 theorem Module.IsTorsion.rank_eq_zero {R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
     [Nontrivial R] (h : IsTorsion R M) : Module.rank R M = 0 := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/DirectSum/Finsupp.lean b/mathlib4/Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
index d20ee7574..2afe4b844 100644
--- a/mathlib4/Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
@@ -124,6 +124,7 @@ lemma finsuppRight_symm_apply_single (i : ι) (m : M) (n : N) :
       m ⊗ₜ[R] Finsupp.single i n := by
   simp [LinearEquiv.symm_apply_eq]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma finsuppLeft_smul' (s : S) (t : (ι →₀ M) ⊗[R] N) :
     finsuppLeft R S M N ι (s • t) = s • finsuppLeft R S M N ι t := by
@@ -190,6 +191,7 @@ lemma finsuppScalarRight_symm_apply_single (i : ι) (m : M) :
       m ⊗ₜ[R] (Finsupp.single i 1) := by
   simp [finsuppScalarRight, finsuppRight_symm_apply_single]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem finsuppScalarRight_smul (s : S) (t) :
     finsuppScalarRight R S M ι (s • t) = s • finsuppScalarRight R S M ι t := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dual/Basis.lean b/mathlib4/Mathlib/LinearAlgebra/Dual/Basis.lean
index 12aa75e01..d4e5deda3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dual/Basis.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dual/Basis.lean
@@ -57,6 +57,7 @@ theorem toDual_apply (i j : ι) : b.toDual (b i) (b j) = if i = j then 1 else 0
   rw [toDual, constr_basis b, constr_basis b]
   simp only [eq_comm]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem toDual_linearCombination_left (f : ι →₀ R) (i : ι) :
@@ -65,6 +66,7 @@ theorem toDual_linearCombination_left (f : ι →₀ R) (i : ι) :
   simp_rw [map_smul, LinearMap.smul_apply, toDual_apply, smul_eq_mul, mul_boole,
     Finset.sum_ite_eq', Finsupp.if_mem_support]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem toDual_linearCombination_right (f : ι →₀ R) (i : ι) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean
index 8ce80686f..a751fe2fa 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean
@@ -178,6 +178,7 @@ theorem Module.Dual.eval_naturality (f : M₁ →ₗ[R] M₂) :
     f.dualMap.dualMap ∘ₗ eval R M₁ = eval R M₂ ∘ₗ f := by
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma Dual.apply_one_mul_eq (f : Dual R R) (r : R) :
     f 1 * r = f r := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Eigenspace/Matrix.lean b/mathlib4/Mathlib/LinearAlgebra/Eigenspace/Matrix.lean
index 574408a89..31b548fb4 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Eigenspace/Matrix.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Eigenspace/Matrix.lean
@@ -96,6 +96,7 @@ lemma iSup_eigenspace_toLin'_diagonal_eq_top :
     ⨆ μ, eigenspace (diagonal d).toLin' μ = ⊤ :=
   iSup_eigenspace_toLin_diagonal_eq_top d <| Pi.basisFun R n
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 lemma maxGenEigenspace_toLin_diagonal_eq_eigenspace [IsDomain R] :
diff --git a/mathlib4/Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean b/mathlib4/Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
index c615bc9bd..321794e8b 100644
--- a/mathlib4/Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
@@ -40,6 +40,7 @@ namespace ExteriorAlgebra
 
 open CliffordAlgebra hiding ι
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Build a map out of the exterior algebra given a collection of alternating maps acting on each
 exterior power -/
 def liftAlternating : (∀ i, M [⋀^Fin i]→ₗ[R] N) →ₗ[R] ExteriorAlgebra R M →ₗ[R] N := by
@@ -85,6 +86,7 @@ theorem liftAlternating_one (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) :
   dsimp [liftAlternating]
   rw [foldl_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem liftAlternating_algebraMap (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) (r : R) :
     liftAlternating (R := R) (M := M) (N := N) f (algebraMap _ (ExteriorAlgebra R M) r) =
@@ -108,6 +110,7 @@ theorem liftAlternating_comp_ιMulti {n : ℕ} (f : ∀ i, M [⋀^Fin i]→ₗ[R
     (liftAlternating (R := R) (M := M) (N := N) f).compAlternatingMap (ιMulti R n) = f n :=
   AlternatingMap.ext <| liftAlternating_apply_ιMulti f
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem liftAlternating_comp (g : N →ₗ[R] N') (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) :
     (liftAlternating (R := R) (M := M) (N := N') fun i => g.compAlternatingMap (f i)) =
@@ -135,6 +138,7 @@ theorem liftAlternating_ιMulti :
   | ι_mul _ _ hx => simp_rw [liftAlternating_ι_mul, ιMulti_succ_curryLeft, liftAlternating_comp,
       LinearMap.comp_apply, LinearMap.mulLeft_apply, hx]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `ExteriorAlgebra.liftAlternating` is an equivalence. -/
 @[simps apply symm_apply]
 def liftAlternatingEquiv : (∀ i, M [⋀^Fin i]→ₗ[R] N) ≃ₗ[R] ExteriorAlgebra R M →ₗ[R] N where
diff --git a/mathlib4/Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean
index 8a8923035..a7047bb64 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean
@@ -124,6 +124,7 @@ theorem exists_relation_sum_zero_pos_coefficient_of_finrank_succ_lt_card [Finite
 
 end
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- In a vector space with dimension 1, each set `{v}` is a basis for `v ≠ 0`. -/
 @[simps repr_apply]
diff --git a/mathlib4/Mathlib/LinearAlgebra/FiniteSpan.lean b/mathlib4/Mathlib/LinearAlgebra/FiniteSpan.lean
index bf11e9854..8358e6c31 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FiniteSpan.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FiniteSpan.lean
@@ -20,6 +20,7 @@ public section
 open Set Function
 open Submodule (span)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A linear equivalence which preserves a finite spanning set must have finite order. -/
 lemma LinearEquiv.isOfFinOrder_of_finite_of_span_eq_top_of_mapsTo
diff --git a/mathlib4/Mathlib/LinearAlgebra/Finsupp/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/Finsupp/Defs.lean
index 51d89abaf..6e9bd8fdc 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Finsupp/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Finsupp/Defs.lean
@@ -107,6 +107,7 @@ theorem lhom_ext' ⦃φ ψ : (α →₀ M) →ₛₗ[σ₁₂] N⦄ (h : ∀ a,
 def lapply (a : α) : (α →₀ M) →ₗ[R] M :=
   { Finsupp.applyAddHom a with map_smul' := fun _ _ => rfl }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance [Nonempty α] [FaithfulSMul R M] : FaithfulSMul R (α →₀ M) :=
   .of_injective (Finsupp.lsingle <| Classical.arbitrary _) (Finsupp.single_injective _)
 
@@ -327,6 +328,7 @@ namespace Module.End
 
 variable (ι : Type*) {R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `M` is an `R`-module and `ι` is a type, then an additive endomorphism of `M` that
 commutes with all `R`-endomorphisms of `M` gives rise to an additive endomorphism of `ι →₀ M`
 that commutes with all `R`-endomorphisms of `ι →₀ M`. -/
@@ -348,6 +350,7 @@ that commutes with all `R`-endomorphisms of `ι →₀ M`. -/
 
 variable {ι}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `M` is an `R`-module and `ι` is a nonempty type, then every additive endomorphism
 of `ι →₀ M` that commutes with all `R`-endomorphisms of `ι →₀ M` comes from an additive
 endomorphism of `M` that commutes with all `R`-endomorphisms of `M`.
diff --git a/mathlib4/Mathlib/LinearAlgebra/Finsupp/VectorSpace.lean b/mathlib4/Mathlib/LinearAlgebra/Finsupp/VectorSpace.lean
index ad172b4c2..92ff4d74e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Finsupp/VectorSpace.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Finsupp/VectorSpace.lean
@@ -206,6 +206,7 @@ section Algebra
 
 variable {R S : Type*} [CommRing R] [Ring S] [Algebra R S] {ι : Type*} (B : Basis ι R S)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- For any `r : R`, `s : S`, we have
   `B.repr ((algebra_map R S r) * s) i = r * (B.repr s i) `. -/
 theorem Module.Basis.repr_smul' (i : ι) (r : R) (s : S) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Basic.lean
index 5bfdafe4f..3535cbe1f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Basic.lean
@@ -110,6 +110,7 @@ instance [Nontrivial M] : Nonempty (Module.Free.ChooseBasisIndex R M) :=
 theorem infinite [Infinite R] [Nontrivial M] : Infinite M :=
   (Equiv.infinite_iff (chooseBasis R M).repr.toEquiv).mpr Finsupp.infinite_of_right
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance [Nontrivial M] : FaithfulSMul R M :=
   .of_injective _ (chooseBasis R M).repr.symm.injective
 
@@ -179,6 +180,7 @@ open Finset
 
 variable {S : Type*} [CommRing R] [Ring S] [Algebra R S]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable {R} in
 /-- If `B` is a basis of the `R`-algebra `S` such that `B i = 1` for some index `i`, then
diff --git a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Finite/CardQuotient.lean b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Finite/CardQuotient.lean
index d553504c2..50d63e97c 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Finite/CardQuotient.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Finite/CardQuotient.lean
@@ -28,6 +28,7 @@ section Submodule
 
 variable {M : Type*} [AddCommGroup M] [Module.Free ℤ M] [Module.Finite ℤ M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `e : M ≃ N` be an additive isomorphism (therefore a `ℤ`-linear equiv).
 Then an alternative way to compute the cardinality of the quotient `M ⧸ N` is given by taking
 the determinant of `e`.
diff --git a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Int.lean b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Int.lean
index 4edf34a66..3ae8a4fd3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Int.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Int.lean
@@ -26,6 +26,7 @@ namespace Module.Basis.SmithNormalForm
 
 variable [Fintype ι]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a submodule `N` in Smith normal form of a free `R`-module, its index as an additive
 subgroup is an appropriate power of the cardinality of `R` multiplied by the product of the
diff --git a/mathlib4/Mathlib/LinearAlgebra/FreeModule/PID.lean b/mathlib4/Mathlib/LinearAlgebra/FreeModule/PID.lean
index b58768eeb..459c1090d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FreeModule/PID.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FreeModule/PID.lean
@@ -138,6 +138,7 @@ theorem generator_maximal_submoduleImage_dvd {N O : Submodule R M} (hNO : N ≤
 
 variable [IsDomain R]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The induction hypothesis of `Submodule.basisOfPid` and `Submodule.smithNormalForm`.
 
@@ -422,6 +423,7 @@ namespace Module.Basis.SmithNormalForm
 
 variable {n : ℕ} {N : Submodule R M} (snf : Basis.SmithNormalForm N ι n) (m : N)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma repr_eq_zero_of_notMem_range {i : ι} (hi : i ∉ Set.range snf.f) :
     snf.bM.repr m i = 0 := by
@@ -434,6 +436,7 @@ lemma le_ker_coord_of_notMem_range {i : ι} (hi : i ∉ Set.range snf.f) :
     N ≤ LinearMap.ker (snf.bM.coord i) :=
   fun m hm ↦ snf.repr_eq_zero_of_notMem_range ⟨m, hm⟩ hi
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma repr_apply_embedding_eq_repr_smul {i : Fin n} :
     snf.bM.repr m (snf.f i) = snf.bN.repr (snf.a i • m) i := by
@@ -450,12 +453,14 @@ set_option backward.isDefEq.respectTransparency false in
     Finsupp.mem_support_iff, ite_not, mul_comm, ite_eq_right_iff]
   exact fun a ↦ (mul_eq_zero_of_right _ a).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma repr_comp_embedding_eq_smul :
     snf.bM.repr m ∘ snf.f = snf.a • (snf.bN.repr m : Fin n → R) := by
   ext i
   simp [Pi.smul_apply (snf.a i)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma coord_apply_embedding_eq_smul_coord {i : Fin n} :
     snf.bM.coord (snf.f i) ∘ₗ N.subtype = snf.a i • snf.bN.coord i := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/GeneralLinearGroup/AlgEquiv.lean b/mathlib4/Mathlib/LinearAlgebra/GeneralLinearGroup/AlgEquiv.lean
index 27ba036b5..71de53225 100644
--- a/mathlib4/Mathlib/LinearAlgebra/GeneralLinearGroup/AlgEquiv.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/GeneralLinearGroup/AlgEquiv.lean
@@ -28,6 +28,7 @@ open Module LinearMap LinearEquiv
 variable {K V W : Type*} [Semifield K] [AddCommMonoid V] [Module K V] [Projective K V]
   [AddCommMonoid W] [Module K W] [Projective K W]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given an algebra isomorphism `f : End K V ≃ₐ[K] End K W`, there exists a linear isomorphism `T`
 such that `f` is given by `x ↦ T ∘ₗ x ∘ₗ T.symm`. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/InvariantBasisNumber.lean b/mathlib4/Mathlib/LinearAlgebra/InvariantBasisNumber.lean
index 61512f8a3..b31b5bc89 100644
--- a/mathlib4/Mathlib/LinearAlgebra/InvariantBasisNumber.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/InvariantBasisNumber.lean
@@ -279,6 +279,7 @@ private def induced_map (I : Ideal R) (e : (ι → R) →ₗ[R] ι' → R) :
       rw [← map_sub]
       exact Ideal.map_pi _ _ hab e h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An isomorphism of `R`-modules `R^n ≃ R^m` induces an isomorphism of `R/I`-modules
     `R^n/I^n ≃ R^m/I^m`. -/
 private def inducedEquiv [Fintype ι'] (I : Ideal R) (e : (ι → R) ≃ₗ[R] ι' → R) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean b/mathlib4/Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean
index 300b8a01f..9f0029f3a 100644
--- a/mathlib4/Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean
@@ -491,6 +491,7 @@ lemma linearIndependent_algHom_toLinearMap' (K M L) [CommRing K] [IsDomain K]
     LinearIndependent K (AlgHom.toLinearMap : (M →ₐ[K] L) → M →ₗ[K] L) :=
   (linearIndependent_algHom_toLinearMap K M L).restrict_scalars' K
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma LinearMap.injective_of_linearIndependent {N : Type*} [AddCommGroup N] [Module R N]
     {f : M →ₗ[R] N} {ι : Type*} {v : ι → M}
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/Adjugate.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/Adjugate.lean
index 6f4e185c3..cd2bee239 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/Adjugate.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/Adjugate.lean
@@ -255,6 +255,7 @@ theorem cramer_eq_adjugate_mulVec (A : Matrix n n α) (b : n → α) :
   ext k
   simp [mulVec, dotProduct, mul_comm]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mul_adjugate_apply (A : Matrix n n α) (i j k) :
     A i k * adjugate A k j = cramer Aᵀ (Pi.single k (A i k)) j := by
   rw [← smul_eq_mul, adjugate, of_apply, ← Pi.smul_apply, ← map_smul, ← Pi.single_smul',
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/Basis.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/Basis.lean
index b1078913d..c39d85b4d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/Basis.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/Basis.lean
@@ -83,6 +83,7 @@ theorem toMatrix_update [DecidableEq ι'] (x : M) :
   · rw [h, update_self j x v]
   · rw [update_of_ne h]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The basis constructed by `unitsSMul` has vectors given by a diagonal matrix. -/
 @[simp]
@@ -123,6 +124,7 @@ theorem toLin_toMatrix [Finite ι] [Fintype ι'] [DecidableEq ι'] (v : Basis ι
     Matrix.toLin v e (e.toMatrix v) = LinearMap.id :=
   v.ext fun i => by cases nonempty_fintype ι; rw [toLin_self, id_apply, e.sum_toMatrix_smul_self]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- From a basis `e : ι → M`, build a linear equivalence between families of vectors `v : ι → M`,
 and matrices, making the matrix whose columns are the vectors `v i` written in the basis `e`. -/
 def toMatrixEquiv [Fintype ι] (e : Basis ι R M) : (ι → M) ≃ₗ[R] Matrix ι ι R where
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
index d9cb65f1a..319acb4a4 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
@@ -123,6 +123,7 @@ theorem Matrix.Represents.zero : (0 : Matrix ι ι R).Represents b 0 := by
   delta Matrix.Represents
   rw [map_zero, map_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Matrix.Represents.smul {A : Matrix ι ι R} {f : Module.End R M} (h : A.Represents b f)
     (r : R) : (r • A).Represents b (r • f) := by
   delta Matrix.Represents at h ⊢
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/Rank.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/Rank.lean
index 49063b03a..11e7ebfa9 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/Rank.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/Rank.lean
@@ -344,6 +344,7 @@ theorem eRank_reindex {m₀ : Type um} {n : Type un} [Semiring R] (A : Matrix m
     (en : n ≃ n₀) : eRank (A.reindex em en) = eRank A :=
   eRank_submatrix ..
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The rank of a matrix equals the dimension of the range of the corresponding linear map,
 and is therefore independent of the choice of bases. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/ToLin.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/ToLin.lean
index f5cf502db..af976f5e7 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/ToLin.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/ToLin.lean
@@ -478,6 +478,7 @@ theorem LinearMap.toMatrix'_mul [Fintype m] [DecidableEq m] (f g : (m → R) →
     LinearMap.toMatrix' (f * g) = LinearMap.toMatrix' f * LinearMap.toMatrix' g :=
   LinearMap.toMatrix'_comp f g
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem LinearMap.toMatrix'_algebraMap (x : R) :
@@ -652,6 +653,7 @@ lemma LinearMap.toMatrix_singleton {ι : Type*} [Unique ι] (f : R →ₗ[R] R)
 theorem Matrix.toLin_one : Matrix.toLin v₁ v₁ 1 = LinearMap.id := by
   rw [← LinearMap.toMatrix_id v₁, Matrix.toLin_toMatrix]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem Matrix.toLin_scalar (r : R) : Matrix.toLin v₁ v₁ (scalar n r) = r • LinearMap.id :=
   (LinearMap.toMatrix v₁ v₁).injective (by simp [toMatrix_id, smul_one_eq_diagonal])
@@ -662,6 +664,7 @@ theorem LinearMap.toMatrix_reindexRange [DecidableEq M₁] (f : M₁ →ₗ[R] M
       LinearMap.toMatrix v₁ v₂ f k i := by
   simp_rw [LinearMap.toMatrix_apply, Basis.reindexRange_self, Basis.reindexRange_repr]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem LinearMap.toMatrix_algebraMap (x : R) :
@@ -716,6 +719,7 @@ variable {l m n : Type*} [Fintype n] [DecidableEq n]
 variable {M₁ M₂ : Type*} [AddCommMonoid M₁] [AddCommMonoid M₂] [Module R M₁] [Module R M₂]
 variable (v₁ : Basis n R M₁) (v₂ : Basis m R M₂)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The matrix of `toSpanSingleton R M₂ x` given by bases `v₁` and `v₂` is equal to
 `vecMulVec (v₂.repr x) v₁`. When `v₁ = Module.Basis.singleton`
@@ -724,6 +728,7 @@ theorem LinearMap.toMatrix_toSpanSingleton [Finite m] (v₁ : Basis n R R) (v₂
     (x : M₂) : (toSpanSingleton R M₂ x).toMatrix v₁ v₂ = vecMulVec (v₂.repr x) v₁ := by
   ext; simp [toMatrix_apply, vecMulVec_apply, mul_comm]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 lemma LinearMap.toMatrix_smulRight [Finite m] (f : M₁ →ₗ[R] R) (x : M₂) :
@@ -911,6 +916,7 @@ theorem Matrix.toLin_finTwoProd (a b c d : R) :
         (c • LinearMap.fst R R R + d • LinearMap.snd R R R) :=
   LinearMap.ext <| Matrix.toLin_finTwoProd_apply _ _ _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toMatrix_distrib_mul_action_toLinearMap (x : R) :
     LinearMap.toMatrix v₁ v₁ (DistribSMul.toLinearMap R M₁ x) =
@@ -1002,6 +1008,7 @@ variable {A M n : Type*} [Fintype n] [DecidableEq n]
   [CommSemiring A] [AddCommMonoid M] [Module R M] [Module A M] [Algebra R A] [IsScalarTower R A M]
   (bA : Basis m R A) (bM : Basis n A M)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma _root_.LinearMap.restrictScalars_toMatrix (f : M →ₗ[A] M) :
     (f.restrictScalars R).toMatrix (bA.smulTower' bM) (bA.smulTower' bM) =
@@ -1018,6 +1025,7 @@ variable [Algebra R S] [Algebra S T] [Algebra R T] [IsScalarTower R S T]
 variable {m n : Type*} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n]
 variable (b : Basis m R S) (c : Basis n S T)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem smulTower_leftMulMatrix (x) (ik jk) :
     leftMulMatrix (b.smulTower c) x ik jk =
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/ZMatrix.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/ZMatrix.lean
index ce22815bd..e0dcac1b6 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/ZMatrix.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/ZMatrix.lean
@@ -36,6 +36,7 @@ public lemma diag_pos_of_mul_diagonal_posDef (i : ι) :
   rw [← mul_pos_iff_of_pos_left (hD i)]
   simpa using hA.2 (x := Finsupp.single i 1) (by simp)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A spectral bound result for Z-matrices satisfying a positive-definiteness condition.
 
 It is important because it applies to Cartan matrices, and shows that all (real) eigenvalues must
diff --git a/mathlib4/Mathlib/LinearAlgebra/Multilinear/DFinsupp.lean b/mathlib4/Mathlib/LinearAlgebra/Multilinear/DFinsupp.lean
index 18309fef9..5afa234bd 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Multilinear/DFinsupp.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Multilinear/DFinsupp.lean
@@ -269,6 +269,7 @@ theorem freeDFinsuppEquiv_def (f : Π₀ (_ : (Π i, κ i) × ι'), R) :
       (DFinsupp.domLCongr (R := R) (Equiv.sigmaEquivProd _ _).symm) f) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /--
 When `freeDFinsuppEquiv` is applied to a map with a single value of one the resulting multilinear
diff --git a/mathlib4/Mathlib/LinearAlgebra/PerfectPairing/Restrict.lean b/mathlib4/Mathlib/LinearAlgebra/PerfectPairing/Restrict.lean
index ad8616d8d..471a285f4 100644
--- a/mathlib4/Mathlib/LinearAlgebra/PerfectPairing/Restrict.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/PerfectPairing/Restrict.lean
@@ -83,6 +83,7 @@ variable {S M' N' : Type*}
   [AddCommGroup M'] [Module S M'] [AddCommGroup N'] [Module S N']
   (i : M' →ₗ[S] M) (j : N' →ₗ[S] N)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 private lemma restrictScalars_injective_aux
     (hi : Injective i)
diff --git a/mathlib4/Mathlib/LinearAlgebra/Pi.lean b/mathlib4/Mathlib/LinearAlgebra/Pi.lean
index e213045ff..272b09ad5 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Pi.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Pi.lean
@@ -354,6 +354,7 @@ theorem proj_comp_single (i j : ι) : (proj i).comp (single R φ j) = diag j i :
 
 end
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear map `f` applied to `x : ι → R` can be computed using the image under `f` of elements
 of the canonical basis. -/
 theorem pi_apply_eq_sum_univ [Fintype ι] (f : (ι → R) →ₗ[R] M₂) (x : ι → R) :
@@ -461,6 +462,7 @@ variable [(i : ι) → AddCommMonoid (φ i)] [(i : ι) → Module R (φ i)]
 variable [(i : ι) → AddCommMonoid (ψ i)] [(i : ι) → Module R (ψ i)]
 variable [(i : ι) → AddCommMonoid (χ i)] [(i : ι) → Module R (χ i)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Combine a family of linear equivalences into a linear equivalence of `pi`-types.
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Basic.lean
index b6900cd03..1d7021c2a 100644
--- a/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Basic.lean
@@ -645,6 +645,7 @@ theorem piTensorHomMapFun₂_add (φ ψ : ⨂[R] i, s i →ₗ[R] t i →ₗ[R]
   dsimp [piTensorHomMapFun₂]; ext; simp only [map_add, LinearMap.compMultilinearMap_apply,
     lift.tprod, add_apply, LinearMap.add_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem piTensorHomMapFun₂_smul (r : R) (φ : ⨂[R] i, s i →ₗ[R] t i →ₗ[R] t' i) :
     piTensorHomMapFun₂ (r • φ) = r • piTensorHomMapFun₂ φ := by
@@ -773,6 +774,7 @@ theorem map_reindex_symm (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) (x : 
 
 variable (ι)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local simp] eq_iff_true_of_subsingleton in
 /-- The tensor product over an empty index type `ι` is isomorphic to the base ring. -/
 @[simps symm_apply]
@@ -840,6 +842,7 @@ section tmulEquivDep
 
 variable (N : ι ⊕ ι₂ → Type*) [∀ i, AddCommMonoid (N i)] [∀ i, Module R (N i)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Equivalence between a `TensorProduct` of `PiTensorProduct`s and a single
 `PiTensorProduct` indexed by a `Sum` type. If `N` is a constant family of
diff --git a/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Generators.lean b/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Generators.lean
index 36f51dded..815509585 100644
--- a/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Generators.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Generators.lean
@@ -47,6 +47,45 @@ noncomputable def equivPiTensorComplSingletonTensor (i₀ : ι) :
 
 variable (i₀ : ι)
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`AddCommMonoid (⨂[R] (i₁ : { i // ¬i = i₀ }), M ↑i₁)`
+The companion searches `Module R (⨂[R] (i₁ : { i // ¬i = i₀ }), M ↑i₁)` and the two `PUnit`-indexed
+variants fail in the same way. They are needed by the `rw [dsimp% …]` below, after `Equiv.symm_symm`
+has rewritten the index type to `{ i // ¬i = i₀ }` while the instance arguments in the term stay
+phrased through the equivalence.
+
+The failure happens while applying `@PiTensorProduct.instAddCommMonoid`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type of
+the assigned value do not match at `.instances` transparency. The metavariable's expected type is
+`(i : { i // ¬i = i₀ }) → AddCommMonoid (M ↑i)`, whereas the assigned value
+`fun i ↦ inst✝ ((Equiv.subtypeNeSumPUnit i₀) (Sum.inl i))` has type
+`(i : { i // i ≠ i₀ }) → AddCommMonoid (M ((Equiv.subtypeNeSumPUnit i₀) (Sum.inl i)))`. The
+comparison bottoms out at `i.1 =?= (Equiv.subtypeNeSumPUnit i₀).1 (Sum.inl i)`, i.e. at actually
+computing the equivalence on `Sum.inl i`. Lean falls back to synthesize an instance of the correct
+type, which succeeds, but it returns `fun i ↦ inst✝ ↑i`, which is again not defeq to the assigned
+value, for the same reason. The `respectTransparency false` backward-compatibility flag blocks Lean
+from bumping to implicit, so the comparison happens at `.instances` again.
+
+Validated, but perhaps too invasive, fix: Make all of the following definitions implicit-reducible:
+
+```
+  Equiv.trans
+  Equiv.optionSubtype
+  Equiv.optionEquivSumPUnit
+  Equiv.refl
+  Set.singleton
+  Option.casesOn'
+  Equiv.optionSubtypeNe
+  Sum.elim
+```
+
+Then both backward compatibility options can go: first `respectTransparency false`, then
+`instanceTypes false`.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 lemma equivPiTensorComplSingletonTensor_tprod (i₀ : ι) (m : ∀ i, M i) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Prod.lean b/mathlib4/Mathlib/LinearAlgebra/Prod.lean
index 181a08d69..97e683d25 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Prod.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Prod.lean
@@ -90,6 +90,7 @@ theorem fst_surjective : Function.Surjective (fst R M M₂) := fun x => ⟨(x, 0
 
 theorem snd_surjective : Function.Surjective (snd R M M₂) := fun x => ⟨(0, x), rfl⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The prod of two linear maps is a linear map. -/
 @[simps]
@@ -881,6 +882,7 @@ section Graph
 variable [Semiring R] [AddCommMonoid M] [AddCommMonoid M₂] [AddCommGroup M₃] [AddCommGroup M₄]
   [Module R M] [Module R M₂] [Module R M₃] [Module R M₄] (f : M →ₗ[R] M₂) (g : M₃ →ₗ[R] M₄)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Graph of a linear map. -/
 def graph : Submodule R (M × M₂) where
   carrier := { p | p.2 = f p.1 }
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
index d88d051e3..a2f63cdf3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@@ -536,6 +536,7 @@ section Comp
 variable [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N]
 variable [AddCommMonoid P] [Module R P]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Compose the quadratic map with a linear function on the right. -/
 def comp (Q : QuadraticMap R N P) (f : M →ₗ[R] N) : QuadraticMap R M P where
   toFun x := Q (f x)
@@ -544,10 +545,12 @@ def comp (Q : QuadraticMap R N P) (f : M →ₗ[R] N) : QuadraticMap R M P where
     let ⟨B, h⟩ := Q.exists_companion
     ⟨B.compl₁₂ f f, fun x y => by simp_rw [f.map_add]; exact h (f x) (f y)⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem comp_apply (Q : QuadraticMap R N P) (f : M →ₗ[R] N) (x : M) : (Q.comp f) x = Q (f x) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Compose a quadratic map with a linear function on the left. -/
 @[simps +simpRhs]
 def _root_.LinearMap.compQuadraticMap (f : N →ₗ[R] P) (Q : QuadraticMap R M N) :
@@ -620,6 +623,7 @@ theorem linMulLin_add (f g h : M →ₗ[R] A) : linMulLin f (g + h) = linMulLin
 
 variable {N' : Type*} [AddCommMonoid N'] [Module R N']
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem linMulLin_comp (f g : M →ₗ[R] A) (h : N' →ₗ[R] M) :
     (linMulLin f g).comp h = linMulLin (f.comp h) (g.comp h) :=
@@ -671,6 +675,7 @@ section Semiring
 variable [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N]
 variable {N' : Type*} [AddCommMonoid N'] [Module R N']
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A bilinear map gives a quadratic map by applying the argument twice. -/
 def toQuadraticMap (B : BilinMap R M N) : QuadraticMap R M N where
@@ -678,10 +683,12 @@ def toQuadraticMap (B : BilinMap R M N) : QuadraticMap R M N where
   toFun_smul a x := by simp only [map_smul, LinearMap.smul_apply, smul_smul]
   exists_companion' := ⟨B + LinearMap.flip B, fun x y => by simp [add_add_add_comm, add_comm]⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_apply (B : BilinMap R M N) (x : M) : B.toQuadraticMap x = B x x :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toQuadraticMap_comp_same (B : BilinMap R M N) (f : N' →ₗ[R] M) :
     BilinMap.toQuadraticMap (B.compl₁₂ f f) = B.toQuadraticMap.comp f := rfl
 
@@ -689,17 +696,20 @@ section
 
 variable (R M)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_zero : (0 : BilinMap R M N).toQuadraticMap = 0 :=
   rfl
 
 end
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_add (B₁ B₂ : BilinMap R M N) :
     (B₁ + B₂).toQuadraticMap = B₁.toQuadraticMap + B₂.toQuadraticMap :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_smul [Monoid S] [DistribMulAction S N] [SMulCommClass S R N]
     [SMulCommClass R S N] (a : S)
@@ -710,6 +720,7 @@ section
 
 variable (S R M)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `LinearMap.BilinMap.toQuadraticMap` as an additive homomorphism -/
 @[simps]
 def toQuadraticMapAddMonoidHom : (BilinMap R M N) →+ QuadraticMap R M N where
@@ -717,6 +728,7 @@ def toQuadraticMapAddMonoidHom : (BilinMap R M N) →+ QuadraticMap R M N where
   map_zero' := toQuadraticMap_zero _ _
   map_add' := toQuadraticMap_add
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `LinearMap.BilinMap.toQuadraticMap` as a linear map -/
 @[simps]
 def toQuadraticMapLinearMap [Semiring S] [Module S N] [SMulCommClass S R N] [SMulCommClass R S N] :
@@ -727,6 +739,7 @@ def toQuadraticMapLinearMap [Semiring S] [Module S N] [SMulCommClass S R N] [SMu
 
 end
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_list_sum (B : List (BilinMap R M N)) :
     B.sum.toQuadraticMap = (B.map toQuadraticMap).sum :=
@@ -742,6 +755,7 @@ theorem toQuadraticMap_sum {ι : Type*} (s : Finset ι) (B : ι → (BilinMap R
     (∑ i ∈ s, B i).toQuadraticMap = ∑ i ∈ s, (B i).toQuadraticMap :=
   map_sum (toQuadraticMapAddMonoidHom R M) B s
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_eq_zero {B : BilinMap R M N} :
     B.toQuadraticMap = 0 ↔ B.IsAlt :=
@@ -754,15 +768,18 @@ section Ring
 variable [CommRing R] [AddCommGroup M] [AddCommGroup N] [Module R M] [Module R N]
 variable {B : BilinMap R M N}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_neg (B : BilinMap R M N) : (-B).toQuadraticMap = -B.toQuadraticMap :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_sub (B₁ B₂ : BilinMap R M N) :
     (B₁ - B₂).toQuadraticMap = B₁.toQuadraticMap - B₂.toQuadraticMap :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem polar_toQuadraticMap (x y : M) : polar (toQuadraticMap B) x y = B x y + B y x := by
   simp only [polar, toQuadraticMap_apply, map_add, add_apply, add_assoc, add_comm (B y x) _,
     add_sub_cancel_left, sub_eq_add_neg _ (B y y), add_neg_cancel_left]
@@ -770,6 +787,7 @@ theorem polar_toQuadraticMap (x y : M) : polar (toQuadraticMap B) x y = B x y +
 theorem polarBilin_toQuadraticMap : polarBilin (toQuadraticMap B) = B + flip B :=
   LinearMap.ext₂ polar_toQuadraticMap
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] theorem _root_.QuadraticMap.toQuadraticMap_polarBilin (Q : QuadraticMap R M N) :
     toQuadraticMap (polarBilin Q) = 2 • Q :=
   QuadraticMap.ext fun x => (polar_self _ x).trans <| by simp
@@ -786,6 +804,7 @@ section
 
 variable {N' : Type*} [AddCommGroup N'] [Module R N']
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.QuadraticMap.polarBilin_comp (Q : QuadraticMap R N' N) (f : M →ₗ[R] N') :
     polarBilin (Q.comp f) = LinearMap.compl₁₂ (polarBilin Q) f f :=
   LinearMap.ext₂ <| fun x y => by simp [polar]
@@ -892,12 +911,14 @@ lemma associated_flip : (associatedHom S Q).flip = associatedHom S Q := by
   simp only [LinearMap.flip_apply, associated_apply, add_comm, sub_eq_add_neg, add_left_comm,
     add_assoc]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem associated_comp {N' : Type*} [AddCommGroup N'] [Module R N'] (f : N' →ₗ[R] M) :
     associatedHom S (Q.comp f) = (associatedHom S Q).compl₁₂ f f := by
   ext
   simp only [associated_apply, comp_apply, map_add, LinearMap.compl₁₂_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem associated_toQuadraticMap (B : BilinMap R M N) (x y : M) :
     associatedHom S B.toQuadraticMap x y = ⅟(2 : Module.End R N) • (B x y + B y x) := by
   simp only [associated_apply, BilinMap.toQuadraticMap_apply, map_add, LinearMap.add_apply,
@@ -920,6 +941,7 @@ theorem associated_eq_self_apply (x : M) : associatedHom S Q x x = Q x := by
     add_smul, one_smul, add_sub_cancel_right, add_sub_cancel_right, two_smul, ← two_smul R,
     invOf_smul_eq_iff, two_smul, two_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toQuadraticMap_associated : (associatedHom S Q).toQuadraticMap = Q :=
   QuadraticMap.ext <| associated_eq_self_apply S Q
 
@@ -1026,6 +1048,7 @@ theorem isOrtho_comm {x y : M} : IsOrtho Q x y ↔ IsOrtho Q y x := by simp_rw [
 
 alias ⟨IsOrtho.symm, _⟩ := isOrtho_comm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.LinearMap.BilinForm.toQuadraticMap_isOrtho [IsCancelAdd R]
     [NoZeroDivisors R] [CharZero R] {B : BilinMap R M R} {x y : M} (h : B.IsSymm) :
     B.toQuadraticMap.IsOrtho x y ↔ B x y = 0 := by
@@ -1161,6 +1184,7 @@ The determinant of the matrix is the discriminant of the quadratic form.
 variable {n : Type w} [Fintype n] [DecidableEq n]
 variable [CommRing R] [AddCommMonoid M] [Module R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `M.toQuadraticForm'` is the map `fun x ↦ row x * M * col x` as a quadratic form on `n → R`. -/
 def Matrix.toQuadraticForm' (M : Matrix n n R) : QuadraticForm R (n → R) :=
   LinearMap.BilinMap.toQuadraticMap (Matrix.toLinearMap₂' R M)
@@ -1179,6 +1203,7 @@ section Rn
 def toMatrix' (Q : QuadraticForm R (n → R)) : Matrix n n R :=
   LinearMap.toMatrix₂' R Q.associated
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toMatrix'_smul (a : R) (Q : QuadraticForm R (n → R)) :
     (a • Q).toMatrix' = a • Q.toMatrix' := by
   simp [toMatrix']
@@ -1224,6 +1249,7 @@ lemma toMatrix_eq_toMatrix' (Q : QuadraticForm R (n → R)) :
   simp only [toMatrix, toMatrix']
   exact LinearEquiv.congr_arg rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toMatrix_smul (a : R) (Q : QuadraticForm R N) :
     (a • Q).toMatrix b = a • (Q.toMatrix b) := by
   simp [toMatrix]
@@ -1313,6 +1339,7 @@ section Semiring
 
 variable [CommSemiring R] [AddCommMonoid M] [Module R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 A bilinear form is separating left if the quadratic form it is associated with is anisotropic.
 -/
@@ -1337,6 +1364,7 @@ open Module
 variable {V : Type u} {K : Type v} [Field K] [AddCommGroup V] [Module K V]
 variable [FiniteDimensional K V]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a symmetric bilinear form `B` on some vector space `V` over a field `K`
 in which `2` is invertible, there exists an orthogonal basis with respect to `B`. -/
 theorem exists_orthogonal_basis [hK : Invertible (2 : K)] {B : LinearMap.BilinForm K V}
@@ -1400,6 +1428,7 @@ noncomputable def basisRepr [Finite ι] (Q : QuadraticMap R M N) (v : Basis ι R
     QuadraticMap R (ι → R) N :=
   Q.comp v.equivFun.symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem basisRepr_apply [Fintype ι] {v : Basis ι R M} (Q : QuadraticMap R M N) (w : ι → R) :
     Q.basisRepr v w = Q (∑ i : ι, w i • v i) := by
@@ -1428,6 +1457,7 @@ theorem weightedSumSquares_apply [Monoid S] [DistribMulAction S R] [SMulCommClas
     weightedSumSquares R w v = ∑ i : ι, w i • (v i * v i) :=
   sum_apply _ _ _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- On an orthogonal basis, the basis representation of `Q` is just a sum of squares. -/
 theorem basisRepr_eq_of_iIsOrtho {R M} [CommRing R] [AddCommGroup M] [Module R M]
     [Invertible (2 : R)] (Q : QuadraticForm R M) (v : Basis ι R M)
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basis.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basis.lean
index 7e0dbd832..26b2576ff 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basis.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basis.lean
@@ -91,6 +91,7 @@ theorem toBilin_apply (Q : QuadraticMap R M N) (bm : Basis ι R M) (i j : ι) :
       if i = j then Q (bm i) else if i < j then polar Q (bm i) (bm j) else 0 := by
   simp [toBilin]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem toQuadraticMap_toBilin (Q : QuadraticMap R M N) (bm : Basis ι R M) :
     (Q.toBilin bm).toQuadraticMap = Q := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Dual.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Dual.lean
index 0f63ac84e..3c684214e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Dual.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Dual.lean
@@ -81,6 +81,7 @@ section Semiring
 
 variable [CommSemiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The quadratic form on `Module.Dual R M × M` defined as `Q (f, x) = f x`. -/
 @[simps]
 def dualProd : QuadraticForm R (Module.Dual R M × M) where
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
index b846483cb..7ac7170b0 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
@@ -135,6 +135,7 @@ open QuadraticForm
 
 variable {X Y Z : QuadraticModuleCat.{v} R}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Build a `QuadraticForm.IsometryEquiv` from an isomorphism in the category
 `QuadraticModuleCat R`. -/
 @[simps]
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean
index 9f2013209..c3f369c85 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean
@@ -139,6 +139,7 @@ theorem associated_baseChange [Invertible (2 : A)] (Q : QuadraticForm R M₂) :
   rw [associated_tmul (QuadraticMap.sq (R := A)) Q, associated_sq]
   exact rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem polarBilin_baseChange [Invertible (2 : A)] (Q : QuadraticForm R M₂) :
     polarBilin (Q.baseChange A) = BilinForm.baseChange A (polarBilin Q) := by
   rw [QuadraticForm.baseChange, BilinForm.baseChange, polarBilin_tmul, BilinForm.tmul,
diff --git a/mathlib4/Mathlib/LinearAlgebra/Ray.lean b/mathlib4/Mathlib/LinearAlgebra/Ray.lean
index fc8688918..7280d6e14 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Ray.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Ray.lean
@@ -176,6 +176,7 @@ theorem map (f : M →ₗ[R] N) (h : SameRay R x y) : SameRay R (f x) (f y) :=
     Or.imp (fun hy => by rw [hy, map_zero]) fun ⟨r₁, r₂, hr₁, hr₂, h⟩ =>
       ⟨r₁, r₂, hr₁, hr₂, by rw [← f.map_smul, ← f.map_smul, h]⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The images of two vectors under an injective linear map are on the same ray if and only if the
 original vectors are on the same ray. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Reflection.lean b/mathlib4/Mathlib/LinearAlgebra/Reflection.lean
index 87747700e..8fee78b24 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Reflection.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Reflection.lean
@@ -85,6 +85,7 @@ lemma involutive_preReflection (h : f x = 2) :
     Involutive (preReflection x f) :=
   fun y ↦ by simp [map_sub, h, two_smul, preReflection_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma preReflection_preReflection (g : Dual R M) (h : f x = 2) :
     preReflection (preReflection x f y) (preReflection f (Dual.eval R M x) g) =
@@ -180,6 +181,7 @@ open Int Polynomial.Chebyshev
 
 variable {x y : M} {f g : Dual R M} (hf : f x = 2) (hg : g y = 2)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A formula for $(r_1 r_2)^m z$, where $m$ is a natural number and $z \in M$. -/
 lemma reflection_mul_reflection_pow_apply (m : ℕ) (z : M)
@@ -274,6 +276,7 @@ lemma reflection_mul_reflection_zpow (m : ℤ)
   ext z
   simpa using reflection_mul_reflection_zpow_apply hf hg m z t ht
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A formula for $(r_1 r_2)^m x$, where $m$ is an integer. This is the special case of
 `Module.reflection_mul_reflection_zpow_apply` with $z = x$. -/
@@ -316,6 +319,7 @@ lemma reflection_mul_reflection_pow_apply_self (m : ℕ)
       ((S R m).eval t + (S R (m - 1)).eval t) • x + ((S R (m - 1)).eval t * -g x) • y :=
   mod_cast reflection_mul_reflection_zpow_apply_self hf hg m t ht
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A formula for $r_2 (r_1 r_2)^m x$, where $m$ is an integer. -/
 lemma reflection_mul_reflection_mul_reflection_zpow_apply_self (m : ℤ)
@@ -339,6 +343,7 @@ end
 
 /-! ### Lemmas used to prove uniqueness results for root data -/
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- See also `Module.Dual.eq_of_preReflection_mapsTo'` for a variant of this lemma which
 applies when `Φ` does not span.
@@ -406,6 +411,7 @@ lemma Dual.eq_of_preReflection_mapsTo' [CharZero R] [IsDomain R] [IsTorsionFree
 variable {y}
 variable {g : Dual R M}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Composite of reflections in "parallel" hyperplanes is a shear (special case). -/
 lemma reflection_reflection_iterate
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Base.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Base.lean
index 6c7285ca5..42bf8f27b 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Base.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Base.lean
@@ -149,6 +149,7 @@ lemma span_coroot_support :
     span R (P.coroot '' b.support) = P.corootSpan R :=
   b.flip.span_root_support
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 open Finsupp in
 lemma eq_one_or_neg_one_of_mem_support_of_smul_mem_aux [Finite ι]
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/BaseExists.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/BaseExists.lean
index 6e805b6ec..f0b920886 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/BaseExists.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/BaseExists.lean
@@ -196,6 +196,7 @@ lemma eq_baseOf_iff (s : Set ι) (f : M →+ ℚ)
 
 variable [P.IsReduced]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma baseOf_root_eq_baseOf_coroot_aux
     (f : M →+ ℚ) (g : N →+ ℚ) (hf : ∀ i, f (P.root i) ≠ 0)
     (hfg : ∀ i, 0 < f (P.root i) ↔ 0 < g (P.coroot i)) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Basic.lean
index 86ea43557..90e03cde6 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Basic.lean
@@ -127,6 +127,7 @@ protected lemma ext [CharZero R] [IsDomain R] [IsTorsionFree R M]
   · exact hr ▸ he ▸ P₂.coroot_root_two i
   · exact hr ▸ he ▸ P₂.mapsTo_reflection_root i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma coroot_eq_coreflection_of_root_eq' [CharZero R] [IsDomain R] [IsTorsionFree R M]
     (p : M →ₗ[R] N →ₗ[R] R) [p.IsPerfPair]
     (root : ι ↪ M)
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/CartanMatrix.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/CartanMatrix.lean
index e3e3fa962..8e626b806 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/CartanMatrix.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/CartanMatrix.lean
@@ -331,6 +331,7 @@ variable {ι₂ M₂ N₂ : Type*} [AddCommGroup M₂] [Module R M₂] [AddCommG
   {P₂ : RootPairing ι₂ R M₂ N₂} [P₂.IsCrystallographic] (b₂ : P₂.Base)
   (e : b.support ≃ b₂.support)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma apply_mem_range_root_of_cartanMatrixEq
     (f : M ≃ₗ[R] M₂) (hf : ∀ i : b.support, f (P.root i) = P₂.root (e i))
     (m : M) (hm : m ∈ range P.root)
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Defs.lean
index abb003188..c09911566 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Defs.lean
@@ -209,6 +209,7 @@ lemma pairing_eq_add_of_root_eq_add {i j k l : ι} (h : P.root k = P.root i + P.
     P.pairing k l = P.pairing i l + P.pairing j l := by
   simp only [← root_coroot_eq_pairing, h, map_add, LinearMap.add_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable {P} in
 lemma pairing_eq_add_of_root_eq_smul_add_smul
@@ -399,6 +400,7 @@ lemma pairing_reflectionPerm_self_right (i j : ι) :
   rw [pairing, ← reflectionPerm_coroot, root_coroot_eq_pairing, pairing_same, two_smul,
     sub_add_cancel_left, map_neg, root_coroot_eq_pairing]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The indexing set of a root pairing carries an involutive negation, corresponding to the negation
 of a root / coroot. -/
@@ -411,6 +413,7 @@ of a root / coroot. -/
       sub_neg_eq_add, map_smul, smul_add]
     module
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ne_neg [NeZero (2 : R)] [IsDomain R] :
     letI := P.indexNeg
     i ≠ -i := by
@@ -499,6 +502,7 @@ lemma pairing_smul_coroot_eq (k : ι) (hij : P.reflectionPerm i = P.reflectionPe
     simp only [← coroot_reflectionPerm, hij]
   simpa only [coreflection_apply_coroot, sub_right_inj] using h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma two_nsmul_reflection_eq_of_perm_eq (hij : P.reflectionPerm i = P.reflectionPerm j) :
     2 • ⇑(P.reflection i) = 2 • P.reflection j := by
   ext x
@@ -524,6 +528,7 @@ lemma reflectionPerm_eq_reflectionPerm_iff_of_isSMulRegular (h2 : IsSMulRegular
   replace h2 : IsSMulRegular (M → M) 2 := IsSMulRegular.pi fun _ ↦ h2
   exact h2 <| P.two_nsmul_reflection_eq_of_perm_eq i j h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma reflectionPerm_eq_reflectionPerm_iff_of_span :
     P.reflectionPerm i = P.reflectionPerm j ↔
@@ -568,6 +573,7 @@ def IsOrthogonal : Prop := pairing P i j = 0 ∧ pairing P j i = 0
 lemma isOrthogonal_symm : IsOrthogonal P i j ↔ IsOrthogonal P j i := by
   simp only [IsOrthogonal, and_comm]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isOrthogonal_comm (h : IsOrthogonal P i j) : Commute (P.reflection i) (P.reflection j) := by
   rw [commute_iff_eq]
@@ -599,6 +605,7 @@ lemma IsOrthogonal.coreflection_apply_right (h : IsOrthogonal P j i) :
     P.coreflection j (P.coroot i) = P.coroot i :=
   h.flip.reflection_apply_right
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma isFixedPt_reflection_of_isOrthogonal {s : Set ι} (hj : ∀ i ∈ s, P.IsOrthogonal j i)
     {x : M} (hx : x ∈ span R (P.root '' s)) :
     IsFixedPt (P.reflection j) x := by
@@ -657,6 +664,7 @@ section Map
 
 variable {ι₂ M₂ N₂ : Type*} [AddCommGroup M₂] [Module R M₂] [AddCommGroup N₂] [Module R N₂]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Push forward a root pairing along linear equivalences, also reindexing the (co)roots. -/
 protected def map (e : ι ≃ ι₂) (f : M ≃ₗ[R] M₂) (g : N ≃ₗ[R] N₂) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean
index 80834459f..28c7e8cfc 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean
@@ -271,6 +271,7 @@ lemma rootFormIn_self_smul_coroot (i : ι) :
   intro j hj
   rw [← P.algebraMap_pairingIn S, IsScalarTower.algebraMap_smul, ← mul_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma prod_rootFormIn_smul_coroot_mem_range_PolarizationIn (i : ι) :
     (∏ j : ι, P.RootFormIn S (P.rootSpanMem S j) (P.rootSpanMem S j)) • P.coroot i ∈
       LinearMap.range (P.PolarizationIn S) := by
@@ -300,12 +301,14 @@ lemma corootForm_self_smul_root (i : ι) :
     (P.CorootForm (P.coroot i) (P.coroot i)) • P.root i = 2 • P.CoPolarization (P.coroot i) :=
   rootForm_self_smul_coroot (P.flip) i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma four_nsmul_coPolarization_compl_polarization_apply_root (i : ι) :
     (4 • P.CoPolarization ∘ₗ P.Polarization) (P.root i) =
     (P.RootForm (P.root i) (P.root i) * P.CorootForm (P.coroot i) (P.coroot i)) • P.root i := by
   rw [LinearMap.smul_apply, LinearMap.comp_apply, show 4 = 2 * 2 from rfl, mul_smul, ← map_nsmul,
     ← rootForm_self_smul_coroot, map_smul, smul_comm, ← corootForm_self_smul_root, smul_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma four_smul_rootForm_sq_eq_coxeterWeight_smul (i j : ι) :
     4 • (P.RootForm (P.root i) (P.root j)) ^ 2 = P.coxeterWeight i j •
       (P.RootForm (P.root i) (P.root i) * P.RootForm (P.root j) (P.root j)) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/G2.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/G2.lean
index 5e1faecae..26f771a99 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/G2.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/G2.lean
@@ -294,6 +294,7 @@ lemma threeShortAddLongRoot_eq :
   simp [threeShortAddLongRoot, threeShortAddLong, reflection_apply_root]
   module
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma threeShortAddTwoLongRoot_eq :
     threeShortAddTwoLongRoot P = (3 : R) • shortRoot P + (2 : R) • longRoot P := by
   simp [threeShortAddTwoLongRoot, threeShortAddTwoLong, reflection_apply_root]
@@ -401,6 +402,7 @@ variable (i : ι)
   · simp only [twoShortAddLongRoot_eq, one_smul, add_left_inj]
     norm_cast
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma pairingIn_twoShortAddLong_right :
     P.pairingIn ℤ i (twoShortAddLong P) =
       2 * P.pairingIn ℤ i (short P) + 3 * P.pairingIn ℤ i (long P) := by
@@ -431,6 +433,7 @@ omit [Finite ι] [IsDomain R] in
   · simp only [threeShortAddLongRoot_eq, one_smul, add_left_inj]
     norm_cast
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma pairingIn_threeShortAddLong_right :
     P.pairingIn ℤ i (threeShortAddLong P) =
       P.pairingIn ℤ i (short P) + P.pairingIn ℤ i (long P) := by
@@ -461,6 +464,7 @@ omit [Finite ι] [IsDomain R] in
   · simp only [threeShortAddTwoLongRoot_eq]
     norm_cast
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma pairingIn_threeShortAddTwoLong_right :
     P.pairingIn ℤ i (threeShortAddTwoLong P) =
       P.pairingIn ℤ i (short P) + 2 * P.pairingIn ℤ i (long P) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/Nondegenerate.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/Nondegenerate.lean
index d260e9d12..798510948 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/Nondegenerate.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/Nondegenerate.lean
@@ -95,6 +95,7 @@ instance instIsAnisotropicOfIsCrystallographic [CharZero R] [P.IsCrystallographi
   ne_zero := IsAnisotropic.rootForm_root_ne_zero
   isOrthogonal_reflection := P.rootForm_reflection_reflection_apply
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma smul_coroot_eq_of_root_add_root_eq [P.IsAnisotropic] [IsDomain R] [IsTorsionFree R N]
     {i j k : ι} {m n : R} (hk : m • P.root i + n • P.root j = P.root k) :
     letI Q :=
@@ -376,6 +377,7 @@ lemma coroot_eq_polarizationEquiv_apply_root (i : ι) :
     smul_smul, mul_div_cancel₀ _ h₀]
   norm_cast
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma polarizationEquiv_symm_apply_coroot {i : ι} :
     P.PolarizationEquiv.symm (P.coroot i) = (2 / P.RootForm (P.root i) (P.root i)) • P.root i := by
   simp [coroot_eq_polarizationEquiv_apply_root]
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/OfBilinear.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/OfBilinear.lean
index 6d82bce06..8ddfc09be 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/OfBilinear.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/OfBilinear.lean
@@ -53,6 +53,7 @@ lemma of_dvd_two [IsCancelMulZero R] [NeZero (2 : R)] (hx : B x x ∣ 2) :
 
 variable (hx : IsReflective B x)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The coroot attached to a reflective vector. -/
 def coroot : M →ₗ[R] R where
   toFun y := (hx.2 y).choose
@@ -80,6 +81,7 @@ lemma smul_coroot : B x x • coroot B hx = 2 • B x := by
 lemma coroot_apply_self : coroot B hx x = 2 :=
   hx.regular.left <| by simp [mul_comm _ (B x x)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isOrthogonal_reflection (hSB : LinearMap.IsSymm B) :
     B.IsOrthogonal (Module.reflection (coroot_apply_self B hx)) := by
@@ -114,6 +116,7 @@ namespace RootPairing
 
 open LinearMap IsReflective
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The root pairing given by all reflective vectors for a bilinear form. -/
 def ofBilinear [IsReflexive R M] (B : M →ₗ[R] M →ₗ[R] R) (hNB : LinearMap.Nondegenerate B)
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Reduced.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Reduced.lean
index ac36cc6b8..d806c1254 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Reduced.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Reduced.lean
@@ -230,6 +230,7 @@ lemma pairing_neg_two_neg_two_iff :
 
 variable [Module.IsTorsionFree R N]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma pairing_one_four_iff' (h2 : IsSMulRegular R (2 : R)) :
     P.pairing i j = 1 ∧ P.pairing j i = 4 ↔ P.root j = (2 : R) • P.root i := by
   have : IsAddTorsionFree M := .of_isTorsionFree R M
diff --git a/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Basic.lean
index e7b501403..053ae87e3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Basic.lean
@@ -807,6 +807,7 @@ end Nondegenerate
 
 namespace BilinForm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma apply_smul_sub_smul_sub_eq [CommRing R] [AddCommGroup M] [Module R M]
     (B : LinearMap.BilinForm R M) (x y : M) :
@@ -899,6 +900,7 @@ lemma nondegenerate_restrict_iff_disjoint_ker (hs : ∀ x, 0 ≤ B x x) (hB : B.
 
 variable [IsTorsionFree R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Strict **Cauchy-Schwarz** is equivalent to linear independence for positive definite forms. -/
 lemma apply_mul_apply_lt_iff_linearIndependent (hp : ∀ x, x ≠ 0 → 0 < B x x) (x y : M) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Star.lean b/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Star.lean
index b2fc28e05..5b0d35c00 100644
--- a/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Star.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Star.lean
@@ -22,6 +22,7 @@ variable {R M n : Type*} [CommSemiring R] [StarRing R] [AddCommMonoid M] [Module
   [Fintype n] [DecidableEq n]
   {B : M →ₗ⋆[R] M →ₗ[R] R} (b : Basis n R M)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma LinearMap.isSymm_iff_basis {ι : Type*} (b : Basis ι R M) :
     IsSymm B ↔ ∀ i j, star (B (b i) (b j)) = B (b j) (b i) where
diff --git a/mathlib4/Mathlib/LinearAlgebra/Span/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Span/Basic.lean
index 1d7829afd..495383ecc 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Span/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Span/Basic.lean
@@ -776,6 +776,7 @@ theorem toSpanSingleton_isIdempotentElem_iff {e : R} :
     smul_eq_mul, mul_assoc]
   exact ⟨fun h ↦ by conv_rhs => rw [← one_mul e, ← h, one_mul], fun h _ ↦ by rw [h]⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isIdempotentElem_map_one_iff {f : Module.End R R} :
     IsIdempotentElem (f 1) ↔ IsIdempotentElem f := by
   rw [IsIdempotentElem, ← smul_eq_mul, ← map_smul, smul_eq_mul, mul_one, IsIdempotentElem,
diff --git a/mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean
index 451ec1d3b..ecfcbd5c4 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean
@@ -461,6 +461,7 @@ theorem mem_span_singleton {y : M} : x ∈ R ∙ y ↔ ∃ a : R, a • y = x :=
 theorem le_span_singleton_iff {s : Submodule R M} {v₀ : M} :
     s ≤ R ∙ v₀ ↔ ∀ v ∈ s, ∃ r : R, r • v₀ = v := by simp_rw [SetLike.le_def, mem_span_singleton]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem eq_span_singleton_of_surjective {s : Submodule R M}
     {f : R →ₗ[R] s} (hf : Surjective f) : s = span R {(f 1 : M)} := by
   refine le_antisymm (fun x hx ↦ mem_span_singleton.mpr ?_)
@@ -681,6 +682,7 @@ theorem Module.isPrincipal_submodule_iff {p : Submodule R M} :
     have ⟨r, hr⟩ := mem_span_singleton.mp (ha.le x.2)
     exact mem_span_singleton.mpr ⟨r, Subtype.ext hr⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem Module.IsPrincipal.of_surjective (f : M →ₗ[R] M₂) (hf : Function.Surjective f)
     [IsPrincipal R M] : IsPrincipal R M₂ where
diff --git a/mathlib4/Mathlib/LinearAlgebra/SpecialLinearGroup.lean b/mathlib4/Mathlib/LinearAlgebra/SpecialLinearGroup.lean
index b5c47a967..9d66df79e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/SpecialLinearGroup.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/SpecialLinearGroup.lean
@@ -238,6 +238,7 @@ theorem _root_.SpecialLinearGroup.smul_def (g : SpecialLinearGroup R V) (v : V)
 theorem _root_.SpecialLinearGroup.toLinearEquiv_eq_coe (g : SpecialLinearGroup R V) :
     g.toLinearEquiv = (g : V ≃ₗ[R] V) := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : SMulCommClass (SpecialLinearGroup R V) R V where
   smul_comm g a v := by
     simp [SpecialLinearGroup.smul_def]
@@ -355,6 +356,7 @@ theorem center_eq_bot_of_finrank_le_one (h : Module.finrank R V ≤ 1) :
     (Subgroup.centerCongr (Matrix.SpecialLinearGroup.toLin_equiv b)).toEquiv] at this
   exact Subgroup.eq_bot_of_subsingleton _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mem_center_iff {g : SpecialLinearGroup R V} :
     g ∈ Subgroup.center (SpecialLinearGroup R V) ↔
       ∃ (r : R), r ^ (Module.finrank R V) = 1 ∧
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean b/mathlib4/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
index 2a9db1c01..56a8b0e36 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
@@ -55,6 +55,7 @@ theorem toTensorAlgebra_gMul {i j} (a : (⨂[R]^i) M) (b : (⨂[R]^j) M) :
   rw [List.ofFn_comp' _ (TensorAlgebra.ι R), List.ofFn_comp' _ (TensorAlgebra.ι R),
     List.ofFn_comp' _ (TensorAlgebra.ι R), ← List.map_append, List.ofFn_fin_append]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toTensorAlgebra_galgebra_toFun (r : R) :
     TensorPower.toTensorAlgebra (DirectSum.GAlgebra.toFun (R := R) (A := fun n => ⨂[R]^n M) r) =
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorPower/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/TensorPower/Basic.lean
index 49e1a4518..113a7e369 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorPower/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorPower/Basic.lean
@@ -146,6 +146,7 @@ theorem tprod_mul_tprod {na nb} (a : Fin na → M) (b : Fin nb → M) :
   apply funext
   apply Fin.addCases <;> simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem one_mul {n} (a : ⨂[R]^n M) : cast R M (zero_add n) (ₜ1 ₜ* a) = a := by
   rw [gMul_def, gOne_def]
   induction a using PiTensorProduct.induction_on with
@@ -158,6 +159,7 @@ theorem one_mul {n} (a : ⨂[R]^n M) : cast R M (zero_add n) (ₜ1 ₜ* a) = a :
   | add x y hx hy =>
     rw [TensorProduct.tmul_add, map_add, map_add, hx, hy]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mul_one {n} (a : ⨂[R]^n M) : cast R M (add_zero _) (a ₜ* ₜ1) = a := by
   rw [gMul_def, gOne_def]
   induction a using PiTensorProduct.induction_on with
@@ -209,16 +211,19 @@ theorem algebraMap₀_eq_smul_one (r : R) : (algebraMap₀ r : (⨂[R]^0) M) = r
 theorem algebraMap₀_one : (algebraMap₀ 1 : (⨂[R]^0) M) = ₜ1 :=
   (algebraMap₀_eq_smul_one 1).trans (one_smul _ _)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem algebraMap₀_mul {n} (r : R) (a : ⨂[R]^n M) :
     cast R M (zero_add _) (algebraMap₀ r ₜ* a) = r • a := by
   rw [gMul_eq_coe_linearMap, algebraMap₀_eq_smul_one, LinearMap.map_smul₂, map_smul,
     ← gMul_eq_coe_linearMap, one_mul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mul_algebraMap₀ {n} (r : R) (a : ⨂[R]^n M) :
     cast R M (add_zero _) (a ₜ* algebraMap₀ r) = r • a := by
   rw [gMul_eq_coe_linearMap, algebraMap₀_eq_smul_one, map_smul, map_smul, ← gMul_eq_coe_linearMap,
     mul_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem algebraMap₀_mul_algebraMap₀ (r s : R) :
     cast R M (add_zero _) (algebraMap₀ r ₜ* algebraMap₀ s) = algebraMap₀ (r * s) := by
   rw [← smul_eq_mul, map_smul]
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
index 1b7efccfc..fdcdb8edb 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
@@ -186,6 +186,7 @@ noncomputable irreducible_def gradedMul :
   refine (assoc R _ _ _).toLinearMap ∘ₗ .rTensor _ ?_ ∘ₗ (assoc R _ _ _).symm.toLinearMap
   exact (gradedComm _ _ _).toLinearMap
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem tmul_of_gradedMul_of_tmul (j₁ i₂ : ι)
     (a₁ : ⨁ i, 𝒜 i) (b₁ : ℬ j₁) (a₂ : 𝒜 i₂) (b₂ : ⨁ i, ℬ i) :
     gradedMul R 𝒜 ℬ (a₁ ⊗ₜ lof R _ ℬ j₁ b₁) (lof R _ 𝒜 i₂ a₂ ⊗ₜ b₂) =
@@ -236,6 +237,7 @@ theorem gradedMul_one (x : (⨁ i, 𝒜 i) ⊗[R] (⨁ i, ℬ i)) :
   -- Note: https://github.com/leanprover-community/mathlib4/pull/8386 had to specialize `map_one` to avoid timeouts.
   simpa only [RingHom.map_one, one_smul] using! gradedMul_algebraMap 𝒜 ℬ x 1
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 theorem gradedMul_assoc (x y z : DirectSum _ 𝒜 ⊗[R] DirectSum _ ℬ) :
@@ -256,6 +258,7 @@ theorem gradedMul_assoc (x y z : DirectSum _ 𝒜 ⊗[R] DirectSum _ ℬ) :
   congr 2
   abel
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 theorem gradedComm_gradedMul (x y : DirectSum _ 𝒜 ⊗[R] DirectSum _ ℬ) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
index 538cd230b..3f2c3e74f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
@@ -178,6 +178,7 @@ instance instRing : Ring (𝒜 ᵍ⊗[R] ℬ) where
   mul_zero x := by simp_rw [mul_def, map_zero]
   zero_mul x := by simp_rw [mul_def, LinearMap.map_zero₂]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The characterization of this multiplication on partially homogeneous elements. -/
 theorem tmul_coe_mul_coe_tmul {j₁ i₂ : ι} (a₁ : A) (b₁ : ℬ j₁) (a₂ : 𝒜 i₂) (b₂ : B) :
     (a₁ ᵍ⊗ₜ[R] (b₁ : B) * (a₂ : A) ᵍ⊗ₜ[R] b₂ : 𝒜 ᵍ⊗[R] ℬ) =
@@ -273,6 +274,7 @@ def includeLeft : A →ₐ[R] 𝒜 ᵍ⊗[R] ℬ where
   toRingHom := includeLeftRingHom 𝒜 ℬ
   commutes' _ := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The algebra morphism `B →ₐ[R] A ⊗[R] B` sending `b` to `1 ⊗ₜ b`. -/
 @[simps!]
 def includeRight : B →ₐ[R] (𝒜 ᵍ⊗[R] ℬ) :=
@@ -294,6 +296,7 @@ lemma algebraMap_def' (r : R) : algebraMap R (𝒜 ᵍ⊗[R] ℬ) r = 1 ᵍ⊗
 
 variable {C} [Ring C] [Algebra R C]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 /-- The forwards direction of the universal property; an algebra morphism out of the graded tensor
 product can be assembled from maps on each component that (anti)commute on pure elements of the
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
index 065aa4006..dad8b00be 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
@@ -204,6 +204,7 @@ noncomputable def lTensor.toFun (hfg : Exact f g) :
     rw [LinearMap.range_le_iff_comap, ← LinearMap.ker_comp,
       ← lTensor_comp, hfg.linearMap_comp_eq_zero, lTensor_zero, ker_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The inverse map in `lTensor.equiv_of_rightInverse` (computably, given a right inverse) -/
 noncomputable def lTensor.inverse_of_rightInverse {h : P → N} (hfg : Exact f g)
@@ -312,6 +313,7 @@ noncomputable def rTensor.toFun (hfg : Exact f g) :
     rw [range_le_iff_comap, ← ker_comp, ← rTensor_comp,
       hfg.linearMap_comp_eq_zero, rTensor_zero, ker_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The inverse map in `rTensor.equiv_of_rightInverse` (computably, given a right inverse) -/
 noncomputable def rTensor.inverse_of_rightInverse {h : P → N} (hfg : Exact f g)
diff --git a/mathlib4/Mathlib/LinearAlgebra/Trace.lean b/mathlib4/Mathlib/LinearAlgebra/Trace.lean
index 15937293e..bcbbfb16d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Trace.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Trace.lean
@@ -268,6 +268,7 @@ theorem trace_comp_comm' (f : M →ₗ[R] N) (g : N →ₗ[R] M) :
   simp only [llcomp_apply', compr₂_apply, flip_apply] at h
   exact h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma trace_smulRight (f : M →ₗ[R] R) (x : M) :
     trace R M (f.smulRight x) = f x := by
@@ -360,6 +361,7 @@ lemma isNilpotent_trace_of_isNilpotent {f : M →ₗ[R] M} (hf : IsNilpotent f)
   apply Matrix.isNilpotent_trace_of_isNilpotent
   simpa
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma trace_comp_eq_mul_of_commute_of_isNilpotent [IsReduced R] {f g : Module.End R M}
     (μ : R) (h_comm : Commute f g) (hg : IsNilpotent (g - algebraMap R _ μ)) :
     trace R M (f ∘ₗ g) = μ * trace R M f := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Transvection/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Transvection/Basic.lean
index 6fa4b3ef8..aa7d7a33d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Transvection/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Transvection/Basic.lean
@@ -95,6 +95,7 @@ theorem of_right_eq_zero (f : Dual R V) :
   ext
   simp [transvection]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem comp_smul_smul {f : Dual R V} {v : V} {r s : R} :
     transvection f (r • v) ∘ₗ transvection f (s • v) =
       transvection f ((r + s + s * f v * r) • v) := by
@@ -102,6 +103,7 @@ theorem comp_smul_smul {f : Dual R V} {v : V} {r s : R} :
   simp only [LinearMap.comp_apply, apply, map_add, map_smul, add_assoc]
   simp only [smul_add, ← mul_smul, ← add_smul, ← mul_add (f x), mul_assoc]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem eq_id_of_finrank_le_one
     {R V : Type*} [CommSemiring R] [AddCommMonoid V] [Module R V]
     [Free R V] [Module.Finite R V] [StrongRankCondition R]
@@ -122,6 +124,7 @@ theorem eq_id_of_finrank_le_one
     have : x = ∑ i, b.repr x i • b i := (b.sum_equivFun x).symm
     rwa [Finset.sum_eq_single_of_mem i (Finset.mem_univ i) (by grind)] at this
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem congr {W : Type*} [AddCommMonoid W] [Module R W]
     (f : Dual R V) (v : V) (e : V ≃ₗ[R] W) :
     e ∘ₗ (transvection f v) ∘ₗ e.symm = transvection (f ∘ₗ e.symm) (e v) := by
@@ -292,6 +295,7 @@ theorem transvection_mem_dilatransvections {f : Dual R V} {v : V} (hfv : f v = 0
 theorem one_mem_dilatransvections : 1 ∈ dilatransvections R V :=
   refl_mem_dilatransvections
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem symm_mem_dilatransvections_iff {e : V ≃ₗ[R] V} :
     e.symm ∈ dilatransvections R V ↔ e ∈ dilatransvections R V := by
@@ -555,6 +559,7 @@ section Field
 
 variable {K : Type*} {V : Type*} [Field K] [AddCommGroup V] [Module K V]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Determinant of transvections, over a field.
 
 See `LinearMap.Transvection.det` for the general result. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Transvection/Generation.lean b/mathlib4/Mathlib/LinearAlgebra/Transvection/Generation.lean
index fefe9a9ef..2b493f990 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Transvection/Generation.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Transvection/Generation.lean
@@ -298,6 +298,7 @@ private theorem apply_notMem_sup_of_linearIndependent {u : V}
     grind [smul_sub, sub_smul, one_smul, map_smul]
   aesop
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 omit [Module.Finite K V] in
 variable {e} in
 /-- If `e.fixedReduce` is not a homothety, then there are a linear form `f` and
@@ -340,6 +341,7 @@ private theorem exists_dual_of_fixedReduce_ne_smul
   rw [← LinearIndependent.pair_smul_smul_iff (Ne.isUnit hfu).inv (Ne.isUnit hfu).inv] at hu
   simpa only [← LinearMap.map_smul, ← LinearEquiv.map_smul, ← v_def] using hu
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable {e} in
 /-- Auxiliary lemma for the second non-exceptional case in Dieudonné's theorem:
 with the notation of the proof of
diff --git a/mathlib4/Mathlib/MeasureTheory/Function/Jacobian.lean b/mathlib4/Mathlib/MeasureTheory/Function/Jacobian.lean
index fe7664d02..1e5c41fbd 100644
--- a/mathlib4/Mathlib/MeasureTheory/Function/Jacobian.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Function/Jacobian.lean
@@ -280,6 +280,7 @@ to the approximating linear map.
 -/
 
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `f` be a function which is sufficiently close (in the Lipschitz sense) to a given linear
 map `A`. Then it expands the volume of any set by at most `m` for any `m > det A`. -/
 theorem addHaar_image_le_mul_of_det_lt (A : E →L[ℝ] E) {m : ℝ≥0}
@@ -457,6 +458,7 @@ theorem mul_le_addHaar_image_of_lt_det (A : E →L[ℝ] E) {m : ℝ≥0}
   -- and our choice of `δ`.
   exact hδ₀ _ _ ((hf'.to_inv h1δ).mono_num h2δ.le)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a differentiable function `f` is approximated by a linear map `A` on a set `s`, up to `δ`,
 then at almost every `x` in `s` one has `‖f' x - A‖ ≤ δ`. -/
 theorem _root_.ApproximatesLinearOn.norm_fderiv_sub_le {A : E →L[ℝ] E} {δ : ℝ≥0}
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/Bochner/L1.lean b/mathlib4/Mathlib/MeasureTheory/Integral/Bochner/L1.lean
index f8ae4c1ce..0848d3309 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/Bochner/L1.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/Bochner/L1.lean
@@ -589,6 +589,7 @@ theorem integral_sub (f g : α →₁[μ] E) : integral (f - g) = integral f - i
   simp only [integral]
   exact map_sub integralCLM f g
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[integral_simps]
 theorem integral_smul (c : 𝕜) (f : α →₁[μ] E) : integral (c • f) = c • integral f := by
   rw [integral_eq' 𝕜 f, integral_eq' 𝕜 (c • f), map_smul (integralCLM' 𝕜) c f]
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/CircleAverage.lean b/mathlib4/Mathlib/MeasureTheory/Integral/CircleAverage.lean
index 33e0e2d18..3cbf10623 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/CircleAverage.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/CircleAverage.lean
@@ -313,6 +313,7 @@ theorem circleAverage_nonneg_of_nonneg {c : ℂ} {R : ℝ} {f : ℂ → ℝ}
 ## Commutativity with Linear Maps
 -/
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Circle averages commute with continuous linear maps. -/
 theorem _root_.ContinuousLinearMap.circleAverage_comp_comm [CompleteSpace E] (L : E →L[ℝ] F)
     {f : ℂ → E} (hf : CircleIntegrable f c R) :
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/FinMeasAdditive.lean b/mathlib4/Mathlib/MeasureTheory/Integral/FinMeasAdditive.lean
index 0920a1eeb..4aa707f79 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/FinMeasAdditive.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/FinMeasAdditive.lean
@@ -487,6 +487,7 @@ theorem setToSimpleFunc_sub (T : Set α → E →L[ℝ] F) (h_add : FinMeasAddit
   refine hg (-x) ?_
   simp [hx_ne]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem setToSimpleFunc_smul_real (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T) (c : ℝ)
     {f : α →ₛ E} (hf : Integrable f μ) : setToSimpleFunc T (c • f) = c • setToSimpleFunc T f :=
   calc
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean b/mathlib4/Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean
index 3a73e6791..cf9ca77a2 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean
@@ -280,6 +280,7 @@ noncomputable def rieszContent (Λ : C_c(X, ℝ≥0) →ₗ[ℝ≥0] ℝ≥0) :
 lemma rieszContent_ne_top {K : Compacts X} : rieszContent Λ K ≠ ⊤ := by
   simp [rieszContent, ne_eq, not_false_eq_true]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma contentRegular_rieszContent : (rieszContent Λ).ContentRegular := by
   intro K
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/SetToL1.lean b/mathlib4/Mathlib/MeasureTheory/Integral/SetToL1.lean
index cfc8c8c87..238a3285f 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/SetToL1.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/SetToL1.lean
@@ -500,6 +500,7 @@ theorem setToL1_smul_left' (hT : DominatedFinMeasAdditive μ T C)
   apply setToL1_unique hT' (A := c • setToL1 hT) _ f
   simp [setToL1_eq_setToL1SCLM, setToL1SCLM_smul_left' c hT hT' h_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem setToL1_smul (hT : DominatedFinMeasAdditive μ T C)
     (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜) (f : α →₁[μ] E) :
     setToL1 hT (c • f) = c • setToL1 hT f := by
diff --git a/mathlib4/Mathlib/MeasureTheory/Measure/CharacteristicFunction/TaylorExpansion.lean b/mathlib4/Mathlib/MeasureTheory/Measure/CharacteristicFunction/TaylorExpansion.lean
index e11fe18fb..fa39fe30c 100644
--- a/mathlib4/Mathlib/MeasureTheory/Measure/CharacteristicFunction/TaylorExpansion.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Measure/CharacteristicFunction/TaylorExpansion.lean
@@ -66,6 +66,7 @@ lemma continuous_charFun : Continuous (charFun μ) := by
   refine contDiff_zero.1 (contDiff_charFun ?_)
   simpa using by fun_prop
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem iteratedFDeriv_charFun {n : ℕ} {t : E} (hint : MemLp id n μ) (x : Fin n → E) :
     iteratedFDeriv ℝ n (charFun μ) t x = I ^ n * ∫ y, (∏ i, ⟪y, x i⟫) * exp (⟪y, t⟫ * I) ∂μ := by
   have h : innerₗ E = (innerSL ℝ).toLinearMap₁₂ := rfl
diff --git a/mathlib4/Mathlib/MeasureTheory/Measure/Haar/Extension.lean b/mathlib4/Mathlib/MeasureTheory/Measure/Haar/Extension.lean
index 39f6ec2c5..1e661c6ee 100644
--- a/mathlib4/Mathlib/MeasureTheory/Measure/Haar/Extension.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Measure/Haar/Extension.lean
@@ -148,6 +148,7 @@ theorem pushforward_mono {f g : CompactlySupportedContinuousMap B ℝ} (h : f 
 
 variable [MeasurableSpace C] [BorelSpace C] (μC : Measure C) [hμC : IsHaarMeasure μC]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `φ : A →* B` and `ψ : B →* C` define a short exact sequence of topological groups, then we
 can integrate a continuous compactly supported function on `B` by integrating over `A` and `C`. -/
 @[to_additive /-- If `φ : A →+ B` and `ψ : B →+ C` define a short exact sequence of additive
@@ -162,11 +163,17 @@ noncomputable def integrate : CompactlySupportedContinuousMap B E →ₗ[ℝ] E
     rw [map_smul]
     exact integral_smul x (H.pushforward μA f)
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 theorem integrate_apply (f : CompactlySupportedContinuousMap B E) :
     H.integrate μA μC f = ∫ c, pushforward H μA f c ∂μC :=
   rfl
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 theorem integrate_mono {f g : CompactlySupportedContinuousMap B ℝ} (h : f ≤ g) :
     integrate H μA μC f ≤ integrate H μA μC g :=
@@ -175,6 +182,9 @@ theorem integrate_mono {f g : CompactlySupportedContinuousMap B ℝ} (h : f ≤
 
 variable [T2Space B] [MeasurableSpace B] [BorelSpace B]
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `φ : A →* B` and `ψ : B →* C` define a short exact sequence of topological groups, then we
 can define a Haar measure on `B` induced by the Haar measures on `A` and `C`. -/
 @[to_additive /-- If `φ : A →+ B` and `ψ : B →+ C` define a short exact sequence of additive
@@ -183,15 +193,24 @@ and `C`. -/]
 noncomputable def inducedMeasure : Measure B :=
   RealRMK.rieszMeasure ⟨integrate H μA μC, fun _ _ ↦ integrate_mono H μA μC⟩
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 instance inducedMeasure_regular : (inducedMeasure H μA μC).Regular :=
   RealRMK.regular_rieszMeasure _
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 theorem integral_inducedMeasure (f : CompactlySupportedContinuousMap B ℝ) :
     ∫ b : B, f b ∂(inducedMeasure H μA μC) = integrate H μA μC f := by
   apply RealRMK.integral_rieszMeasure
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 instance isHaarMeasure_inducedMeasure : IsHaarMeasure (inducedMeasure H μA μC) where
   lt_top_of_isCompact K hK := by
@@ -230,6 +249,9 @@ instance isHaarMeasure_inducedMeasure : IsHaarMeasure (inducedMeasure H μA μC)
     exact (pullback H ⟨f, hf2⟩ _).continuous.integral_pos_of_hasCompactSupport_nonneg_nonzero
       (pullback H ⟨f, hf2⟩ _).hasCompactSupport (fun x ↦ (hf4 _).1) ha
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- If `φ : A →* B` and `ψ : B →* C` define a short exact sequence of topological groups, and if
 `ψ` is injective on an open set `U`, then the induced measure on `U` is bounded above by
diff --git a/mathlib4/Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean b/mathlib4/Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
index 76ce2932f..38b6b4435 100644
--- a/mathlib4/Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
@@ -54,6 +54,7 @@ theorem mem_parallelepiped_iff (v : ι → E) (x : E) :
     x ∈ parallelepiped v ↔ ∃ t ∈ Icc (0 : ι → ℝ) 1, x = ∑ i, t i • v i := by
   simp [parallelepiped, eq_comm]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem parallelepiped_basis_eq (b : Basis ι ℝ E) :
     parallelepiped b = {x | ∀ i, b.repr x i ∈ Set.Icc 0 1} := by
diff --git a/mathlib4/Mathlib/ModelTheory/Arithmetic/Presburger/Semilinear/Basic.lean b/mathlib4/Mathlib/ModelTheory/Arithmetic/Presburger/Semilinear/Basic.lean
index f310d3887..2aad3f4ee 100644
--- a/mathlib4/Mathlib/ModelTheory/Arithmetic/Presburger/Semilinear/Basic.lean
+++ b/mathlib4/Mathlib/ModelTheory/Arithmetic/Presburger/Semilinear/Basic.lean
@@ -558,6 +558,7 @@ private theorem fract_add_of_mem_closure {x y} (hy : y ∈ closure hs.basisSet)
   rw [map_add, ← sub_add_eq_add_sub]
   simp [-nsmul_eq_mul, ← hs.basis_apply, Finsupp.single_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 private theorem fract_mem_fundamentalDomain (x) : hs.fract x ∈ hs.fundamentalDomain := by
   classical
diff --git a/mathlib4/Mathlib/ModelTheory/Types.lean b/mathlib4/Mathlib/ModelTheory/Types.lean
index 8f9efd01e..457a59c75 100644
--- a/mathlib4/Mathlib/ModelTheory/Types.lean
+++ b/mathlib4/Mathlib/ModelTheory/Types.lean
@@ -237,6 +237,33 @@ def realizedTypes (α : Type w) : Set (T.CompleteType α) :=
 
 section
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`(L.lhomWithConstants α).IsExpansionOn ↑(ModelType.reduct (L.lhomWithConstants α)
+(M.subtheoryModel ⋯))`
+It is needed by the `@Formula.realize_equivSentence_symm_con` application below, which passes
+`M.struc` explicitly.
+
+The failure happens while applying `@LHom.isExpansionOn_reduct`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type of
+the assigned value do not match at `.instances` transparency. The metavariable's expected type is
+`L[[α]].Structure ↑(ModelType.reduct (L.lhomWithConstants α) (M.subtheoryModel ⋯))`, whereas the
+supplied `M.struc` has type `L[[α]].Structure ↑M`. The comparison bottoms out at
+`ModelType.reduct (L.lhomWithConstants α) (M.subtheoryModel ⋯) =?= M`, which would require
+`ModelType.reduct` and `ModelType.subtheoryModel` to unfold; both are plain semireducible `def`s and
+therefore do not unfold at the `.instances` transparency that instance search runs at. Lean falls
+back to synthesize an instance of the correct type, but that synthesis fails as well: its only
+candidate `@ModelType.struc` needs to unify `T` with a metavariable of type `L[[α]].Theory`, and
+`L[[α]].Theory` and `L.Theory` do not even agree at `.default`.
+
+Potential fix: mark `ModelType.reduct` and `ModelType.subtheoryModel`
+implicit-reducible and replace `M.struc` with `cast rfl M.struc`, so that it gets the correct type.
+The `cast rfl` there is a quick and dirty way of ensuring that the `Structure` instance has the
+expected type.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 theorem exists_modelType_is_realized_in (p : T.CompleteType α) :
     ∃ M : Theory.ModelType.{u, v, max u v w} T, p ∈ T.realizedTypes M α := by
diff --git a/mathlib4/Mathlib/NumberTheory/ClassNumber/Finite.lean b/mathlib4/Mathlib/NumberTheory/ClassNumber/Finite.lean
index 3d9bd5728..19d1df1be 100644
--- a/mathlib4/Mathlib/NumberTheory/ClassNumber/Finite.lean
+++ b/mathlib4/Mathlib/NumberTheory/ClassNumber/Finite.lean
@@ -70,6 +70,7 @@ theorem normBound_pos : 0 < normBound abv bS := by
   refine lt_of_lt_of_le (abv.pos hijk) (Finset.le_max' _ _ ?_)
   exact Finset.mem_image.mpr ⟨⟨i, j, k⟩, Finset.mem_univ _, rfl⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If the `R`-integral element `a : S` has coordinates `≤ y` with respect to some basis `b`,
 its norm is less than `normBound abv b * y ^ dim S`. -/
 theorem norm_le (a : S) {y : ℤ} (hy : ∀ k, abv (bS.repr a k) ≤ y) :
@@ -185,6 +186,7 @@ open Real
 
 attribute [-instance] Real.decidableEq
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- We can approximate `a / b : L` with `q / r`, where `r` has finitely many options for `L`. -/
 theorem exists_mem_finsetApprox (a : S) {b} (hb : b ≠ (0 : R)) :
diff --git a/mathlib4/Mathlib/NumberTheory/ModularForms/LevelOne/DimensionFormula.lean b/mathlib4/Mathlib/NumberTheory/ModularForms/LevelOne/DimensionFormula.lean
index d64e0c83b..b8eb2bc27 100644
--- a/mathlib4/Mathlib/NumberTheory/ModularForms/LevelOne/DimensionFormula.lean
+++ b/mathlib4/Mathlib/NumberTheory/ModularForms/LevelOne/DimensionFormula.lean
@@ -220,6 +220,7 @@ private lemma eq_zero_of_pow_eq_smul {p p4 p6 : PowerSeries ℂ} {c4 c6 : ℂ}
     grind
   grind [pow_eq_zero_iff, zero_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma weight_two_qExpansion_eq_zero (f : ModularForm 𝒮ℒ 2) : qExpansion 1 f = 0 := by
   obtain ⟨c4, hc4⟩ : ∃ c4, c4 • E₄ = f.mul f :=
     (finrank_eq_one_iff_of_nonzero' E₄ (E_ne_zero _ ⟨2, rfl⟩)).mp
diff --git a/mathlib4/Mathlib/NumberTheory/NumberField/CanonicalEmbedding/NormLeOne.lean b/mathlib4/Mathlib/NumberTheory/NumberField/CanonicalEmbedding/NormLeOne.lean
index 22ee702d4..6f3742779 100644
--- a/mathlib4/Mathlib/NumberTheory/NumberField/CanonicalEmbedding/NormLeOne.lean
+++ b/mathlib4/Mathlib/NumberTheory/NumberField/CanonicalEmbedding/NormLeOne.lean
@@ -531,6 +531,7 @@ theorem norm_expMapBasis_ne_zero (x : realSpace K) :
     mixedEmbedding.norm (mixedSpaceOfRealSpace (expMapBasis x)) ≠ 0 :=
   norm_expMapBasis x ▸ pow_ne_zero _ (Real.exp_ne_zero _)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped Classical in
 theorem logMap_expMapBasis (x : realSpace K) :
     logMap (mixedSpaceOfRealSpace (expMapBasis x)) ∈
diff --git a/mathlib4/Mathlib/NumberTheory/NumberField/Cyclotomic/Basic.lean b/mathlib4/Mathlib/NumberTheory/NumberField/Cyclotomic/Basic.lean
index 2b3facbfa..3a3adda3c 100644
--- a/mathlib4/Mathlib/NumberTheory/NumberField/Cyclotomic/Basic.lean
+++ b/mathlib4/Mathlib/NumberTheory/NumberField/Cyclotomic/Basic.lean
@@ -428,6 +428,7 @@ lemma prime_norm_toInteger_sub_one_of_prime_ne_two' [hcycl : IsCyclotomicExtensi
   replace hζ : IsPrimitiveRoot ζ (p ^ (0 + 1)) := by simpa using hζ
   exact hζ.prime_norm_toInteger_sub_one_of_prime_ne_two hodd
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- In a `p ^ (k + 1)`-th cyclotomic extension of `ℚ `, we have that `ζ` is not congruent to an
   integer modulo `p` if `p ^ (k  + 1) ≠ 2`. -/
 theorem not_exists_int_prime_dvd_sub_of_prime_pow_ne_two
diff --git a/mathlib4/Mathlib/NumberTheory/NumberField/Ideal/Asymptotics.lean b/mathlib4/Mathlib/NumberTheory/NumberField/Ideal/Asymptotics.lean
index ae19ab8ba..5fd464b75 100644
--- a/mathlib4/Mathlib/NumberTheory/NumberField/Ideal/Asymptotics.lean
+++ b/mathlib4/Mathlib/NumberTheory/NumberField/Ideal/Asymptotics.lean
@@ -70,6 +70,7 @@ private def tendsto_norm_le_and_mk_eq_div_atTop_aux₂ :
   · rintro ⟨⟨hx₁, ⟨x, hx₂, rfl⟩⟩, hx₃⟩
     exact ⟨(toMixed K).symm (mixedEmbedding K x), ⟨⟨hx₁, hx₃⟩, ⟨(x : K), by simp [hx₂], rfl⟩⟩, rfl⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (C) in
 /--
 The limit of the number of nonzero integral ideals of norm `≤ s` in a fixed class `C` of the
diff --git a/mathlib4/Mathlib/NumberTheory/Padics/Measure/Basic.lean b/mathlib4/Mathlib/NumberTheory/Padics/Measure/Basic.lean
index f8a2f46b2..99d254570 100644
--- a/mathlib4/Mathlib/NumberTheory/Padics/Measure/Basic.lean
+++ b/mathlib4/Mathlib/NumberTheory/Padics/Measure/Basic.lean
@@ -131,6 +131,7 @@ section Prod
 
 -- note we define `contractSnd` first, because `f.curry` only works one way round
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Send a measure `ν` on `Y` and a function `f` on `X × Y` to the function on `X` given by
 `x ↦ ν (f (x, ·))`, or more suggestively, `x ↦ ∫ f(x, y) dμ(y)`. -/
 def contractSnd : D(Y, R) →ₗ[R] C(X × Y, R) →ₗ[R] C(X, R) :=
@@ -186,6 +187,7 @@ def prodMk : D(X, R) →ₗ[R] D(Y, R) →ₗ[R] D(X × Y, R) :=
 @[simp] lemma prodMk_apply (f : C(X × Y, R)) :
   prodMk μ ν f = ν (μ.contractFst f) := (rfl)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- On functions of the form `(x, y) ↦ f x * g y`, the measure `prodMk μ ν` agrees with the
 algebraic tensor product of `μ` and `ν`. -/
 lemma prodMk_prod_apply (f : C(X, R)) (g : C(Y, R)) :
@@ -209,6 +211,7 @@ lemma prodMk'_apply (f : C(X × Y, R)) : (μ.prodMk' ν) f = μ (ν.contractSnd
 lemma prodMk'_flip (f : C(X × Y, R)) :
     (μ.prodMk' ν) f = (ν.prodMk μ) (f.comp ContinuousMap.prodSwap) := (rfl)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma prodMk'_prod_apply (f : C(X, R)) (g : C(Y, R)) :
     prodMk' μ ν ((f.comp .fst) * (g.comp .snd)) = μ f * ν g := by
   simp only [prodMk'_apply, mul_comm (μ f) (ν g), ← smul_eq_mul, ← map_smul]
diff --git a/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean b/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
index cdd182a69..407520045 100644
--- a/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
+++ b/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
@@ -35,8 +35,42 @@ variable {p : ℕ} [Fact p.Prime]
 
 open NNReal WithZero UniformSpace
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+```
+MonoidWithZeroHomClass ((MonoidWithZeroHom.ofClass Valued.v).ValueGroup₀ →*₀
+  WithZero (Multiplicative ℤ)) (MonoidWithZeroHom.ofClass Valued.v).ValueGroup₀
+  (WithZero (Multiplicative ℤ))
+```
+It is needed in the second bullet below, whose final `simp_all` otherwise leaves the goal
+`1 ≤ padicValRat p (x.ofVal - y.ofVal) + (embedding ↑γ).log` unsolved.
+
+The failure happens while applying `@MonoidWithZeroHom.monoidWithZeroHomClass`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `MulZeroOneClass (MonoidWithZeroHom.ofClass Valued.v).ValueGroup₀`, whereas the assigned value
+`instMulZeroOneClass` has type
+`MulZeroOneClass (WithZero ↥(MonoidWithZeroHom.ofClass Valued.v).valueGroup)`.
+Lean falls back to synthesize an instance of the correct type, which
+succeeds, but it returns a `instMulZeroOneClass` instance that is not defeq to the assigned one
+at `.implicit` transparency.
+
+Potential fix: make the following definitions implicit-reducible:
+
+```
+  Rat.padicValuation
+  Valuation.restrict
+  coe
+  exp
+```
+
+Then both backward compatibility options can go.
+-/
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.isDefEq.respectTransparency.outParams false in
+set_option backward.isDefEq.instanceTypes false in
 open MonoidWithZeroHom.ValueGroup₀ in
 lemma isUniformInducing_cast_withVal : IsUniformInducing ((Rat.castHom ℚ_[p]).comp
     (WithVal.equiv (Rat.padicValuation p)).toRingHom) := by
diff --git a/mathlib4/Mathlib/NumberTheory/RamificationInertia/Basic.lean b/mathlib4/Mathlib/NumberTheory/RamificationInertia/Basic.lean
index 9195283f3..151da2816 100644
--- a/mathlib4/Mathlib/NumberTheory/RamificationInertia/Basic.lean
+++ b/mathlib4/Mathlib/NumberTheory/RamificationInertia/Basic.lean
@@ -180,6 +180,7 @@ theorem FinrankQuotientMap.span_eq_top [IsDomain R] [IsDomain S] [Algebra K L] [
 
 variable [hRK : IsFractionRing R K]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `V` be a vector space over `K = Frac(R)`, `S / R` a ring extension
 and `V'` a module over `S`. If `b`, in the intersection `V''` of `V` and `V'`,
 is linear independent over `S` in `V'`, then it is linear independent over `R` in `V`.
diff --git a/mathlib4/Mathlib/Probability/Distributions/Binomial.lean b/mathlib4/Mathlib/Probability/Distributions/Binomial.lean
index 7c124b3f6..dcba34c6d 100644
--- a/mathlib4/Mathlib/Probability/Distributions/Binomial.lean
+++ b/mathlib4/Mathlib/Probability/Distributions/Binomial.lean
@@ -127,6 +127,7 @@ lemma binomial_real_self (n : ℕ) (p : I) :
 lemma map_cast_binomial_real_self [MeasurableSingletonClass R] [CharZero R] (n : ℕ) (p : I) :
     Bin(R, n, p).real {(n : R)} = p ^ n := by simp [map_cast_binomial_real_singleton]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 @[simp]
 lemma binomial_one_eq_bernoulliMeasure (p : I) :
diff --git a/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean b/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
index 6215a8180..7ae90d5eb 100644
--- a/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
+++ b/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
@@ -60,6 +60,7 @@ lemma IsGaussian.charFunDual_eq' [IsGaussian μ] (L : StrongDual ℝ E) :
   · exact IsGaussian.integrable_id
   · exact IsGaussian.memLp_two_id
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The measure `μ` is Gaussian if and only if there
 exist `m : E` and `f : StrongDual ℝ E →L[ℝ] StrongDual ℝ E →L[ℝ] ℝ`
 satisfying `f.toBilinForm.IsPosSemidef` and `charFunDual μ L = exp (L m * I - f L L / 2)`. -/
diff --git a/mathlib4/Mathlib/RepresentationTheory/Basic.lean b/mathlib4/Mathlib/RepresentationTheory/Basic.lean
index 7713722e9..92ef4e7a9 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Basic.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Basic.lean
@@ -224,6 +224,7 @@ we have `Module k[G] (restrictScalars k k[G] M)`.
 -/
 
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem ofModule_asAlgebraHom_apply_apply (r : k[G])
@@ -493,6 +494,7 @@ end
 variable {k G V : Type*} [CommSemiring k] [Group G] [AddCommMonoid V] [Module k V]
   (ρ : Representation k G V)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma asAlgebraHom_ofMulAction_smul_eq_mul (x y : k[G]) :
     (ofMulAction k G G).asAlgebraHom x y = x * y := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Character.lean b/mathlib4/Mathlib/RepresentationTheory/Character.lean
index 768f3d7f3..422b8227b 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Character.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Character.lean
@@ -101,6 +101,7 @@ theorem char_linHom (g : G) :
 
 variable [Fintype G] [Invertible (Nat.card G : k)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem card_inv_mul_sum_char_eq_finrank :
     (Nat.card G : k)⁻¹ * ∑ g : G, ρ.character g = finrank k (invariants ρ) := by
   have : Invertible (Fintype.card G : k) := by rw [Fintype.card_eq_nat_card]; assumption
@@ -196,6 +197,7 @@ theorem char_linHom (V W : FDRep k G) (g : G) :
 
 variable [Fintype G] [Invertible (Nat.card G : k)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem average_char_eq_finrank_invariants (V : FDRep k G) :
     (Nat.card G : k)⁻¹ * ∑ g : G, V.character g = finrank k (invariants V.ρ) := by
   have : Invertible (Fintype.card G : k) := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Continuous/Basic.lean b/mathlib4/Mathlib/RepresentationTheory/Continuous/Basic.lean
index 81d7d2a93..e20ba486a 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Continuous/Basic.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Continuous/Basic.lean
@@ -576,6 +576,7 @@ def coind₁ (π : ContRepresentation R G V) :
 lemma coind₁_apply_apply (π : ContRepresentation R G V) (g : G) (f : C(G, V)) (x : G) :
     π.coind₁ g f x = π g (f (g⁻¹ * x)) := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The functoriality of `coind₁`. -/
 @[simps]
 def coind₁Map {π₁ : ContRepresentation R G V} {π₂ : ContRepresentation R G W} (f : π₁ →ⁱL π₂) :
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/Functoriality.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/Functoriality.lean
index 69f6b38f9..5e3e0f193 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/Functoriality.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/Functoriality.lean
@@ -46,6 +46,7 @@ theorem congr {f₁ f₂ : G →* H} (h : f₁ = f₂) {φ : res f₁ A ⟶ B} {
   subst h
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a group homomorphism `f : G →* H` and a representation morphism `φ : Res(f)(A) ⟶ B`,
 this is the chain map sending `x : Hⁿ → A` to `(g : Gⁿ) ↦ φ (x (f ∘ g))`. -/
 @[simps! -isSimp f f_hom]
@@ -59,15 +60,18 @@ noncomputable def cochainsMap :
     simpa [inhomogeneousCochains.d_hom_apply, Fin.comp_contractNth, CochainComplex.of.d]
       using! (hom_comm_apply φ _ _).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma cochainsMap_id :
     cochainsMap (MonoidHom.id _) (𝟙 A) = 𝟙 (inhomogeneousCochains A) := by
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma cochainsMap_id_f_hom_eq_compLeft {A B : Rep k G} (f : A ⟶ B) (i : ℕ) :
     ((cochainsMap (MonoidHom.id G) f).f i).hom = f.hom.toLinearMap.compLeft _ := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc]
 lemma cochainsMap_comp {G H K : Type u} [Group G] [Group H]
     [Group K] {A : Rep k K} {B : Rep k H} {C : Rep k G} (f : H →* K) (g : G →* H)
@@ -76,15 +80,18 @@ lemma cochainsMap_comp {G H K : Type u} [Group G] [Group H]
       cochainsMap f φ ≫ cochainsMap g ψ := by
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc]
 lemma cochainsMap_id_comp {A B C : Rep k G} (φ : A ⟶ B) (ψ : B ⟶ C) :
     cochainsMap (MonoidHom.id G) (φ ≫ ψ) =
       cochainsMap (MonoidHom.id G) φ ≫ cochainsMap (MonoidHom.id G) ψ := by
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma cochainsMap_zero : cochainsMap (A := A) (B := B) f 0 = 0 := by rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cochainsMap_f_map_mono (hf : Function.Surjective f) [Mono φ] (i : ℕ) :
     Mono ((cochainsMap f φ).f i) := by
   simpa [ModuleCat.mono_iff_injective] using!
@@ -95,6 +102,7 @@ instance cochainsMap_id_f_map_mono {A B : Rep k G} (φ : A ⟶ B) [Mono φ] (i :
     Mono ((cochainsMap (MonoidHom.id G) φ).f i) :=
   cochainsMap_f_map_mono (MonoidHom.id G) φ (fun x => ⟨x, rfl⟩) i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cochainsMap_f_map_epi (hf : Function.Injective f) [Epi φ] (i : ℕ) :
     Epi ((cochainsMap f φ).f i) := by
   simpa [ModuleCat.epi_iff_surjective] using!
@@ -117,6 +125,7 @@ lemma cochainsMap_congr {f g : G →* H} {φ : res f A ⟶ B} {ψ : res g A ⟶
     cochainsMap f φ = cochainsMap g ψ := by
   subst hfg; congr; ext; simp [hφψ]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma cocyclesMap_id : cocyclesMap (MonoidHom.id G) (𝟙 B) n = 𝟙 _ :=
   HomologicalComplex.cyclesMap_id _ _
@@ -153,6 +162,7 @@ theorem π_map (n : ℕ) :
     π A n ≫ map f φ n = cocyclesMap f φ n ≫ π B n := by
   simp [map, cocyclesMap]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma map_id : map (MonoidHom.id G) (𝟙 B) n = 𝟙 _ := HomologicalComplex.homologyMap_id _ _
 
@@ -215,10 +225,12 @@ lemma cochainsMap_f_0_comp_cochainsIso₀ :
   simp only [cochainsMap_f, Unique.eq_default (f ∘ _)]
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma cochainsMap_f_1_comp_cochainsIso₁ :
     (cochainsMap f φ).f 1 ≫ (cochainsIso₁ B).hom = (cochainsIso₁ A).hom ≫ cochainsMap₁ f φ := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma cochainsMap_f_2_comp_cochainsIso₂ :
     (cochainsMap f φ).f 2 ≫ (cochainsIso₂ B).hom = (cochainsIso₂ A).hom ≫ cochainsMap₂ f φ := by
@@ -227,6 +239,7 @@ lemma cochainsMap_f_2_comp_cochainsIso₂ :
   rcongr x
   fin_cases x <;> rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma cochainsMap_f_3_comp_cochainsIso₃ :
     (cochainsMap f φ).f 3 ≫ (cochainsIso₃ B).hom = (cochainsIso₃ A).hom ≫ cochainsMap₃ f φ := by
@@ -331,6 +344,7 @@ lemma mapCocycles₁_comp_i :
 lemma coe_mapCocycles₁ (x) :
     ⇑(mapCocycles₁ f φ x) = cochainsMap₁ f φ x := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma cocyclesMap_comp_isoCocycles₁_hom :
@@ -518,8 +532,10 @@ noncomputable def cochainsFunctor : Rep k G ⥤ CochainComplex (ModuleCat k) ℕ
   map_comp φ ψ := cochainsMap_comp (MonoidHom.id G) (MonoidHom.id G) φ ψ
 
 instance : (cochainsFunctor k G).PreservesZeroMorphisms where
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (cochainsFunctor k G).Additive where
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The functor sending a `G`-representation `A` to `Hⁿ(G, A)`. -/
 @[simps]
@@ -531,12 +547,14 @@ noncomputable def functor (n : ℕ) : Rep k G ⥤ ModuleCat k where
     simp only [← HomologicalComplex.homologyMap_comp]
     rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance (n : ℕ) : (functor k G n).PreservesZeroMorphisms where
   map_zero _ _ := by simp [map]
 
 variable {G}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a group homomorphism `f : G →* H`, this is a natural transformation between the functors
 sending `A : Rep k H` to `Hⁿ(H, A)` and to `Hⁿ(G, Res(f)(A))`. -/
@@ -551,6 +569,7 @@ noncomputable def resNatTrans (n : ℕ) :
       ← cochainsMap_comp, res_obj_ρ, Category.comp_id]
     rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a normal subgroup `S ≤ G`, this is a natural transformation between the functors
 sending `A : Rep k G` to `Hⁿ(G ⧸ S, A^S)` and to `Hⁿ(G, A)`. -/
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
index 8178f55ce..1c5574ed8 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
@@ -91,6 +91,7 @@ end Cochains
 
 section Differentials
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The 0th differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
 `k`-linear map `A → Fun(G, A)`. It sends `(a, g) ↦ ρ_A(g)(a) - a.` -/
 @[simps!]
@@ -117,6 +118,7 @@ lemma subtype_comp_d₀₁ : ModuleCat.ofHom (A.ρ.invariants.subtype) ≫ d₀
   rw [← sub_eq_zero] at hx
   exact hx
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The 1st differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
 `k`-linear map `Fun(G, A) → Fun(G × G, A)`. It sends
 `(f, (g₁, g₂)) ↦ ρ_A(g₁)(f(g₂)) - f(g₁g₂) + f(g₁).` -/
@@ -127,6 +129,7 @@ def d₁₂ : ModuleCat.of k (G → A) ⟶ ModuleCat.of k (G × G → A) :=
     map_add' x y := funext fun g => by dsimp; rw [map_add, add_add_add_comm, add_sub_add_comm]
     map_smul' r x := funext fun g => by dsimp; rw [map_smul, smul_add, smul_sub] }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The 2nd differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
 `k`-linear map `Fun(G × G, A) → Fun(G × G × G, A)`. It sends
 `(f, (g₁, g₂, g₃)) ↦ ρ_A(g₁)(f(g₂, g₃)) - f(g₁g₂, g₃) + f(g₁, g₂g₃) - f(g₁, g₂).` -/
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
index 7fe22bb51..2b2710aae 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
@@ -52,6 +52,7 @@ theorem congr {f₁ f₂ : G →* H} (h : f₁ = f₂) {φ : A ⟶ res f₁ B} {
   subst h
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a group homomorphism `f : G →* H` and a representation morphism `φ : A ⟶ Res(f)(B)`,
 this is the chain map sending `∑ aᵢ·gᵢ : Gⁿ →₀ A` to `∑ φ(aᵢ)·(f ∘ gᵢ) : Hⁿ →₀ B`. -/
 @[simps! -isSimp f f_hom]
@@ -108,6 +109,7 @@ lemma chainsMap_id_comp {A B C : Rep k G} (φ : A ⟶ B) (ψ : B ⟶ C) :
 lemma chainsMap_zero : chainsMap f (0 : A ⟶ res f B) = 0 := by
   ext; simp [chainsMap_f, LinearMap.zero_apply (M₂ := B)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma chainsMap_f_map_mono (hf : Function.Injective f) [Mono φ] (i : ℕ) :
     Mono ((chainsMap f φ).f i) := by
   simpa [ModuleCat.mono_iff_injective] using!
@@ -118,6 +120,7 @@ instance chainsMap_id_f_map_mono {A B : Rep k G} (φ : A ⟶ B) [Mono φ] (i : 
     Mono ((chainsMap (MonoidHom.id G) φ).f i) :=
   chainsMap_f_map_mono (MonoidHom.id G) φ (fun _ _ h => h) _
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma chainsMap_f_map_epi (hf : Function.Surjective f) [Epi φ] (i : ℕ) :
     Epi ((chainsMap f φ).f i) := by
   simpa [ModuleCat.epi_iff_surjective] using!
@@ -825,6 +828,7 @@ noncomputable def chainsFunctor :
   map_id _ := chainsMap_id
   map_comp φ ψ := chainsMap_comp (MonoidHom.id G) (MonoidHom.id G) φ ψ
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (chainsFunctor k G).PreservesZeroMorphisms where
   map_zero _ _ := chainsMap_zero (MonoidHom.id G)
 
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
index 86cf1ed86..b481aec9c 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
@@ -114,7 +114,6 @@ theorem range_d₁₀_eq_coinvariantsKer :
       simpa [← hy, add_sub_add_comm, sum_add_index, d₁₀_single (G := G)]
         using! Submodule.add_mem _ (Coinvariants.mem_ker_of_eq _ _ _ rfl) (h rfl)
 
-set_option backward.isDefEq.respectTransparency false in
 set_option backward.defeqAttrib.useBackward true in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma d₁₀_comp_coinvariantsMk : d₁₀ A ≫ (coinvariantsMk k G).app A = 0 := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/Resolution.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/Resolution.lean
index 137e240b6..a6a4fc58a 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/Resolution.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/Resolution.lean
@@ -190,6 +190,7 @@ theorem d_of {n : ℕ} (c : Fin (n + 1) → G) :
     d k G n (.single c 1) = ∑ p : Fin (n + 1), .single (c ∘ p.succAbove) ((-1 : k) ^ p.val) := by
   simp [d]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma d_single {n : ℕ} (c : Fin (n + 1) → G) (r : k) :
     d k G n (.single c r) =
       ∑ p : Fin (n + 1), .single (c ∘ p.succAbove) (r * (-1 : k) ^ p.val) := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Induced.lean b/mathlib4/Mathlib/RepresentationTheory/Induced.lean
index 2677fd901..7b892ac5a 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Induced.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Induced.lean
@@ -179,7 +179,6 @@ variable {G H : Type u} [Group G] [Group H] (φ : G →* H) (A : Rep k G) (B : R
 open Representation
 
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency false in
 /-- Given a group hom `φ : G →* H`, `A : Rep k G` and `B : Rep k H`, this is the `k`-linear map
 `(Ind(φ)(A) ⊗ B))_H ⟶ (A ⊗ Res(φ)(B))_G` sending `⟦h ⊗ₜ a⟧ ⊗ₜ b` to `⟦a ⊗ ρ(h)(b)⟧` for all
 `h : H`, `a : A`, and `b : B`. -/
@@ -198,7 +197,6 @@ noncomputable def coinvariantsTensorIndHom :
     ext; simp
 
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency false in
 variable {A B} in
 lemma coinvariantsTensorIndHom_mk_tmul_indVMk (h : H) (x : A) (y : B) :
     coinvariantsTensorIndHom φ A B (coinvariantsTensorMk _ _ (IndV.mk φ _ h x) y) =
@@ -206,7 +204,6 @@ lemma coinvariantsTensorIndHom_mk_tmul_indVMk (h : H) (x : A) (y : B) :
   simp [coinvariantsTensorIndHom, coinvariantsTensorMk]
 
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency false in
 /-- Given a group hom `φ : G →* H`, `A : Rep k G` and `B : Rep k H`, this is the `k`-linear map
 `(A ⊗ Res(φ)(B))_G ⟶ (Ind(φ)(A) ⊗ B))_H` sending `⟦a ⊗ₜ b⟧` to `⟦1 ⊗ₜ a⟧ ⊗ₜ b` for all
 `a : A`, and `b : B`. -/
@@ -223,7 +220,6 @@ noncomputable def coinvariantsTensorIndInv :
       simp [← Coinvariants.mk_inv_tmul]
 
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency false in
 variable {A B} in
 lemma coinvariantsTensorIndInv_mk_tmul_indMk (x : A) (y : B) :
     coinvariantsTensorIndInv φ A B (Coinvariants.mk
@@ -232,7 +228,6 @@ lemma coinvariantsTensorIndInv_mk_tmul_indMk (x : A) (y : B) :
   simp [coinvariantsTensorIndInv, coinvariantsTensorMk]
 
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency false in
 /-- Given a group hom `φ : G →* H`, `A : Rep k G` and `B : Rep k H`, this is the `k`-linear
 isomorphism `(Ind(φ)(A) ⊗ B))_H ⟶ (A ⊗ Res(φ)(B))_G` sending `⟦h ⊗ₜ a⟧ ⊗ₜ b` to `⟦a ⊗ ρ(h)(b)⟧`
 for all `h : H`, `a : A`, and `b : B`. -/
@@ -252,7 +247,6 @@ noncomputable def coinvariantsTensorIndIso :
     simp [coinvariantsTensorIndInv, coinvariantsTensorMk, coinvariantsTensorIndHom]
 
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency false in
 /-- Given a group hom `φ : G →* H` and `A : Rep k G`, the functor `Rep k H ⥤ ModuleCat k` sending
 `B ↦ (Ind(φ)(A) ⊗ B))_H` is naturally isomorphic to the one sending `B ↦ (A ⊗ Res(φ)(B))_G`. -/
 @[simps! hom_app inv_app]
diff --git a/mathlib4/Mathlib/RepresentationTheory/Intertwining.lean b/mathlib4/Mathlib/RepresentationTheory/Intertwining.lean
index 428ad6f57..2cd8a6ee2 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Intertwining.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Intertwining.lean
@@ -486,6 +486,35 @@ instance : Module A (IntertwiningMap ρ σ) :=
   fast_instance%
   Function.Injective.module A (coeFnAddMonoidHom ρ σ) DFunLike.coe_injective (coe_smul ρ σ)
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`LinearMap.CompatibleSMul ρ.asModule σ.asModule A A[G]`
+It is needed by `LinearMap.map_smul_of_tower`, with which the `simp` in `invFun`'s `map_smul'`
+below has to rewrite the goal `f (a • v) = a • f v`.
+
+The failure happens while applying `@LinearMap.IsScalarTower.compatibleSMul`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `SMul A ρ.asModule`, whereas the assigned value `DistribMulAction.toDistribSMul.toSMul` has type
+`SMul A V`. The comparison bottoms out at `ρ.asModule =?= V`, where `asModule` is a plain
+semireducible `def` and therefore does not unfold at the `.instances` transparency that instance
+search runs at. Lean falls back to synthesize an instance of the correct type, which succeeds, but
+the candidate is again not defeq to the assigned value, stalling at
+`inst✝.toSemigroupAction.1 =?= instModuleAsModule._aux_1 ρ`. That comparison, too, runs at
+`.instances`, since `respectTransparency false` suppresses the transparency bump that
+instance-implicit arguments would otherwise receive.
+
+With no `CompatibleSMul` instance found, the rewrite does not fire and `simp` makes no progress.
+
+Potential fix: mark `asModule` implicit-reducible *at its definition site*. Then
+`respectTransparency false` becomes obsolete, and once it is removed, `instanceTypes false` can go
+as well: `asModule` being implicit-reducible, the `instModuleAsModule._aux_1` constant becomes
+implicit-reducible as well. The reason for this is that `instModuleAsModule`'s definition uses
+`inferInstanceAs`, which wraps the instance's fields into wrappers to encapsulate defeq abuse.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 /-- An intertwining map is the same thing as a linear map over the group ring. -/
 def equivLinearMapAsModule :
@@ -507,6 +536,7 @@ def equivLinearMapAsModule :
   left_inv f := rfl
   right_inv f := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Composition of intertwining maps. -/
 def llcomp : IntertwiningMap σ τ →ₗ[A] IntertwiningMap ρ σ →ₗ[A] IntertwiningMap ρ τ where
diff --git a/mathlib4/Mathlib/RepresentationTheory/Invariants.lean b/mathlib4/Mathlib/RepresentationTheory/Invariants.lean
index 50c4e2cff..c49820a10 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Invariants.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Invariants.lean
@@ -135,6 +135,7 @@ theorem averageMap_invariant (v : V) : averageMap ρ v ∈ invariants ρ := fun
   rw [averageMap, ← asAlgebraHom_single_one, ← Module.End.mul_apply, ← map_mul (asAlgebraHom ρ),
     mul_average_left]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The `averageMap` acts as the identity on the subspace of invariants.
 -/
 theorem averageMap_id (v : V) (hv : v ∈ invariants ρ) : averageMap ρ v = v := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Rep/Iso.lean b/mathlib4/Mathlib/RepresentationTheory/Rep/Iso.lean
index 4c3818e73..8fe09aa69 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Rep/Iso.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Rep/Iso.lean
@@ -69,6 +69,7 @@ variable {k : Type u} {G : Type v} [CommRing k] [Monoid G]
 
 open MonoidAlgebra
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Auxiliary lemma for `toModuleMonoidAlgebra`. -/
 theorem to_Module_monoidAlgebra_map_aux {k G : Type*} [CommRing k] [Monoid G] (V W : Type*)
     [AddCommGroup V] [AddCommGroup W] [Module k V] [Module k W] (ρ : G →* V →ₗ[k] V)
diff --git a/mathlib4/Mathlib/RepresentationTheory/Submodule.lean b/mathlib4/Mathlib/RepresentationTheory/Submodule.lean
index 34683e179..1c5daff13 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Submodule.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Submodule.lean
@@ -60,6 +60,7 @@ instance [Nontrivial V] : Nontrivial ρ.invtSubmodule :=
 
 end invtSubmodule
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma asAlgebraHom_mem_of_forall_mem (p : Submodule k V) (hp : ∀ g, ∀ v ∈ p, ρ g v ∈ p)
     (v : V) (hv : v ∈ p) (x : k[G]) :
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/Algebra.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/Algebra.lean
index 07afcc4ab..9ea23eb4a 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/Algebra.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/Algebra.lean
@@ -304,6 +304,7 @@ instance : IsScalarTower R (R ⧸ (I • ⊤ : Ideal R)) (M ⧸ (I • ⊤ : Sub
     rw [← Submodule.Quotient.mk_smul, Ideal.Quotient.mk_eq_mk, mk_smul_mk, smul_assoc]
     rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance smul : SMul (AdicCompletion I R) (AdicCompletion I M) where
   smul r x := {
@@ -316,11 +317,13 @@ instance smul : SMul (AdicCompletion I R) (AdicCompletion I M) where
       rw [smul_mk I hmn]
   }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem smul_eval (n : ℕ) (r : AdicCompletion I R) (x : AdicCompletion I M) :
     (r • x).val n = r.val n • x.val n :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `AdicCompletion I M` is naturally an `AdicCompletion I R` module. -/
 instance module : Module (AdicCompletion I R) (AdicCompletion I M) where
   one_smul b := by
@@ -339,6 +342,7 @@ instance : IsScalarTower R (AdicCompletion I R) (AdicCompletion I M) where
     ext n
     rw [smul_eval, val_smul_apply, val_smul_apply, smul_eval, smul_assoc]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A priori `AdicCompletion I R` has two `AdicCompletion I R`-module instances.
 Both agree definitionally. -/
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/Basic.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/Basic.lean
index 48c570d3a..9bfd9bc40 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/Basic.lean
@@ -263,6 +263,7 @@ end IsPrecomplete
 
 namespace AdicCompletion
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `AdicCompletion` is the submodule of compatible families in
 `∀ n : ℕ, M ⧸ (I ^ n • ⊤)`. -/
 def submodule : Submodule R (∀ n : ℕ, M ⧸ (I ^ n • ⊤ : Submodule R M)) where
@@ -678,6 +679,7 @@ theorem of_ofLinearEquiv_symm (x : AdicCompletion I M) :
 
 end Bijective
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem pow_smul_top_le_ker_eval (n : ℕ) : I ^ n • ⊤ ≤ (eval I M n).ker := by
   simp only [smul_le, mem_top, LinearMap.mem_ker, map_smul, coe_eval, forall_const]
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/Completeness.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/Completeness.lean
index 418dd7fdd..24c3fd5c6 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/Completeness.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/Completeness.lean
@@ -124,6 +124,7 @@ theorem restrictScalars_range_ofPowSMul_eq_ker_eval {n : ℕ} :
   simp only [LinearMap.mem_ker, coe_eval] at hx
   use ofValEqZero I hx; simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /- An intermediate helper lemma for the theorem below to avoid introducing
 `AdicCompletion.finsuppSum` (the `Finsupp` version of `AdicCompletion.sum`).
 It proves the equality of two linear maps:
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/Functoriality.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/Functoriality.lean
index b71da4435..e30c3544e 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/Functoriality.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@@ -102,6 +102,7 @@ theorem map_zero : map I (0 : M →ₗ[R] N) = 0 :=
 
 end AdicCauchySequence
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear map induces a map on adic completions. -/
 def map (f : M →ₗ[R] N) :
     AdicCompletion I M →ₗ[AdicCompletion I R] AdicCompletion I N where
@@ -359,6 +360,7 @@ open Submodule
 
 variable {I}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem exists_smodEq_pow_add_one_smul {f : M →ₗ[R] N}
     (h : Function.Surjective (mkQ (I • ⊤) ∘ₗ f)) {y : N} {n : ℕ}
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/LocalRing.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/LocalRing.lean
index dc5d64818..d0f972467 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/LocalRing.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/LocalRing.lean
@@ -153,6 +153,7 @@ lemma residueField_map_bijective [IsNoetherianRing R] [IsLocalRing R] :
       (algebraMap R (AdicCompletion (maximalIdeal R) R))) :=
     AdicCompletion.residueField_map_bijective_of_fg (maximalIdeal R).fg_of_isNoetherianRing
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma spanFinrank_maximalIdeal_eq [IsNoetherianRing R] [IsLocalRing R] :
     (maximalIdeal (AdicCompletion (maximalIdeal R) R)).spanFinrank =
     (maximalIdeal R).spanFinrank := by
diff --git a/mathlib4/Mathlib/RingTheory/Adjoin/PowerBasis.lean b/mathlib4/Mathlib/RingTheory/Adjoin/PowerBasis.lean
index 315df15f4..f000745ef 100644
--- a/mathlib4/Mathlib/RingTheory/Adjoin/PowerBasis.lean
+++ b/mathlib4/Mathlib/RingTheory/Adjoin/PowerBasis.lean
@@ -92,6 +92,7 @@ variable {R : Type*} [CommRing R] [Algebra R S] [Algebra R K] [IsScalarTower R K
 variable {A : Type*} [CommRing A] [Algebra R A] [Algebra S A]
 variable [IsScalarTower R S A] {B : PowerBasis S A}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `B : PowerBasis S A` is such that `IsIntegral R B.gen`, then
 `IsIntegral R (B.basis.repr (B.gen ^ n) i)` for all `i` if
 `minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)`. This is the case if `R` is a GCD domain
@@ -167,6 +168,7 @@ theorem repr_pow_isIntegral (hB : IsIntegral R B.gen) {x : A}
     rw [pow_succ]
     exact repr_mul_isIntegral hB (fun _ => hn _ le_rfl (fun _ => hx _) _) hx hmin
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `B B' : PowerBasis K S` be such that `IsIntegral R B.gen`, and let `P : R[X]` be such that
 `aeval B.gen P = B'.gen`. Then `IsIntegral R (B.basis.to_matrix B'.basis i j)` for all `i` and `j`
 if `minpoly K B.gen = (minpoly R B.gen).map (algebraMap R L)`. This is the case
diff --git a/mathlib4/Mathlib/RingTheory/AlgebraTower.lean b/mathlib4/Mathlib/RingTheory/AlgebraTower.lean
index 115298b10..d51af1f58 100644
--- a/mathlib4/Mathlib/RingTheory/AlgebraTower.lean
+++ b/mathlib4/Mathlib/RingTheory/AlgebraTower.lean
@@ -135,6 +135,7 @@ theorem smulTower_repr (x ij) :
 theorem smulTower_repr_mk (x i j) : (b.smulTower c).repr x (i, j) = b.repr (c.repr x j) i :=
   b.smulTower_repr c x (i, j)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem smulTower_apply (ij) : (b.smulTower c) ij = b ij.1 • c ij.2 := by
   classical
diff --git a/mathlib4/Mathlib/RingTheory/Algebraic/Integral.lean b/mathlib4/Mathlib/RingTheory/Algebraic/Integral.lean
index 9ef1db23b..7bce98242 100644
--- a/mathlib4/Mathlib/RingTheory/Algebraic/Integral.lean
+++ b/mathlib4/Mathlib/RingTheory/Algebraic/Integral.lean
@@ -244,6 +244,7 @@ theorem restrictScalars_of_isIntegral [int : Algebra.IsIntegral R S]
     e, ← Algebra.smul_def, mul_comm, mul_smul]
   exact isIntegral_trans _ (int_s.smul _)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 theorem restrictScalars [Algebra.IsAlgebraic R S]
     {a : A} (h : IsAlgebraic S a) : IsAlgebraic R a := by
diff --git a/mathlib4/Mathlib/RingTheory/Bialgebra/Equiv.lean b/mathlib4/Mathlib/RingTheory/Bialgebra/Equiv.lean
index a121f140f..c2d46634e 100644
--- a/mathlib4/Mathlib/RingTheory/Bialgebra/Equiv.lean
+++ b/mathlib4/Mathlib/RingTheory/Bialgebra/Equiv.lean
@@ -55,6 +55,7 @@ variable {F R A B : Type*} [CommSemiring R] [Semiring A] [Semiring B]
   [Algebra R A] [Algebra R B] [CoalgebraStruct R A] [CoalgebraStruct R B]
   [EquivLike F A B] [BialgEquivClass F R A B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) toBialgHomClass : BialgHomClass F R A B where
   map_add := map_add
   map_smulₛₗ := map_smul
@@ -310,6 +311,7 @@ end
 
 variable [Semiring A] [Semiring B] [Bialgebra R A] [Bialgebra R B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Construct a bialgebra equiv from an algebra equiv respecting counit and comultiplication. -/
 @[simps apply] def ofAlgEquiv (f : A ≃ₐ[R] B)
     (counit_comp : (Bialgebra.counitAlgHom R B).comp f = Bialgebra.counitAlgHom R A)
diff --git a/mathlib4/Mathlib/RingTheory/Bialgebra/Hom.lean b/mathlib4/Mathlib/RingTheory/Bialgebra/Hom.lean
index 3f5f5d8f0..f544284a8 100644
--- a/mathlib4/Mathlib/RingTheory/Bialgebra/Hom.lean
+++ b/mathlib4/Mathlib/RingTheory/Bialgebra/Hom.lean
@@ -65,6 +65,7 @@ variable [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B]
   [CoalgebraStruct R A] [CoalgebraStruct R B] [FunLike F A B]
   [BialgHomClass F R A B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance (priority := 100) toAlgHomClass : AlgHomClass F R A B where
   map_mul := map_mul
@@ -315,6 +316,7 @@ end AlgebraCoalgebra
 
 variable [Bialgebra R A] [Bialgebra R B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Construct a bialgebra hom from an algebra hom respecting counit and comultiplication. -/
 @[simps!]
 def ofAlgHom (f : A →ₐ[R] B) (counit_comp : (counitAlgHom R B).comp f = counitAlgHom R A)
diff --git a/mathlib4/Mathlib/RingTheory/Bialgebra/MonoidAlgebra.lean b/mathlib4/Mathlib/RingTheory/Bialgebra/MonoidAlgebra.lean
index a974bdfd2..c9012f9f5 100644
--- a/mathlib4/Mathlib/RingTheory/Bialgebra/MonoidAlgebra.lean
+++ b/mathlib4/Mathlib/RingTheory/Bialgebra/MonoidAlgebra.lean
@@ -284,6 +284,7 @@ def mapDomainOfBialgHom (f : R[G] →ₐc[R] R[H]) : G →* H where
     rw [← mul_one (1 : R), ← single_mul_single, ← single_mul_single, map_mul]
     simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive (dont_translate := R) (attr := simp)]
 lemma single_mapDomainOfBialgHom (f : R[G] →ₐc[R] R[H]) (g : G) (r : R) :
     single (mapDomainOfBialgHom f g) r = f (single g r) := by
diff --git a/mathlib4/Mathlib/RingTheory/DedekindDomain/Different.lean b/mathlib4/Mathlib/RingTheory/DedekindDomain/Different.lean
index d4f293ebe..9668bfe14 100644
--- a/mathlib4/Mathlib/RingTheory/DedekindDomain/Different.lean
+++ b/mathlib4/Mathlib/RingTheory/DedekindDomain/Different.lean
@@ -439,6 +439,7 @@ theorem smul_mem_dual_one {x : L} (hx : x ∈ dual A K (1 : FractionalIdeal B⁰
 
 variable [IsTorsionFree B C]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem dual_eq_dual_mul_dual :
     dual A K (1 : FractionalIdeal C⁰ M) = dual B L (1 : FractionalIdeal C⁰ M) *
         (dual A K (1 : FractionalIdeal B⁰ L)).extendedHom M C := by
@@ -687,6 +688,7 @@ variable [IsFractionRing B L] [IsDedekindDomain A] [IsDedekindDomain B]
 
 set_option linter.overlappingInstances false
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include K L in
 lemma pow_sub_one_dvd_differentIdeal_aux
     {p : Ideal A} [p.IsMaximal] (P : Ideal B) {e : ℕ} (he : e ≠ 0) (hp : p ≠ ⊥)
@@ -846,6 +848,7 @@ theorem not_dvd_differentIdeal_of_isCoprime
       exact Ideal.mul_le_right
   exact not_dvd_differentIdeal_of_isCoprime_of_isSeparable A P Q hPQ hP
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma dvd_differentIdeal_of_not_isSeparable
     [Algebra.IsSeparable (FractionRing A) (FractionRing B)]
     {p : Ideal A} [p.IsMaximal] (hp : p ≠ ⊥)
diff --git a/mathlib4/Mathlib/RingTheory/Derivation/Basic.lean b/mathlib4/Mathlib/RingTheory/Derivation/Basic.lean
index e0e05c8fe..a34ac262f 100644
--- a/mathlib4/Mathlib/RingTheory/Derivation/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Derivation/Basic.lean
@@ -264,6 +264,7 @@ variable {N : Type*} [AddCommMonoid N] [Module A N] [Module R N] [IsScalarTower
 
 variable (f : M →ₗ[A] N) (e : M ≃ₗ[A] N)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- We can push forward derivations using linear maps, i.e., the composition of a derivation with a
 linear map is a derivation. Furthermore, this operation is linear on the spaces of derivations. -/
@@ -277,14 +278,17 @@ def _root_.LinearMap.compDer : Derivation R A M →ₗ[A] Derivation R A N where
   map_add' D₁ D₂ := by ext; exact LinearMap.map_add _ _ _
   map_smul' r D := by ext; dsimp; simp only [_root_.map_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_to_linearMap_comp : (f.compDer D : A →ₗ[R] N) = (f : M →ₗ[R] N).comp (D : A →ₗ[R] M) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_comp : (f.compDer D : A → N) = (f : M →ₗ[R] N).comp (D : A →ₗ[R] M) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The composition of a derivation with a linear map as a bilinear map -/
 @[simps]
 def llcomp : (M →ₗ[A] N) →ₗ[A] Derivation R A M →ₗ[A] Derivation R A N where
@@ -292,6 +296,7 @@ def llcomp : (M →ₗ[A] N) →ₗ[A] Derivation R A M →ₗ[A] Derivation R A
   map_add' f₁ f₂ := by ext; rfl
   map_smul' r D := by ext; rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Pushing a derivation forward through a linear equivalence is an equivalence. -/
 def _root_.LinearEquiv.compDer : Derivation R A M ≃ₗ[A] Derivation R A N :=
   { e.toLinearMap.compDer with
@@ -299,11 +304,13 @@ def _root_.LinearEquiv.compDer : Derivation R A M ≃ₗ[A] Derivation R A N :=
     left_inv := fun D => by ext a; exact e.symm_apply_apply (D a)
     right_inv := fun D => by ext a; exact e.apply_symm_apply (D a) }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem linearEquiv_coe_to_linearMap_comp :
     (e.compDer D : A →ₗ[R] N) = (e.toLinearMap : M →ₗ[R] N).comp (D : A →ₗ[R] M) :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem linearEquiv_coe_comp :
     (e.compDer D : A → N) = (e.toLinearMap : M →ₗ[R] N).comp (D : A →ₗ[R] M) :=
@@ -361,6 +368,7 @@ variable [CommSemiring R] [CommRing A] [CommRing M]
 variable [Algebra R A] [Algebra R M]
 variable {F : Type*} [FunLike F A M] [AlgHomClass F R A M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /--
 Lift a derivation via an algebra homomorphism `f` with a right inverse such that
diff --git a/mathlib4/Mathlib/RingTheory/DividedPowerAlgebra/Init.lean b/mathlib4/Mathlib/RingTheory/DividedPowerAlgebra/Init.lean
index 388a23a45..2f51e9c0a 100644
--- a/mathlib4/Mathlib/RingTheory/DividedPowerAlgebra/Init.lean
+++ b/mathlib4/Mathlib/RingTheory/DividedPowerAlgebra/Init.lean
@@ -302,6 +302,7 @@ variable (R M)
 
 variable {A : Type*} [CommSemiring A] [Algebra R A]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private theorem lift'_imp {f : ℕ × M → A} (hf_zero : ∀ m, f (0, m) = 1)
     (hf_smul : ∀ (n : ℕ) (r : R) (m : M), f ⟨n, r • m⟩ = r ^ n • f ⟨n, m⟩)
     (hf_mul : ∀ n p m, f ⟨n, m⟩ * f ⟨p, m⟩ = (n + p).choose n • f ⟨n + p, m⟩)
diff --git a/mathlib4/Mathlib/RingTheory/Etale/Kaehler.lean b/mathlib4/Mathlib/RingTheory/Etale/Kaehler.lean
index 7831c3c5a..c705d373f 100644
--- a/mathlib4/Mathlib/RingTheory/Etale/Kaehler.lean
+++ b/mathlib4/Mathlib/RingTheory/Etale/Kaehler.lean
@@ -138,6 +138,7 @@ def tensorCotangentSpaceOfFormallyEtale
       ext a
       simp; rfl }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- (Implementation)
 If `J ≃ Q ⊗ₚ I` (e.g. when `T = Q ⊗ₚ S` and `P → Q` is flat), then `T ⊗ₛ I/I² ≃ J/J²`.
 This is the inverse. -/
@@ -200,6 +201,7 @@ lemma tensorCotangentInvFun_smul_mk
   rw [e.symm_apply_apply]
   simp
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `J ≃ Q ⊗ₚ I` (e.g. when `T = Q ⊗ₚ S` and `P → Q` is flat), then `T ⊗ₛ I/I² ≃ J/J²`. -/
 noncomputable
 def tensorCotangent [alg : Algebra P.Ring Q.Ring] (halg : algebraMap P.Ring Q.Ring = f.toRingHom)
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/BaseChange.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/BaseChange.lean
index a173e7618..12fa897ef 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/BaseChange.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/BaseChange.lean
@@ -112,6 +112,7 @@ noncomputable def tensorCotangentOfFlat [Module.Flat R T] :
     (Ideal.Cotangent.equivOfEq _ _ (P.ker_baseChange T).symm).restrictScalars T ≪≫ₗ
     (P.baseChange (T := T)).cotangentEquivCotangentKer.symm.restrictScalars T
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 attribute [local instance] Algebra.TensorProduct.rightAlgebra in
 @[simp]
@@ -205,6 +206,7 @@ noncomputable def tensorH1CotangentOfFlat (T : Type*) [CommRing T] [Algebra R T]
       ((Generators.self R S).baseChangeToBaseChange T)).restrictScalars T ≪≫ₗ
     ((Generators.self R S).baseChange (T := T)).equivH1Cotangent.restrictScalars T
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 attribute [local instance] TensorProduct.rightAlgebra in
 lemma tensorH1CotangentOfFlat_tmul (T : Type*) [CommRing T] [Algebra R T] [Module.Flat R T]
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basic.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basic.lean
index fee707ff8..bf719aee7 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basic.lean
@@ -243,6 +243,7 @@ def Hom.subToKer (f g : Hom P P') : P.Ring →ₗ[R] P'.ker := by
     Submodule.restrictScalars_mem, RingHom.mem_ker, map_sub, algebraMap_toRingHom,
     sub_self, toAlgHom_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable [IsScalarTower R S S'] in
 /--
 If `f` and `g` are two maps `P → P'` between presentations,
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
index 305e8c78d..bbeceb700 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
@@ -238,7 +238,33 @@ set_option backward.isDefEq.respectTransparency false in
 def basisRight : Module.Basis Unit S D.presRight.toExtension.Cotangent :=
   Generators.basisCotangentAway S D.gbar
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`AddCommMonoid D.presRight.toExtension.Cotangent`
+It is needed by the `Module.Basis.prod` below.
+
+The search reduces via `@AddCommGroup.toAddCommMonoid` to
+`AddCommGroup D.presRight.toExtension.Cotangent`, and the failure happens while applying
+`@Extension.instAddCommGroupCotangent`: assigning one of its instance-implicit-argument
+metavariables is rejected because the metavariable's type and the type of the assigned value do not
+match at `.instances` transparency. The metavariable's expected type is `CommRing D.T`, whereas the
+assigned value `Ideal.Quotient.commRing (Ideal.span (Set.range (Subtype.val ∘ D.f ∘ ⇑b)))` has type
+`CommRing (MvPolynomial ι R ⧸ Ideal.span (Set.range (Subtype.val ∘ D.f ∘ ⇑b)))`. `T` is an `abbrev`,
+so it unfolds and both sides become that same quotient; but the two ideals are taken over different
+rings, `P.toExtension.Ring` on one side and `MvPolynomial ι R` on the other. Comparing those bumps
+the transparency to `.implicit` and bottoms out at
+`P.toExtension.1 =?= AddMonoidAlgebra R (ι →₀ ℕ)`, where `Algebra.Generators.toExtension` is a plain
+semireducible `def` and therefore does not unfold. Lean falls back to synthesize an instance of the
+correct type, which succeeds, but it returns the same `Ideal.Quotient.commRing` term with the ideal
+over `P.toExtension.Ring`, which is again not defeq to the assigned value, for the same reason.
+
+Potential fix: make `Algebra.Generators.toExtension` implicit-reducible.
+Then both backward compatibility options can go.
+-/
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.instanceTypes false in
 /-- The basis on the cotangent space of the constructed presentation. -/
 def basis [Nontrivial S] : Module.Basis (Unit ⊕ σ) S D.pres.toExtension.Cotangent :=
   (Module.Basis.prod D.basisRight D.basisLeft).map D.cotangentEquivProd.symm
@@ -249,7 +275,28 @@ lemma basis_inl [Nontrivial S] :
       D.cotangentEquivProd.symm (Generators.cMulXSubOneCotangent S D.gbar, 0) := by
   simpa [basis] using! Generators.basisCotangentAway_apply _ _
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following two instances cannot be synthesized:
+`OfNat D.presRight.toExtension.Cotangent 0`
+`AddCommMonoid (D.presRight.toExtension.Cotangent × S ⊗[D.T] D.presLeft.toExtension.Cotangent)`
+Both are needed by the pair `(0, D.basisLeft i)` below.
+
+Both searches reduce to `AddCommGroup D.presRight.toExtension.Cotangent` and then fail exactly as
+in `basis` above: applying `@Extension.instAddCommGroupCotangent`, the assignment to the
+instance-implicit-argument metavariable of type `CommRing D.T` is rejected, the assigned value
+`Ideal.Quotient.commRing (Ideal.span (Set.range (Subtype.val ∘ D.f ∘ ⇑b)))` having type
+`CommRing (MvPolynomial ι R ⧸ Ideal.span (Set.range (Subtype.val ∘ D.f ∘ ⇑b)))`, with the two ideals
+taken over different rings; the comparison bottoms out at
+`P.toExtension.1 =?= AddMonoidAlgebra R (ι →₀ ℕ)`, and the fallback synthesis returns a term that is
+again not defeq to the assigned value.
+
+Potential fix: make `Algebra.Generators.toExtension` implicit-reducible.
+Then both backward compatibility options can go.
+-/
 set_option backward.isDefEq.respectTransparency.types false in
+set_option backward.isDefEq.instanceTypes false in
 lemma basis_inr [Nontrivial S] (i : σ) :
     D.basis (.inr i) = D.cotangentEquivProd.symm (0, D.basisLeft i) := by
   simp [basis]
@@ -275,6 +322,29 @@ end PresentationOfFreeCotangent.Aux
 
 end
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`LE (Submodule P.Ring P.toExtension.Cotangent)`
+It is needed by the `refine le_trans le_top (top_le_iff.mpr ?_)` below, as are the `Preorder`,
+`PartialOrder` and `OrderTop` instances on the same type, which fail in the same way.
+
+The failure happens while applying `@Submodule.completeLattice`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `Semiring P.Ring`, whereas the assigned value `CommRing.toCommSemiring.toSemiring` has type
+`Semiring P.toExtension.Ring`. The comparison bottoms out at
+`AddMonoidAlgebra R (α →₀ ℕ) =?= P.toExtension.1`, where `Algebra.Generators.toExtension` is a plain
+semireducible `def` and therefore does not unfold at the `.instances` transparency that instance
+search runs at. Lean falls back to synthesize an instance of the correct type, which succeeds, but
+it returns `AddMonoidAlgebra.semiring`, which is again not defeq to the assigned value; that second
+comparison also runs at `.instances`, `respectTransparency false` suppressing the transparency bump.
+
+Potential fix: make `Algebra.Generators.toExtension` implicit-reducible.
+Then `respectTransparency false` and `instanceTypes false` can both go.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 set_option backward.isDefEq.respectTransparency.outParams false in
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Free.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Free.lean
index 4fb3164a8..06921833e 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Free.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Free.lean
@@ -78,6 +78,7 @@ lemma cotangentRestrict_bijective_of_isCompl
     · exact P.cotangentSpaceBasis.repr.symm.surjective
   · simpa [g, Submodule.map_comp, Submodule.map_span, ← Set.range_comp, Function.comp_def]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma disjoint_ker_toKaehler_of_linearIndependent
     (h : LinearIndependent S (fun k ↦ D R S (P.val (v k)))) :
     Disjoint (LinearMap.ker P.toExtension.toKaehler)
diff --git a/mathlib4/Mathlib/RingTheory/FiniteType.lean b/mathlib4/Mathlib/RingTheory/FiniteType.lean
index 1ba1ee31b..dcd0b6434 100644
--- a/mathlib4/Mathlib/RingTheory/FiniteType.lean
+++ b/mathlib4/Mathlib/RingTheory/FiniteType.lean
@@ -374,6 +374,7 @@ end Ring
 
 end Span
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a set `S` generates an additive monoid `M`, then the image of `M` generates, as algebra,
 `R[M]`. -/
 theorem mvPolynomial_aeval_of_surjective_of_closure [AddCommMonoid M] [CommSemiring R] {S : Set M}
@@ -402,6 +403,7 @@ theorem mvPolynomial_aeval_of_surjective_of_closure [AddCommMonoid M] [CommSemir
 
 variable [AddMonoid M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a set `S` generates an additive monoid `M`, then the image of `M` generates, as algebra,
 `R[M]`. -/
 theorem freeAlgebra_lift_of_surjective_of_closure [CommSemiring R] {S : Set M}
@@ -523,6 +525,7 @@ end Ring
 
 end Span
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a set `S` generates a monoid `M`, then the image of `M` generates, as algebra,
 `R[M]`. -/
 theorem mvPolynomial_aeval_of_surjective_of_closure [CommMonoid M] [CommSemiring R] {S : Set M}
@@ -550,6 +553,7 @@ theorem mvPolynomial_aeval_of_surjective_of_closure [CommMonoid M] [CommSemiring
 
 variable [Monoid M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a set `S` generates an additive monoid `M`, then the image of `M` generates, as algebra,
 `R[M]`. -/
 theorem freeAlgebra_lift_of_surjective_of_closure [CommSemiring R] {S : Set M}
@@ -601,6 +605,7 @@ end MonoidAlgebra
 
 section Orzech
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open Submodule Module Module.Finite in
 /--
 Any commutative ring `R` satisfies the `OrzechProperty`, that is, for any finitely generated
diff --git a/mathlib4/Mathlib/RingTheory/Flat/EquationalCriterion.lean b/mathlib4/Mathlib/RingTheory/Flat/EquationalCriterion.lean
index f5de68128..a36517a6e 100644
--- a/mathlib4/Mathlib/RingTheory/Flat/EquationalCriterion.lean
+++ b/mathlib4/Mathlib/RingTheory/Flat/EquationalCriterion.lean
@@ -100,6 +100,7 @@ end Module
 
 namespace Module.Flat
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R M) in
 /-- **Equational criterion for flatness**, combined form.
 
diff --git a/mathlib4/Mathlib/RingTheory/Flat/FaithfullyFlat/Basic.lean b/mathlib4/Mathlib/RingTheory/Flat/FaithfullyFlat/Basic.lean
index c2d6c3c60..6b4f32e4e 100644
--- a/mathlib4/Mathlib/RingTheory/Flat/FaithfullyFlat/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Flat/FaithfullyFlat/Basic.lean
@@ -267,6 +267,7 @@ variable {N2 : Type*} [AddCommGroup N2] [Module R N2]
 variable {N3 : Type*} [AddCommGroup N3] [Module R N3]
 variable (l12 : N1 →ₗ[R] N2) (l23 : N2 →ₗ[R] N3)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 If `M` is faithfully flat, then exactness of `N₁ ⊗ M -> N₂ ⊗ M -> N₃ ⊗ M` implies that the
 composition `N₁ -> N₂ -> N₃` is `0`.
diff --git a/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean b/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
index c04497e28..ccd039d68 100644
--- a/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
+++ b/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
@@ -53,6 +53,7 @@ section
 variable {P' : Type*} [CommRing P'] [Algebra R P']
 variable {P'' : Type*} [CommRing P''] [Algebra R P'']
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.IsFractional.map (g : P →ₐ[R] P') {I : Submodule R P} :
     IsFractional S I → IsFractional S (Submodule.map g.toLinearMap I)
   | ⟨a, a_nonzero, hI⟩ =>
diff --git a/mathlib4/Mathlib/RingTheory/HopfAlgebra/Basic.lean b/mathlib4/Mathlib/RingTheory/HopfAlgebra/Basic.lean
index 8383ce9c3..1d10dfbe9 100644
--- a/mathlib4/Mathlib/RingTheory/HopfAlgebra/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/HopfAlgebra/Basic.lean
@@ -120,6 +120,7 @@ lemma sum_mul_antipode_eq_smul (repr : Repr R a ι) :
       counit (R := R) a • 1 := by
   rw [sum_mul_antipode_eq_algebraMap_counit, Algebra.smul_def, mul_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma counit_antipode (a : A) : counit (R := R) (antipode R a) = counit a := by
   calc
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean b/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean
index 4c6e4b8ec..6c6988b3b 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean
@@ -115,6 +115,7 @@ theorem isAssociatedPrime_iff [IsNoetherianRing R] :
     IsAssociatedPrime I M ↔ I.IsPrime ∧ ∃ x : M, I = colon ⊥ {x} :=
   (⊥ : Submodule R M).isAssociatedPrime_iff
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem IsAssociatedPrime.map_of_injective (h : IsAssociatedPrime I M) (hf : Function.Injective f) :
     IsAssociatedPrime I M' := by
@@ -163,6 +164,7 @@ contained in that of `M'`. -/
 theorem subset_of_injective (hf : Function.Injective f) :
     associatedPrimes R M ⊆ associatedPrimes R M' := fun _I h => h.map_of_injective f hf
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `0 → M → M' → M''` is an exact sequence, then the set of associated primes of `M'` is
 contained in the union of those of `M` and `M''`. -/
 @[stacks 02M3 "second part"]
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean b/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean
index 8981a4233..d0f70376d 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean
@@ -51,6 +51,7 @@ variable {A : Type u} [CommRing A] {M : Type v} [AddCommGroup M] [Module A M]
 def Submodule.IsQuotientEquivQuotientPrime (N₁ N₂ : Submodule A M) :=
   N₁ ≤ N₂ ∧ ∃ (p : PrimeSpectrum A), Nonempty ((↥N₂ ⧸ N₁.submoduleOf N₂) ≃ₗ[A] A ⧸ p.1)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open LinearMap in
 theorem Submodule.isQuotientEquivQuotientPrime_iff {N₁ N₂ : Submodule A M} :
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Cotangent.lean b/mathlib4/Mathlib/RingTheory/Ideal/Cotangent.lean
index 1a2e1331f..593edfd56 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Cotangent.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Cotangent.lean
@@ -103,6 +103,7 @@ lemma cotangentToQuotientSquare_injective : Function.Injective I.cotangentToQuot
   rw [toCotangent_to_quotient_square] at hx
   rwa [Ideal.toCotangent_eq_zero, ← Submodule.Quotient.mk_eq_zero (I ^ 2)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Cotangent.smul_eq_zero_of_mem {I : Ideal R}
     {x} (hx : x ∈ I) (m : I.Cotangent) : x • m = 0 := by
   obtain ⟨m, rfl⟩ := Ideal.toCotangent_surjective _ m
@@ -235,6 +236,7 @@ section Lift
 variable {S : Type*} [CommRing S] [Algebra R S] {I : Ideal S}
 variable {M : Type*} [AddCommGroup M] [Module R M]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Lift a linear map `f : I →ₗ[R] M` that vanishes on products to a linear map on the
 cotangent space `I ⧸ I ^ 2`. -/
 def lift (f : I →ₗ[R] M) (hf : ∀ (x y : I), f (x * y) = 0) :
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Maps.lean b/mathlib4/Mathlib/RingTheory/Ideal/Maps.lean
index 2dd5b2513..fac6d124e 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Maps.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Maps.lean
@@ -868,10 +868,12 @@ lemma Module.mem_annihilator_iff_lsmul_eq_zero {R : Type*} [CommSemiring R]
 instance (priority := low) : (Module.annihilator R M).IsTwoSided :=
   inferInstanceAs (RingHom.ker _).IsTwoSided
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem LinearMap.annihilator_le_of_injective (f : M →ₗ[R] M') (hf : Function.Injective f) :
     Module.annihilator R M' ≤ Module.annihilator R M := fun x h ↦ by
   rw [Module.mem_annihilator] at h ⊢; exact fun m ↦ hf (by rw [map_smul, h, f.map_zero])
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem LinearMap.annihilator_le_of_surjective (f : M →ₗ[R] M')
     (hf : Function.Surjective f) : Module.annihilator R M ≤ Module.annihilator R M' := fun x h ↦ by
   rw [Module.mem_annihilator] at h ⊢
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Basic.lean b/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Basic.lean
index 40e51966a..2bed3a81f 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Basic.lean
@@ -201,6 +201,7 @@ noncomputable def piQuotEquiv [I.IsTwoSided] : ((ι → R) ⧸ pi fun _ ↦ I) 
     exact Ideal.Quotient.eq.2 fun i ↦ Ideal.Quotient.eq.1 (Quotient.out_eq' _)
   right_inv x := funext fun i ↦ Quotient.out_eq' (x i)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `f : R^n → R^m` is an `R`-linear map and `I ⊆ R` is an ideal, then the image of `I^n` is
     contained in `I^m`. -/
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Operations.lean b/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Operations.lean
index f576ed389..6fde85e86 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Operations.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Operations.lean
@@ -466,6 +466,7 @@ section
 
 variable [Semiring B] [Algebra R₁ B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `Ideal.quotient.lift` as an `AlgHom`. -/
 def Quotient.liftₐ (I : Ideal A) [I.IsTwoSided] (f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) :
@@ -501,6 +502,7 @@ lemma Quotient.smul_top {R : Type*} [CommRing R] (a : R) (I : Ideal R) :
     (a • ⊤ : Submodule R (R ⧸ I)) = Submodule.span R {Submodule.Quotient.mk a} := by
   simp [← Ideal.Quotient.span_singleton_one, Algebra.smul_def, Submodule.smul_span]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem KerLift.map_smul (f : A →ₐ[R₁] B) (r : R₁) (x : A ⧸ (RingHom.ker f)) :
     f.kerLift (r • x) = r • f.kerLift x := by
   obtain ⟨a, rfl⟩ := Quotient.mkₐ_surjective R₁ _ x
diff --git a/mathlib4/Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean b/mathlib4/Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
index 4d82e9594..19be15bd5 100644
--- a/mathlib4/Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
@@ -320,6 +320,7 @@ lemma Polynomial.Monic.quotient_isIntegralElem {g : S[X]} (mon : g.Monic) {I : I
   nth_rw 3 [(as_sum_range_C_mul_X_pow g)]
   simp only [map_sum, algebraMap_eq, RingHom.coe_comp, Function.comp_apply, map_mul, map_pow]⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /- If `I` is an ideal of the polynomial ring `S[X]` and contains a monic polynomial `f`,
 then `S[X]/I` is integral over `S`. -/
 lemma Polynomial.Monic.quotient_isIntegral {g : S[X]} (mon : g.Monic) {I : Ideal S[X]} (h : g ∈ I) :
diff --git a/mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean b/mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean
index 4ef8c7a7b..caa59a131 100644
--- a/mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean
+++ b/mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean
@@ -547,6 +547,7 @@ theorem coeff_one [Nontrivial S] : h.coeff 1 = Pi.single 0 1 := by
 theorem coeff_root (hdeg : 1 < natDegree f) : h.coeff h.root = Pi.single 1 1 := by
   rw [← h.coeff_root_pow hdeg, pow_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem coeff_algebraMap [Nontrivial S] (x : R) : h.coeff (algebraMap R S x) = Pi.single 0 x := by
   ext i
   rw [Algebra.algebraMap_eq_smul_one, map_smul, coeff_one, Pi.smul_apply, smul_eq_mul]
diff --git a/mathlib4/Mathlib/RingTheory/IsGaloisGroup/Defs.lean b/mathlib4/Mathlib/RingTheory/IsGaloisGroup/Defs.lean
index c0ae57e8a..ade9e38d7 100644
--- a/mathlib4/Mathlib/RingTheory/IsGaloisGroup/Defs.lean
+++ b/mathlib4/Mathlib/RingTheory/IsGaloisGroup/Defs.lean
@@ -79,6 +79,7 @@ theorem top_iff : IsGaloisGroup (⊤ : Subgroup G) A B ↔ IsGaloisGroup G A B :
 instance [IsGaloisGroup G A B] : IsGaloisGroup (⊤ : Subgroup G) A B :=
   IsGaloisGroup.top_iff.mpr ‹_›
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem of_algEquiv [hG : IsGaloisGroup G A B] (B' : Type*) [Semiring B']
     [Algebra A B'] [MulSemiringAction G B'] (e : B ≃ₐ[A] B')
     (he : ∀ (g : G) (x : B), e (g • x) = g • (e x)) :
diff --git a/mathlib4/Mathlib/RingTheory/IsPrimary.lean b/mathlib4/Mathlib/RingTheory/IsPrimary.lean
index c69a3f470..235bfbd05 100644
--- a/mathlib4/Mathlib/RingTheory/IsPrimary.lean
+++ b/mathlib4/Mathlib/RingTheory/IsPrimary.lean
@@ -114,6 +114,7 @@ section CommRing
 
 variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] {S : Submodule R M}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isPrimary_iff_zero_divisor_quotient_imp_nilpotent_smul :
     S.IsPrimary ↔ S ≠ ⊤ ∧ ∀ (r : R) (x : M ⧸ S), x ≠ 0 → r • x = 0 →
diff --git a/mathlib4/Mathlib/RingTheory/IsTensorProduct.lean b/mathlib4/Mathlib/RingTheory/IsTensorProduct.lean
index 108f9bb12..54acb8728 100644
--- a/mathlib4/Mathlib/RingTheory/IsTensorProduct.lean
+++ b/mathlib4/Mathlib/RingTheory/IsTensorProduct.lean
@@ -174,6 +174,7 @@ variable {R S : Type*} [CommSemiring R] [CommSemiring S] [Algebra R S]
   [Module R M₁₂] [Module S M₁₂] [IsScalarTower R S M₁₂]
   [Module R M₂₃] [Module S M₂₃] [IsScalarTower R S M₂₃]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- (Implementation): Use the more linear `IsTensorProduct.assoc`. -/
@@ -420,6 +421,7 @@ theorem IsBaseChange.equiv_tmul (s : S) (m : M) : h.equiv (s ⊗ₜ m) = s • f
 theorem IsBaseChange.equiv_symm_apply (m : M) : h.equiv.symm (f m) = 1 ⊗ₜ m := by
   rw [h.equiv.symm_apply_eq, h.equiv_tmul, one_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma IsBaseChange.of_equiv (e : S ⊗[R] M ≃ₗ[S] N) (he : ∀ x, e (1 ⊗ₜ x) = f x) :
     IsBaseChange S f := by
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean b/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
index 828517e10..c95350b01 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
@@ -192,6 +192,37 @@ theorem KaehlerDifferential.DLinearMap_apply (s : S) :
       (KaehlerDifferential.ideal R S).toCotangent
         ⟨1 ⊗ₜ s - s ⊗ₜ 1, KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R s⟩ := rfl
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`LinearMap.CompatibleSMul (↥(ideal R S)) (ideal R S).Cotangent S (S ⊗[R] S)`
+It is needed by the two `← LinearMap.map_smul_of_tower (ideal R S).toCotangent` rewrites in
+`leibniz'` below. The `have` just above them does not rescue the search: it is stated for `Ω[S⁄R]`,
+and `(ideal R S).Cotangent =?= Ω[S⁄R]` already fails at `.instances`.
+
+The failure happens while applying `@LinearMap.IsScalarTower.compatibleSMul`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `SMul S (ideal R S).Cotangent`, whereas the assigned value
+`DistribMulAction.toDistribSMul.toSMul` has type `SMul S Ω[S⁄R]`. The comparison bottoms out at
+`@Ideal.Cotangent =?= KaehlerDifferential`,
+where `KaehlerDifferential` is a plain semireducible `def` and therefore does not unfold at the
+`.instances` transparency that instance search runs at. Lean falls back to synthesize an instance of
+the correct type, which succeeds, but it returns `(ideal R S).instSMulCotangentOfAlgebra`, which
+is not defeq to the assigned value, the comparison bottoming out at
+`instSMulKaehlerDifferentialOfSMulCommClass._aux_1 =?= @Ideal.instSMulCotangentOfAlgebra._aux_1`.
+That second comparison also runs at `.instances`, `respectTransparency false` suppressing the
+transparency bump.
+
+Potential fix: mark `KaehlerDifferential` `@[implicit_reducible]` at its definition site.
+Then `instanceTypes false` and `respectTransparency false` can go, but only together: with
+`respectTransparency false` still in place, the comparison stays at `.instances`, where an
+implicit-reducible definition does not unfold, and the search fails as before.
+The `_aux_1` wrappers for the instance fields become implicit-reducible as soon as
+`KaehlerDifferential` is.
+-/
+set_option backward.isDefEq.instanceTypes false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- The universal derivation into `Ω[S⁄R]`. -/
@@ -525,6 +556,7 @@ theorem KaehlerDifferential.derivationQuotKerTotal_apply (x) :
     KaehlerDifferential.derivationQuotKerTotal R S x = 1𝖣x :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem KaehlerDifferential.derivationQuotKerTotal_lift_comp_linearCombination :
     (KaehlerDifferential.derivationQuotKerTotal R S).liftKaehlerDifferential.comp
         (Finsupp.linearCombination S (KaehlerDifferential.D R S)) =
@@ -719,6 +751,7 @@ This is the first map in the exact sequence `B ⊗[A] Ω[A⁄R] → Ω[B⁄R] 
 noncomputable def KaehlerDifferential.mapBaseChange : B ⊗[A] Ω[A⁄R] →ₗ[B] Ω[B⁄R] :=
   (TensorProduct.isBaseChange A Ω[A⁄R] B).lift (KaehlerDifferential.map R R A B)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem KaehlerDifferential.mapBaseChange_tmul (x : B) (y : Ω[A⁄R]) :
     KaehlerDifferential.mapBaseChange R A B (x ⊗ₜ y) = x • KaehlerDifferential.map R R A B y := by
@@ -771,6 +804,7 @@ def KaehlerDifferential.kerToTensor :
     algebraMap_eq_smul_one, RingHom.mem_ker.mp x.prop, TensorProduct.zero_tmul, add_zero,
     RingHom.id_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The map `I/I² → B ⊗[A] Ω[A⁄R]` where `I = ker(A → B)`. -/
 noncomputable
 def KaehlerDifferential.kerCotangentToTensor :
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean b/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
index bd8cf8763..85f8a08c2 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
@@ -263,6 +263,7 @@ lemma δAux_C (r) :
     δAux R Q (C r) = 1 ⊗ₜ D R S r := by
   rw [← monomial_zero', δAux_monomial, Finsupp.prod_zero_index]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable {Q} {Q'} in
 lemma δAux_toAlgHom (f : Hom Q Q') (x) :
@@ -285,6 +286,7 @@ lemma δAux_toAlgHom (f : Hom Q Q') (x) :
     rw [add_left_comm]
     rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma δAux_ofComp (x : (Q.comp P).Ring) :
     δAux R Q ((Q.ofComp P).toAlgHom x) =
@@ -465,6 +467,7 @@ lemma exact_map_δ' (f : Hom W Q) :
   rw [← Extension.H1Cotangent.map_comp, Extension.H1Cotangent.map_eq _ (Q.ofComp P).toExtensionHom]
   exact exact_map_δ Q P
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 open LinearMap in
 lemma liftBaseChange_range_le :
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/Polynomial.lean b/mathlib4/Mathlib/RingTheory/Kaehler/Polynomial.lean
index 0da83d7b5..578b63447 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/Polynomial.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/Polynomial.lean
@@ -26,6 +26,7 @@ suppress_compilation
 
 section MvPolynomial
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The relative differential module of a polynomial algebra `R[σ]` is the free module generated by
 `{ dx | x ∈ σ }`. Also see `KaehlerDifferential.mvPolynomialBasis`. -/
 def KaehlerDifferential.mvPolynomialEquiv (σ : Type*) :
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean b/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
index 82545a22e..173ac31d9 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
@@ -113,6 +113,7 @@ instance [Algebra.IsPushout R S A B] :
       (algebraMap S B r)) • x = r • x
   simp only [Algebra.pushoutDesc_left, Module.End.smul_def, Algebra.lsmul_coe]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma map_liftBaseChange_smul [h : Algebra.IsPushout R S A B] (b : B) (x) :
     ((map R S A B).restrictScalars R).liftBaseChange S (b • x) =
     b • ((map R S A B).restrictScalars R).liftBaseChange S x := by
@@ -126,6 +127,7 @@ lemma map_liftBaseChange_smul [h : Algebra.IsPushout R S A B] (b : B) (x) :
     · simp [smul_comm]
     · simp only [map_add, smul_add, *]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- (Implementation).
 The `S`-derivation `B = S ⊗[R] A` to `S ⊗[R] Ω[A⁄R]` sending `a ⊗ b` to `a ⊗ d b`. -/
 noncomputable
diff --git a/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean b/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
index a3588fdcd..d4f48cf6c 100644
--- a/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
@@ -35,6 +35,7 @@ section
 
 universe u' v'
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open IsLocalizedModule in
 theorem Module.injective_of_isLocalizedModule [Small.{v} R] [IsNoetherianRing R] {Rₛ : Type u'}
     [Small.{v'} Rₛ] [CommRing Rₛ] [Algebra R Rₛ] {Mₛ : Type v'} [AddCommGroup Mₛ] [Module R Mₛ]
diff --git a/mathlib4/Mathlib/RingTheory/LocalProperties/Projective.lean b/mathlib4/Mathlib/RingTheory/LocalProperties/Projective.lean
index d0077f827..cf4d7492d 100644
--- a/mathlib4/Mathlib/RingTheory/LocalProperties/Projective.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalProperties/Projective.lean
@@ -158,6 +158,7 @@ variable
   (f : ∀ (P : Ideal R) [P.IsMaximal], M →ₗ[R] Mₚ P)
   [inst : ∀ (P : Ideal R) [P.IsMaximal], IsLocalizedModule P.primeCompl (f P)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 attribute [local instance] RingHomInvPair.of_ringEquiv RingHomInvPair.of_ringEquiv_symm in
diff --git a/mathlib4/Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean b/mathlib4/Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean
index 93c620109..1cd0d0725 100644
--- a/mathlib4/Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean
@@ -75,6 +75,7 @@ structure on `(p.Fiber S)_q` agrees with the one coming from the fact that `q` l
 instance (q : Ideal (p.Fiber S)) [q.IsPrime] : Localization.AtPrime.IsLiesOverAlgebra p q where
   algebraMap_eq := (Localization.localRingHom_unique p q _ (Ideal.over_def q p) fun _ ↦ rfl).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Fiber.exists_smul_eq_one_tmul (x : p.Fiber S) : ∃ r ∉ p, ∃ s, r • x = 1 ⊗ₜ[R] s := by
   obtain ⟨r, hr, s, e⟩ := Ideal.ResidueField.exists_smul_eq_tmul_one _
     (Algebra.TensorProduct.comm _ _ _ x)
diff --git a/mathlib4/Mathlib/RingTheory/Localization/Basic.lean b/mathlib4/Mathlib/RingTheory/Localization/Basic.lean
index 3ed65e423..77af066bd 100644
--- a/mathlib4/Mathlib/RingTheory/Localization/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Localization/Basic.lean
@@ -130,6 +130,7 @@ section CompatibleSMul
 
 variable (N₁ N₂ : Type*) [AddCommMonoid N₁] [AddCommMonoid N₂] [Module R N₁] [Module R N₂]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (M S) in
 include M in
diff --git a/mathlib4/Mathlib/RingTheory/Localization/Finiteness.lean b/mathlib4/Mathlib/RingTheory/Localization/Finiteness.lean
index 789e01c7c..e02fb4293 100644
--- a/mathlib4/Mathlib/RingTheory/Localization/Finiteness.lean
+++ b/mathlib4/Mathlib/RingTheory/Localization/Finiteness.lean
@@ -45,6 +45,7 @@ variable {R S : Type*} [CommSemiring R] [CommSemiring S] (M : Submonoid R) (f :
 variable (R' S' : Type*) [CommSemiring R'] [CommSemiring S']
 variable [Algebra R R'] [Algebra S S']
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open scoped Classical in
 /-- Let `S` be an `R`-algebra, `M` a submonoid of `R`, and `S' = M⁻¹S`.
diff --git a/mathlib4/Mathlib/RingTheory/Localization/Module.lean b/mathlib4/Mathlib/RingTheory/Localization/Module.lean
index a7ae587f6..da8da87b7 100644
--- a/mathlib4/Mathlib/RingTheory/Localization/Module.lean
+++ b/mathlib4/Mathlib/RingTheory/Localization/Module.lean
@@ -53,6 +53,7 @@ theorem span_eq_top_of_isLocalizedModule {v : Set M} (hv : span R v = ⊤) :
   rw [← LinearMap.coe_restrictScalars R, ← LinearMap.map_span, hv]
   exact mem_map_of_mem mem_top
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem LinearIndependent.of_isLocalizedModule {ι : Type*} {v : ι → M}
     (hv : LinearIndependent R v) : LinearIndependent Rₛ (f ∘ v) := by
@@ -72,6 +73,7 @@ theorem LinearIndependent.of_isLocalizedModule {ι : Type*} {v : ι → M}
   simpa only [map_mul, (IsLocalization.map_units Rₛ s).mul_right_inj, hfg.1 ⟨i, hi⟩, hfg.2 ⟨i, hi⟩,
     Algebra.smul_def, (IsLocalization.map_units Rₛ a).mul_right_inj] using this
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem LinearIndependent.of_isLocalizedModule_of_isRegular {ι : Type*} {v : ι → M}
     (hv : LinearIndependent R v) (h : ∀ s : S, IsRegular (s : R)) : LinearIndependent R (f ∘ v) :=
@@ -89,6 +91,7 @@ theorem LinearIndependent.localization [Module Rₛ M] [IsScalarTower R Rₛ M]
   have := isLocalizedModule_id S M Rₛ
   exact hli.of_isLocalizedModule Rₛ S .id
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 include f in
 lemma IsLocalizedModule.linearIndependent_lift {ι} {v : ι → Mₛ} (hf : LinearIndependent R v) :
diff --git a/mathlib4/Mathlib/RingTheory/Morita/Matrix.lean b/mathlib4/Mathlib/RingTheory/Morita/Matrix.lean
index a02d76851..86f4640f1 100644
--- a/mathlib4/Mathlib/RingTheory/Morita/Matrix.lean
+++ b/mathlib4/Mathlib/RingTheory/Morita/Matrix.lean
@@ -73,6 +73,7 @@ lemma mem_toModuleCatObj (i : ι) {x : M} :
     x ∈ toModuleCatObj R M i ↔ ∃ y : M, single i i (1 : R) • y = x :=
   Iff.rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable {R} in
 /-- An `R`-linear map between `Eᵢᵢ • M` and `Eᵢᵢ • N` induced by an `Mₙ(R)`-linear map
   from `M` to `N`. -/
diff --git a/mathlib4/Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean b/mathlib4/Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
index ff5f4d1f4..a52619d27 100644
--- a/mathlib4/Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
@@ -419,6 +419,7 @@ theorem weightedHomogeneousComponent_mem (w : σ → M) (φ : MvPolynomial σ R)
   rw [mem_weightedHomogeneousSubmodule]
   exact weightedHomogeneousComponent_isWeightedHomogeneous m φ
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem weightedHomogeneousComponent_C_mul (n : M) (r : R) :
     weightedHomogeneousComponent w n (C r * φ) = C r * weightedHomogeneousComponent w n φ := by
diff --git a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Basic.lean b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Basic.lean
index 48a29cd8a..de9af14bf 100644
--- a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Basic.lean
@@ -975,11 +975,13 @@ theorem _root_.MvPowerSeries.prod_smul_X_eq_smul_monomial_one
   · intro x _
     rw [algebra_compatible_smul R, MvPowerSeries.smul_eq_C_mul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.MvPowerSeries.monomial_eq (e : σ →₀ ℕ) (r : σ → R) :
     MvPowerSeries.monomial e (e.prod (fun s n => r s ^ n))
       = e.prod fun s e => (r s • MvPowerSeries.X s) ^ e := by
   rw [MvPowerSeries.prod_smul_X_eq_smul_monomial_one, ← map_smul, smul_eq_mul, mul_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.MvPowerSeries.monomial_smul_const
     {σ : Type*} {R : Type*} [CommSemiring R]
     (e : σ →₀ ℕ) (r : R) :
diff --git a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Order.lean b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Order.lean
index 5590d111e..f179005e6 100644
--- a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Order.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Order.lean
@@ -587,6 +587,7 @@ protected theorem IsWeightedHomogeneous.mul {f g : MvPowerSeries σ R} {p q : 
   apply hd
   rw [← hx, map_add, hp, hq]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The weighted homogeneous components of an `MvPowerSeries f`. -/
 def weightedHomogeneousComponent (p : ℕ) : MvPowerSeries σ R →ₗ[R] MvPowerSeries σ R where
diff --git a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Substitution.lean b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Substitution.lean
index 9fe7b2c38..983defbe4 100644
--- a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Substitution.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Substitution.lean
@@ -710,6 +710,7 @@ theorem rescale_mul (a b : σ → R) : rescale (a * b) = (rescale b).comp (resca
   ext
   simp [← rescale_rescale]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- Rescaling a homogeneous power series -/
 lemma rescale_homogeneous_eq_smul {n : ℕ} {r : R} {f : MvPowerSeries σ R}
diff --git a/mathlib4/Mathlib/RingTheory/NoetherNormalization.lean b/mathlib4/Mathlib/RingTheory/NoetherNormalization.lean
index 60025b2f9..debaa32f8 100644
--- a/mathlib4/Mathlib/RingTheory/NoetherNormalization.lean
+++ b/mathlib4/Mathlib/RingTheory/NoetherNormalization.lean
@@ -78,6 +78,7 @@ noncomputable abbrev T1 (c : k) :
     MvPolynomial (Fin (n + 1)) k →ₐ[k] MvPolynomial (Fin (n + 1)) k :=
   aeval fun i ↦ if i = 0 then X 0 else X i + c • X 0 ^ r i
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma t1_comp_t1_neg (c : k) : (T1 f c).comp (T1 f (-c)) = AlgHom.id _ _ := by
   rw [comp_aeval, ← MvPolynomial.aeval_X_left]
   ext i v
diff --git a/mathlib4/Mathlib/RingTheory/NormTrace.lean b/mathlib4/Mathlib/RingTheory/NormTrace.lean
index 5d36a5568..9af29acbc 100644
--- a/mathlib4/Mathlib/RingTheory/NormTrace.lean
+++ b/mathlib4/Mathlib/RingTheory/NormTrace.lean
@@ -16,6 +16,7 @@ public section
 
 open Module
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Algebra.norm_one_add_smul {A B} [CommRing A] [CommRing B] [Algebra A B]
     [Module.Free A B] [Module.Finite A B] (a : A) (x : B) :
     ∃ r : A, Algebra.norm A (1 + a • x) = 1 + Algebra.trace A B x * a + r * a ^ 2 := by
diff --git a/mathlib4/Mathlib/RingTheory/PiTensorProduct.lean b/mathlib4/Mathlib/RingTheory/PiTensorProduct.lean
index 298b7534a..d044bcccb 100644
--- a/mathlib4/Mathlib/RingTheory/PiTensorProduct.lean
+++ b/mathlib4/Mathlib/RingTheory/PiTensorProduct.lean
@@ -76,6 +76,7 @@ nonrec theorem _root_.Commute.tprod {a₁ a₂ : Π i, A i} (ha : Commute a₁ a
     Commute (tprod R a₁) (tprod R a₂) :=
   ha.tprod
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma smul_tprod_mul_smul_tprod (r s : R) (x y : Π i, A i) :
     (r • tprod R x) * (s • tprod R y) = (r * s) • tprod R (x * y) := by
diff --git a/mathlib4/Mathlib/RingTheory/PicardGroup.lean b/mathlib4/Mathlib/RingTheory/PicardGroup.lean
index 3c5c3e090..6790ec9a5 100644
--- a/mathlib4/Mathlib/RingTheory/PicardGroup.lean
+++ b/mathlib4/Mathlib/RingTheory/PicardGroup.lean
@@ -263,6 +263,7 @@ theorem toModuleEnd_bijective : Function.Bijective (toModuleEnd R (S := R) M) :=
 instance : FaithfulSMul R M where
   eq_of_smul_eq_smul {_ _} h := (toModuleEnd_bijective R M).injective <| LinearMap.ext h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable {R M N} in
 private theorem bijective_self_of_surjective (f : R →ₗ[R] M) (hf : Function.Surjective f) :
     Function.Bijective f where
@@ -796,6 +797,7 @@ instance : Flat R (submoduleAlgebra e) := .of_linearEquiv (submoduleAlgebraEquiv
 instance [Module.Invertible R M] : Module.Invertible R (submoduleAlgebra e) :=
   .congr (submoduleAlgebraEquiv e).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 /-- When a flat `R`-module `M` is embedded as a submodule of a faithful `R`-algebra `A`,
 the multiplication map induces an isomorphism `A ⊗[R] M ≃ₗ[A] A`. -/
@@ -915,6 +917,7 @@ See https://mathoverflow.net/a/499611. -/
 example [IsNoetherianRing R] : ∃ I : Ideal R, Nonempty (M ≃ₗ[R] I) :=
   Module.Invertible.exists_linearEquiv_ideal R M
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable {R} in
 /-- In a total ring of fractions, if two ideals are inverse to each other in the Picard group,
 the only possibility is that they are both the whole ring. -/
diff --git a/mathlib4/Mathlib/RingTheory/Polynomial/DegreeLT.lean b/mathlib4/Mathlib/RingTheory/Polynomial/DegreeLT.lean
index c0d28c96f..6bb866dc0 100644
--- a/mathlib4/Mathlib/RingTheory/Polynomial/DegreeLT.lean
+++ b/mathlib4/Mathlib/RingTheory/Polynomial/DegreeLT.lean
@@ -104,11 +104,13 @@ lemma addLinearEquiv_symm_apply_inr_basis (j : Fin n) :
       basis R (m + n) (j.natAdd m) :=
   (LinearEquiv.symm_apply_eq _).2 (addLinearEquiv_natAdd j).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma addLinearEquiv_symm_apply_inl (P : R[X]_m) :
     ((addLinearEquiv R m n).symm (LinearMap.inl R _ _ P) : R[X]) = (P : R[X]) := by
   rw [← (basis ..).sum_repr P]
   simp [-LinearMap.coe_inl, addLinearEquiv_symm_apply_inl_basis]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma addLinearEquiv_symm_apply_inr (Q : R[X]_n) :
     ((addLinearEquiv R m n).symm (LinearMap.inr R _ _ Q) : R[X]) = (Q : R[X]) * X ^ (m : ℕ) := by
   rw [← (basis ..).sum_repr Q]
diff --git a/mathlib4/Mathlib/RingTheory/Polynomial/Resultant/Basic.lean b/mathlib4/Mathlib/RingTheory/Polynomial/Resultant/Basic.lean
index a49308f17..7c85d8902 100644
--- a/mathlib4/Mathlib/RingTheory/Polynomial/Resultant/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Polynomial/Resultant/Basic.lean
@@ -855,6 +855,7 @@ def adjSylvester (f g : R[X]) :
   (f.sylvester g m n).adjugate.toLin (degreeLT.basis R (m + n))
     (((degreeLT.basis R m).prod (degreeLT.basis R n)).reindex finSumFinEquiv)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma sylveserMap_comp_adjSylvester (f g : R[X]) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n) :
     sylvesterMap f g hf hg ∘ₗ adjSylvester f g = f.resultant g m n • LinearMap.id := by
   let b₁ := ((degreeLT.basis R m).prod (degreeLT.basis R n)).reindex finSumFinEquiv
@@ -863,6 +864,7 @@ lemma sylveserMap_comp_adjSylvester (f g : R[X]) (hf : f.natDegree ≤ m) (hg :
   rwa [Matrix.toLin_mul b₂ b₁ b₂, Matrix.toLin_toMatrix, map_smul,
     toMatrix_sylvesterMap', Matrix.toLin_one, ← resultant] at this
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma adjSylvester_comp_sylveserMap (f g : R[X]) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n) :
     adjSylvester f g ∘ₗ sylvesterMap f g hf hg = f.resultant g m n • LinearMap.id := by
   let b₁ := ((degreeLT.basis R m).prod (degreeLT.basis R n)).reindex finSumFinEquiv
diff --git a/mathlib4/Mathlib/RingTheory/Polynomial/UniversalFactorizationRing.lean b/mathlib4/Mathlib/RingTheory/Polynomial/UniversalFactorizationRing.lean
index b7e440521..97b92d453 100644
--- a/mathlib4/Mathlib/RingTheory/Polynomial/UniversalFactorizationRing.lean
+++ b/mathlib4/Mathlib/RingTheory/Polynomial/UniversalFactorizationRing.lean
@@ -187,7 +187,6 @@ def universalFactorizationMapLiftEquiv (p : MonicDegreeEq S n) :
   left_inv f := by ext <;> simp
   right_inv q := by ext <;> simp
 
-set_option backward.isDefEq.respectTransparency.types false in
 lemma ker_eval₂Hom_universalFactorizationMap :
     RingHom.ker (eval₂Hom (S₁ := MvPolynomial (Fin m) R ⊗[R] MvPolynomial (Fin k) R)
       (universalFactorizationMap R n m k hn) (Sum.elim (.X · ⊗ₜ 1) (1 ⊗ₜ .X ·))) =
@@ -335,6 +334,7 @@ lemma finitePresentation_universalFactorizationMap :
   letI := (universalFactorizationMap R n m k hn).toAlgebra
   (universalFactorizationMapPresentation R n m k hn).finitePresentation_of_isFinite
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma finite_universalFactorizationMap :
     (universalFactorizationMap R n m k hn).Finite := by
@@ -514,7 +514,6 @@ def UniversalFactorizationRing.presentation :
   letI := ((MvPolynomial.mapEquivMonic R _ n).symm p).toAlgebra
   (MvPolynomial.universalFactorizationMapPresentation R n m k hn).baseChange _
 
-set_option backward.isDefEq.respectTransparency.types false in
 lemma UniversalFactorizationRing.jacobian_resentation :
     (presentation m k hn p).jacobian =
       (-1) ^ n * (factor₁ m k hn p).1.resultant (factor₂ m k hn p).1 := by
diff --git a/mathlib4/Mathlib/RingTheory/PolynomialLaw/Basic.lean b/mathlib4/Mathlib/RingTheory/PolynomialLaw/Basic.lean
index d6a797419..7771a0fdc 100644
--- a/mathlib4/Mathlib/RingTheory/PolynomialLaw/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/PolynomialLaw/Basic.lean
@@ -243,6 +243,7 @@ theorem one_tmul_ground_apply' {S : Type u} [CommSemiring S] [Algebra R S] (x :
   · simp only [includeRight_lid]
   · rw [rTensor_tmul, toLinearMap_apply, map_one]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The map ground assigning a function `M → N` to a polynomial map `f : M →ₚₗ[R] N` as a
   linear map. -/
 def lground : (M →ₚₗ[R] N) →ₗ[R] (M → N) where
@@ -555,6 +556,7 @@ theorem toFun_add :
   ext t
   simp only [Pi.add_apply, toFun_add_apply]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toFun_neg {R : Type u} [CommRing R]
     {M : Type*} [AddCommGroup M] [Module R M]
@@ -566,6 +568,7 @@ theorem toFun_neg {R : Type u} [CommRing R]
   obtain ⟨⟨s, p⟩, ha⟩ := π_surjective t
   simp only [toFun_eq_rTensor_φ_toFun' _ ha, neg_def, Pi.smul_apply, map_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable (S) in
 /-- Extension of `PolynomialLaw.smul_def` -/
 @[simp]
diff --git a/mathlib4/Mathlib/RingTheory/PowerBasis.lean b/mathlib4/Mathlib/RingTheory/PowerBasis.lean
index 8dff9019a..4caafa73a 100644
--- a/mathlib4/Mathlib/RingTheory/PowerBasis.lean
+++ b/mathlib4/Mathlib/RingTheory/PowerBasis.lean
@@ -247,6 +247,7 @@ section Equiv
 
 variable [Algebra A S] {S' : Type*} [Ring S'] [Algebra A S']
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem constr_pow_aeval (pb : PowerBasis A S) {y : S'} (hy : aeval y (minpoly A pb.gen) = 0)
     (f : A[X]) : pb.basis.constr A (fun i => y ^ (i : ℕ)) (aeval pb.gen f) = aeval y f := by
   cases subsingleton_or_nontrivial A
diff --git a/mathlib4/Mathlib/RingTheory/QuasiFinite/Weakly.lean b/mathlib4/Mathlib/RingTheory/QuasiFinite/Weakly.lean
index 32073e6d2..6e0de5feb 100644
--- a/mathlib4/Mathlib/RingTheory/QuasiFinite/Weakly.lean
+++ b/mathlib4/Mathlib/RingTheory/QuasiFinite/Weakly.lean
@@ -225,6 +225,7 @@ lemma of_restrictScalars [Algebra S T] [IsScalarTower R S T]
   refine .trans ?_ (Ideal.comap_map_of_surjective _ Ideal.Quotient.mk_surjective _).symm
   simp [← RingHom.ker_eq_comap_bot, Ideal.map_comap_le]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Use `Algebra.QuasiFinite.of_quasiFiniteAt_residueField` instead
 for `Algebra.QuasiFiniteAt R q`. -/
 lemma of_quasiFiniteAt_residueField [p.IsPrime] [q.LiesOver p]
diff --git a/mathlib4/Mathlib/RingTheory/Regular/Free.lean b/mathlib4/Mathlib/RingTheory/Regular/Free.lean
index 8c268f5df..ae0dade9f 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/Free.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/Free.lean
@@ -29,6 +29,7 @@ instance [Module.Free R M] (x : R) : Module.Free (R ⧸ Ideal.span {x}) (QuotSMu
   Module.Free.of_equiv ((QuotSMulTop.equivQuotTensor x M).extendScalarsOfSurjective
     Ideal.Quotient.mk_surjective).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 open Pointwise in
 lemma Module.free_quotSMulTop_iff_free [Module.FinitePresentation R M] {x : R}
     (mem : x ∈ (⊥ : Ideal R).jacobson) (reg : IsSMulRegular M x) :
diff --git a/mathlib4/Mathlib/RingTheory/Regular/IsSMulRegular.lean b/mathlib4/Mathlib/RingTheory/Regular/IsSMulRegular.lean
index 89b9259c3..b96ee4fb5 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/IsSMulRegular.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/IsSMulRegular.lean
@@ -45,6 +45,7 @@ end Congr
 
 variable {R S M M' M'' : Type*}
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma IsSMulRegular.submodule [Semiring R] [AddCommMonoid M] [Module R M]
     (N : Submodule R M) (r : R) (h : IsSMulRegular M r) : IsSMulRegular N r :=
   h.of_injective N.subtype N.injective_subtype
@@ -80,6 +81,7 @@ lemma isSMulRegular_submodule_iff_right_eq_zero_of_smul :
     Subtype.forall.trans <| by
       simp only [SetLike.mk_smul_mk, Submodule.mk_eq_zero]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma isSMulRegular_quotient_iff_mem_of_smul_mem :
     IsSMulRegular (M ⧸ N) r ↔ ∀ x : M, r • x ∈ N → x ∈ N :=
   isSMulRegular_iff_right_eq_zero_of_smul.trans <|
@@ -168,6 +170,7 @@ lemma smul_top_inf_eq_smul_of_isSMulRegular_on_quot :
   exact Eq.trans (congrArg (· ⊓ N) (map_top _)) (map_comap_eq _ _).symm
 
 -- Who knew this didn't rely on exactness at the right!?
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 open Function in
 lemma QuotSMulTop.map_first_exact_on_four_term_exact_of_isSMulRegular_last
diff --git a/mathlib4/Mathlib/RingTheory/Regular/LinearMap.lean b/mathlib4/Mathlib/RingTheory/Regular/LinearMap.lean
index 9835b4202..321374bb1 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/LinearMap.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/LinearMap.lean
@@ -36,6 +36,7 @@ namespace IsSMulRegular
 
 variable {R M N : Type*} [CommRing R] [AddCommGroup M] [AddCommGroup N] [Module R M] [Module R N]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma linearMap_subsingleton_of_mem_annihilator {r : R} (reg : IsSMulRegular M r)
     (mem_ann : r ∈ Module.annihilator R N) : Subsingleton (N →ₗ[R] M) := by
   apply subsingleton_of_forall_eq 0 (fun f ↦ ext fun x ↦ ?_)
diff --git a/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean b/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
index ed3d5210b..3da23274d 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
@@ -571,8 +571,39 @@ lemma map_first_exact_on_four_term_right_exact_of_isSMulRegular_last
 
 section Perm
 
+#adaptation_note
+/--
+We had to use the `instanceTypes` backward compatibility flag to make an instance search succeed.
+Concretely, the following instance cannot be synthesized:
+`FunLike (M ⧸ torsionBy R M b →ₗ[R] M) (M ⧸ torsionBy R M b) M`
+It is needed by the `ha.of_injective _ <| ker_eq_bot.mp <| ker_liftQ_eq_bot' _ (lsmul R M b) rfl`
+below.
+
+The failure happens while applying `@LinearMap.instFunLike`: assigning one of its
+instance-implicit-argument metavariables is rejected because the metavariable's type and the type
+of the assigned value do not match at `.instances` transparency. The metavariable's expected type
+is `Module R (M ⧸ torsionBy R M b)`, whereas the assigned value
+`Quotient.module ((lsmul R M) b).ker` has type `Module R (M ⧸ ((lsmul R M) b).ker)`.
+Lean falls back to synthesize an instance of the correct type, which succeeds, but it returns
+`Quotient.module (torsionBy R M b)`, which is again not defeq to the assigned value.
+That second comparison runs at `.implicit`.
+
+Potential fix: make the following definitions implicit-reducible:
+
+```
+torsionBy
+DistribSMul.toLinearMap
+LinearMap.lsmul
+LinearMap.mk₂
+LinearMap.mk₂'
+LinearMap.mk₂'ₛₗ
+```
+
+Then both backward compatibility options can go.
+-/
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.isDefEq.respectTransparency.outParams false in
+set_option backward.isDefEq.instanceTypes false in
 open _root_.LinearMap in
 private lemma IsWeaklyRegular.swap {a b : R} (h1 : IsWeaklyRegular M [a, b])
     (h2 : torsionBy R M b = a • torsionBy R M b → torsionBy R M b = ⊥) :
diff --git a/mathlib4/Mathlib/RingTheory/SimpleModule/Basic.lean b/mathlib4/Mathlib/RingTheory/SimpleModule/Basic.lean
index 99af6ae41..6e4e7e9b4 100644
--- a/mathlib4/Mathlib/RingTheory/SimpleModule/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/SimpleModule/Basic.lean
@@ -565,6 +565,7 @@ open Submodule
 variable [IsSemisimpleModule R M]
 
 -- Statement and proof follow [Lorenz2008], Chapter 28, F20.
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem jacobson_density (f : End (End R M) M) (s : Finset M) :
     ∃ r : R, ∀ m ∈ s, f m = r • m :=
   let x := Finsupp.equivFunOnFinite.symm (·.1 : s → M)
@@ -576,6 +577,7 @@ theorem jacobson_density (f : End (End R M) M) (s : Finset M) :
   have ⟨r, hr⟩ := mem_span_singleton.mp this
   ⟨r, fun m hm ↦ by simpa [x] using! congr($hr ⟨m, hm⟩).symm⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The Jacobson density theorem for a module finite over its endomorphism ring. -/
 protected theorem Module.Finite.toModuleEnd_moduleEnd_surjective [Module.Finite (End R M) M] :
diff --git a/mathlib4/Mathlib/RingTheory/Smooth/Basic.lean b/mathlib4/Mathlib/RingTheory/Smooth/Basic.lean
index 696c5eb87..122bd4fb8 100644
--- a/mathlib4/Mathlib/RingTheory/Smooth/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Smooth/Basic.lean
@@ -455,6 +455,7 @@ variable {R : Type*} [CommRing R]
 variable {A : Type*} [CommRing A] [Algebra R A]
 variable (B : Type*) [CommRing B] [Algebra R B]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 instance [FormallySmooth R A] : FormallySmooth B (B ⊗[R] A) := by
   refine .of_comp_surjective fun C _ _ I hI f ↦ ?_
diff --git a/mathlib4/Mathlib/RingTheory/Smooth/Kaehler.lean b/mathlib4/Mathlib/RingTheory/Smooth/Kaehler.lean
index 57ca05e5b..a0dd1ef5c 100644
--- a/mathlib4/Mathlib/RingTheory/Smooth/Kaehler.lean
+++ b/mathlib4/Mathlib/RingTheory/Smooth/Kaehler.lean
@@ -151,6 +151,7 @@ variable [Algebra R S] [IsScalarTower R P S]
 variable (hf' : (RingHom.ker (algebraMap P S)) ^ 2 = ⊥)
 include hf'
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 Given a surjective algebra homomorphism `f : P →ₐ[R] S` with square-zero kernel `I`.
 Let `σ` be an arbitrary (set-theoretic) section of `f`.
diff --git a/mathlib4/Mathlib/RingTheory/Smooth/Quotient.lean b/mathlib4/Mathlib/RingTheory/Smooth/Quotient.lean
index ab8e81d72..70d8992f8 100644
--- a/mathlib4/Mathlib/RingTheory/Smooth/Quotient.lean
+++ b/mathlib4/Mathlib/RingTheory/Smooth/Quotient.lean
@@ -72,6 +72,7 @@ private lemma comap_ker_eq_sup_of_ker_eq_map (surjRS : Function.Surjective (alge
       ← RingHom.comap_ker]
   simp [eqmap, Ideal.comap_map_of_surjective' _ surjRS]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma mul_le_ker_of_range_le_mul_of_sq_zero {J I : Ideal R} (sq : I ^ 2 = ⊥)
     (f : J.Cotangent →ₗ[R] J.Cotangent)
     (le : f.range ≤ (Submodule.comap J.subtype (I * J)).map J.toCotangent) :
@@ -94,6 +95,7 @@ private lemma mul_le_ker_of_range_le_mul_of_sq_zero {J I : Ideal R} (sq : I ^ 2
   rcases Submodule.mem_map.mp hx with ⟨x', hx', eq⟩
   simpa [← eq] using this hx'
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- For flat ring homomorphism `f : R →+* S`, `I` an ideal of `R` which is square zero,
 if `R ⧸ I →+* S ⧸ IS` is formally smooth, so is `f`. -/
diff --git a/mathlib4/Mathlib/RingTheory/Support.lean b/mathlib4/Mathlib/RingTheory/Support.lean
index 4a8562f9b..928b73bd0 100644
--- a/mathlib4/Mathlib/RingTheory/Support.lean
+++ b/mathlib4/Mathlib/RingTheory/Support.lean
@@ -168,6 +168,7 @@ lemma Module.support_subset_of_surjective (hf : Function.Surjective f) :
   obtain ⟨m, rfl⟩ := hf m
   exact ⟨m, fun r hr e ↦ hm r hr (by simpa using congr(f $e))⟩
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 variable {f g} in
 /-- Given an exact sequence `0 → M → N → P → 0` of `R`-modules, `Supp N = Supp M ∪ Supp P`. -/
 @[stacks 00L3 "(4)"]
diff --git a/mathlib4/Mathlib/RingTheory/TensorProduct/IsBaseChangeFree.lean b/mathlib4/Mathlib/RingTheory/TensorProduct/IsBaseChangeFree.lean
index 6d345c2ab..28b33d892 100644
--- a/mathlib4/Mathlib/RingTheory/TensorProduct/IsBaseChangeFree.lean
+++ b/mathlib4/Mathlib/RingTheory/TensorProduct/IsBaseChangeFree.lean
@@ -44,6 +44,7 @@ theorem basis_apply (i) : ibc.basis b i = ε (b i) := by
     simp [LinearEquiv.symm_apply_eq, IsBaseChange.equiv_tmul]
   simp [this, IsBaseChange.equiv_tmul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem basis_repr_comp_apply (v i) :
     (ibc.basis b).repr (ε v) i = algebraMap R S (b.repr v i) := by
diff --git a/mathlib4/Mathlib/RingTheory/Trace/Basic.lean b/mathlib4/Mathlib/RingTheory/Trace/Basic.lean
index f0706b9cc..4cbc47aea 100644
--- a/mathlib4/Mathlib/RingTheory/Trace/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Trace/Basic.lean
@@ -382,6 +382,7 @@ theorem traceMatrix_of_basis [Fintype κ] [DecidableEq κ] (b : Basis κ A B) :
   ext (i j)
   rw [traceMatrix_apply, traceForm_apply, traceForm_toMatrix]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem traceMatrix_of_basis_mulVec [Fintype ι] (b : Basis ι A B) (z : B) :
     traceMatrix A b *ᵥ b.equivFun z = fun i => trace A B (z * b i) := by
   ext i
diff --git a/mathlib4/Mathlib/RingTheory/Unramified/Field.lean b/mathlib4/Mathlib/RingTheory/Unramified/Field.lean
index f7256c8fe..0f30f7dcf 100644
--- a/mathlib4/Mathlib/RingTheory/Unramified/Field.lean
+++ b/mathlib4/Mathlib/RingTheory/Unramified/Field.lean
@@ -58,6 +58,7 @@ theorem of_isSeparable [Algebra.IsSeparable K L] : FormallyUnramified K L := by
 variable [FormallyUnramified K A] [EssFiniteType K A]
 variable [FormallyUnramified K L] [EssFiniteType K L]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 theorem bijective_of_isAlgClosed_of_isLocalRing
     [IsAlgClosed K] [IsLocalRing A] :
     Function.Bijective (algebraMap K A) := by
diff --git a/mathlib4/Mathlib/RingTheory/Unramified/Finite.lean b/mathlib4/Mathlib/RingTheory/Unramified/Finite.lean
index 28ef842ef..68b7a66ad 100644
--- a/mathlib4/Mathlib/RingTheory/Unramified/Finite.lean
+++ b/mathlib4/Mathlib/RingTheory/Unramified/Finite.lean
@@ -83,6 +83,7 @@ theorem iff_exists_tensorProduct [EssFiniteType R S] :
       use 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1
       linear_combination ht₁ s
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma finite_of_free_aux (I) [DecidableEq I] (b : Basis I R S)
     (f : I →₀ S) (x : S) (a : I → I →₀ R) (ha : a = fun i ↦ b.repr (b i * x)) :
     (1 ⊗ₜ[R] x * Finsupp.sum f fun i y ↦ y ⊗ₜ[R] b i) =
diff --git a/mathlib4/Mathlib/Tactic/NormNum/Basic.lean b/mathlib4/Mathlib/Tactic/NormNum/Basic.lean
index 93a721204..3418d30d3 100644
--- a/mathlib4/Mathlib/Tactic/NormNum/Basic.lean
+++ b/mathlib4/Mathlib/Tactic/NormNum/Basic.lean
@@ -559,10 +559,12 @@ theorem isRat_div {α : Type u} [DivisionRing α] : {a b : α} → {cn : ℤ} 
     IsRat (a * b⁻¹) cn cd → IsRat (a / b) cn cd
   | _, _, _, _, h => by simpa [div_eq_mul_inv] using h
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Helper function to synthesize a typed `DivisionSemiring α` expression. -/
 def inferDivisionSemiring {u : Level} (α : Q(Type u)) : MetaM Q(DivisionSemiring $α) :=
   return ← synthInstanceQ q(DivisionSemiring $α) <|> throwError "not a division semiring"
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Helper function to synthesize a typed `DivisionRing α` expression. -/
 def inferDivisionRing {u : Level} (α : Q(Type u)) : MetaM Q(DivisionRing $α) :=
   return ← synthInstanceQ q(DivisionRing $α) <|> throwError "not a division ring"
diff --git a/mathlib4/Mathlib/Tactic/NormNum/BigOperators.lean b/mathlib4/Mathlib/Tactic/NormNum/BigOperators.lean
index 1014da66c..74cc03e56 100644
--- a/mathlib4/Mathlib/Tactic/NormNum/BigOperators.lean
+++ b/mathlib4/Mathlib/Tactic/NormNum/BigOperators.lean
@@ -350,6 +350,7 @@ partial def evalFinsetBigop {α : Q(Type u)} {β : Q(Type v)}
       let eq : Q($op $s $f = $op (Finset.cons $a $s' $h) $f) := q(congr_fun (congr_arg _ $pf) _)
       pure (res.eq_trans eq)
 
+set_option backward.isDefEq.respectTransparency.instances false in
 attribute [local instance] monadLiftOptionMetaM in
 /-- `norm_num` plugin for evaluating products of finsets.
 
@@ -379,6 +380,7 @@ partial def evalFinsetProd : NormNumExt where eval {u β} e := do
       pure <| res.eq_trans eq)
     s
 
+set_option backward.isDefEq.respectTransparency.instances false in
 attribute [local instance] monadLiftOptionMetaM in
 /-- `norm_num` plugin for evaluating sums of finsets.
 
diff --git a/mathlib4/Mathlib/Tactic/NormNum/Inv.lean b/mathlib4/Mathlib/Tactic/NormNum/Inv.lean
index bfc8ad2f2..4abcded32 100644
--- a/mathlib4/Mathlib/Tactic/NormNum/Inv.lean
+++ b/mathlib4/Mathlib/Tactic/NormNum/Inv.lean
@@ -20,6 +20,7 @@ namespace Mathlib.Meta.NormNum
 
 open Lean.Meta Qq
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Helper function to synthesize a typed `CharZero α` expression given `Ring α`. -/
 def inferCharZeroOfRing {α : Q(Type u)} (_i : Q(Ring $α) := by with_reducible assumption) :
     MetaM Q(CharZero $α) :=
@@ -31,6 +32,7 @@ def inferCharZeroOfRing? {α : Q(Type u)} (_i : Q(Ring $α) := by with_reducible
     MetaM (Option Q(CharZero $α)) :=
   return (← trySynthInstanceQ q(CharZero $α)).toOption
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Helper function to synthesize a typed `CharZero α` expression given `AddMonoidWithOne α`. -/
 def inferCharZeroOfAddMonoidWithOne {α : Q(Type u)}
     (_i : Q(AddMonoidWithOne $α) := by with_reducible assumption) : MetaM Q(CharZero $α) :=
@@ -44,6 +46,7 @@ def inferCharZeroOfAddMonoidWithOne? {α : Q(Type u)}
       MetaM (Option Q(CharZero $α)) :=
   return (← trySynthInstanceQ q(CharZero $α)).toOption
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Helper function to synthesize a typed `CharZero α` expression given `DivisionRing α`. -/
 def inferCharZeroOfDivisionRing {α : Q(Type u)}
     (_i : Q(DivisionRing $α) := by with_reducible assumption) : MetaM Q(CharZero $α) :=
diff --git a/mathlib4/Mathlib/Tactic/NormNum/Result.lean b/mathlib4/Mathlib/Tactic/NormNum/Result.lean
index 8583027f5..d5163f6b0 100644
--- a/mathlib4/Mathlib/Tactic/NormNum/Result.lean
+++ b/mathlib4/Mathlib/Tactic/NormNum/Result.lean
@@ -51,15 +51,18 @@ def instAddMonoidWithOne {α : Type u} [Ring α] : AddMonoidWithOne α := inferI
 /-- A shortcut (non)instance for `Nat.AtLeastTwo (n + 2)` to shrink generated proofs. -/
 lemma instAtLeastTwo (n : ℕ) : Nat.AtLeastTwo (n + 2) := inferInstance
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Helper function to synthesize a typed `AddMonoidWithOne α` expression. -/
 meta def inferAddMonoidWithOne (α : Q(Type u)) : MetaM Q(AddMonoidWithOne $α) :=
   return ← synthInstanceQ q(AddMonoidWithOne $α) <|>
     throwError "not an AddMonoidWithOne"
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Helper function to synthesize a typed `Semiring α` expression. -/
 meta def inferSemiring (α : Q(Type u)) : MetaM Q(Semiring $α) :=
   return ← synthInstanceQ q(Semiring $α) <|> throwError "not a semiring"
 
+set_option backward.isDefEq.respectTransparency.instances false in
 /-- Helper function to synthesize a typed `Ring α` expression. -/
 meta def inferRing (α : Q(Type u)) : MetaM Q(Ring $α) :=
   return ← synthInstanceQ q(Ring $α) <|> throwError "not a ring"
diff --git a/mathlib4/Mathlib/Topology/Algebra/Algebra.lean b/mathlib4/Mathlib/Topology/Algebra/Algebra.lean
index 7b4f51e59..ae779e6b9 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Algebra.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Algebra.lean
@@ -217,6 +217,7 @@ protected theorem map_zero (f : A →A[R] B) : f (0 : A) = 0 := map_zero f
 
 protected theorem map_add (f : A →A[R] B) (x y : A) : f (x + y) = f x + f y := map_add f x y
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem map_smul (f : A →A[R] B) (c : R) (x : A) :
     f (c • x) = c • f x :=
   map_smul ..
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/ContinuousLinearMap/Basic.lean b/mathlib4/Mathlib/Topology/Algebra/Module/ContinuousLinearMap/Basic.lean
index 2f0b3d8ff..28ce81e1a 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/ContinuousLinearMap/Basic.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/ContinuousLinearMap/Basic.lean
@@ -658,6 +658,7 @@ instance applyFaithfulSMul : FaithfulSMul (M₁ →L[R₁] M₁) M₁ :=
 instance applySMulCommClass : SMulCommClass R₁ (M₁ →L[R₁] M₁) M₁ where
   smul_comm r e m := (e.map_smul r m).symm
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 instance applySMulCommClass' : SMulCommClass (M₁ →L[R₁] M₁) R₁ M₁ where
   smul_comm := map_smul
 
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimension.lean b/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimension.lean
index 384955324..bbd9e7973 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimension.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimension.lean
@@ -148,6 +148,7 @@ theorem unique_topology_of_t2 {t : TopologicalSpace 𝕜} (h₁ : @IsTopological
           tendsto_id (1 : 𝕜))
       _ = @nhds 𝕜 t 0 := by rw [zero_smul]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Any linear form on a topological vector space over a nontrivially normed field is continuous if
 its kernel is closed. -/
 theorem LinearMap.continuous_of_isClosed_ker (l : E →ₗ[𝕜] 𝕜)
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimensionBilinear.lean b/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimensionBilinear.lean
index c93784a24..828898571 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimensionBilinear.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimensionBilinear.lean
@@ -33,6 +33,7 @@ variable
     {G : Type*} [AddCommGroup G] [Module 𝕜 G] [TopologicalSpace G]
     [IsTopologicalAddGroup G] [ContinuousSMul 𝕜 G]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Building continuous bilinear maps from bilinear maps between finite dimensional topological
   vector spaces over a complete field. -/
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/IsWeak.lean b/mathlib4/Mathlib/Topology/Algebra/Module/IsWeak.lean
index a3bd4fe91..2b6a245bd 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/IsWeak.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/IsWeak.lean
@@ -152,6 +152,7 @@ theorem continuousAdd [ContinuousAdd 𝕜] : ContinuousAdd E where
     simp only [Function.comp_def, map_add, add_apply]
     fun_prop
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 include hB in
 /-- Scalar multiplication in `E` is continuous when `E` is equipped with a `LinearMap.IsWeak`
 topology. -/
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/Spaces/CharacterSpace.lean b/mathlib4/Mathlib/Topology/Algebra/Module/Spaces/CharacterSpace.lean
index 50bcaaf52..432a1041e 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/Spaces/CharacterSpace.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/Spaces/CharacterSpace.lean
@@ -84,6 +84,7 @@ def toCLM (φ : characterSpace 𝕜 A) : A →L[𝕜] 𝕜 :=
 theorem coe_toCLM (φ : characterSpace 𝕜 A) : ⇑(toCLM φ) = φ :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Elements of the character space are non-unital algebra homomorphisms. -/
 instance instNonUnitalAlgHomClass : NonUnitalAlgHomClass (characterSpace 𝕜 A) 𝕜 A 𝕜 :=
   { CharacterSpace.instContinuousLinearMapClass with
@@ -91,6 +92,7 @@ instance instNonUnitalAlgHomClass : NonUnitalAlgHomClass (characterSpace 𝕜 A)
     map_zero := fun φ => map_zero φ
     map_mul := fun φ => φ.prop.2 }
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An element of the character space, as a non-unital algebra homomorphism. -/
 noncomputable def toNonUnitalAlgHom (φ : characterSpace 𝕜 A) : A →ₙₐ[𝕜] 𝕜 where
   toFun := (φ : A → 𝕜)
@@ -135,6 +137,7 @@ section Unital
 variable [CommRing 𝕜] [NoZeroDivisors 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜]
   [ContinuousConstSMul 𝕜 𝕜] [TopologicalSpace A] [Semiring A] [Algebra 𝕜 A]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- In a unital algebra, elements of the character space are algebra homomorphisms. -/
 instance instAlgHomClass : AlgHomClass (characterSpace 𝕜 A) 𝕜 A 𝕜 :=
   haveI map_one' : ∀ φ : characterSpace 𝕜 A, φ 1 = 1 := fun φ => by
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean b/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
index 4b61e1077..fbf347944 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
@@ -52,6 +52,7 @@ variable (𝕜 α E H : Type*) {hom : Type*} [NormedField 𝕜] [AddCommGroup H]
   [ContinuousSMul 𝕜 E] {𝔖 : Set <| Set α}
   [FunLike hom H (α → E)] [LinearMapClass hom 𝕜 H (α → E)]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Let `E` be a topological vector space over a normed field `𝕜`, let `α` be any type.
 Let `H` be a submodule of `α →ᵤ E` such that the range of each `f ∈ H` is von Neumann bounded.
@@ -87,6 +88,7 @@ lemma UniformFun.continuousSMul_induced_of_range_bounded (φ : hom)
     simp only [Set.mem_ofPred_eq, map_smul, Pi.smul_apply]
     simpa only [Set.mapsTo_range_iff] using (h u hU).eventually_nhds_zero (mem_of_mem_nhds hU)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
 `S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
 equipped with the topology of `𝔖`-convergence, is a TVS.
diff --git a/mathlib4/Mathlib/Topology/Algebra/MulAction.lean b/mathlib4/Mathlib/Topology/Algebra/MulAction.lean
index ce466c4e9..7efa23072 100644
--- a/mathlib4/Mathlib/Topology/Algebra/MulAction.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/MulAction.lean
@@ -95,6 +95,7 @@ instance OrderDual.instContinuousSMul_left : ContinuousSMul Mᵒᵈ X where
 instance (priority := 100) ContinuousSMul.continuousConstSMul : ContinuousConstSMul M X where
   continuous_const_smul _ := continuous_smul.comp (continuous_const.prodMk continuous_id)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem ContinuousSMul.induced {R : Type*} {α : Type*} {β : Type*} {F : Type*} [FunLike F α β]
     [Semiring R] [AddCommMonoid α] [AddCommMonoid β] [Module R α] [Module R β]
diff --git a/mathlib4/Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean b/mathlib4/Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
index 37c048e5b..f22e43881 100644
--- a/mathlib4/Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
+++ b/mathlib4/Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
@@ -527,6 +527,7 @@ theorem good_lt_maxProducts (q : GoodProducts (π C (ord I · < o)))
     simp only [term, Ordinal.typein_enum]
     exact Products.prop_of_isGood C _ q.prop q.val.val.head! (List.head!_mem_self h)
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 include hC hsC in
 /--
diff --git a/mathlib4/Mathlib/Topology/Category/TopCat/Monoidal.lean b/mathlib4/Mathlib/Topology/Category/TopCat/Monoidal.lean
index a75e372c1..377c44aa5 100644
--- a/mathlib4/Mathlib/Topology/Category/TopCat/Monoidal.lean
+++ b/mathlib4/Mathlib/Topology/Category/TopCat/Monoidal.lean
@@ -130,10 +130,14 @@ def homeomorph : I ≃ₜ unitInterval := Homeomorph.ulift
 lemma ext {x y : I.{u}} (h : homeomorph x = homeomorph y) : x = y :=
   homeomorph.injective h
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The symmetrization map `TopCat.I ⟶ TopCat.I`. -/
 def symm : I.{u} ⟶ I :=
   ofHom ⟨homeomorph.symm ∘ unitInterval.symm ∘ homeomorph, by fun_prop⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma homeomorph_symm (x : I) :
     homeomorph (symm x) = unitInterval.symm (homeomorph x) := rfl
@@ -141,6 +145,8 @@ lemma homeomorph_symm (x : I) :
 instance : OfNat I.{u} 0 := ⟨homeomorph.symm 0⟩
 instance : OfNat I.{u} 1 := ⟨homeomorph.symm 1⟩
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma homeomorph_zero : homeomorph (0 : I.{u}) = 0 := by simp [OfNat.ofNat]
 @[simp] lemma homeomorph_one : homeomorph (1 : I.{u}) = 1 := by simp [OfNat.ofNat]
 @[simp] lemma symm_one : I.symm 1 = 0 := by aesop
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/CompactlySupported.lean b/mathlib4/Mathlib/Topology/ContinuousMap/CompactlySupported.lean
index ddb70bfdd..b700fa12a 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/CompactlySupported.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/CompactlySupported.lean
@@ -794,6 +794,7 @@ end toNNRealLinear
 
 section toRealPositiveLinear
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- For a positive linear functional `Λ : C_c(α, ℝ≥0) → ℝ≥0`, define a positive `ℝ`-linear map. -/
 noncomputable def toRealPositiveLinear (Λ : C_c(α, ℝ≥0) →ₗ[ℝ≥0] ℝ≥0) : C_c(α, ℝ) →ₚ[ℝ] ℝ :=
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/ContinuousMapZero.lean b/mathlib4/Mathlib/Topology/ContinuousMap/ContinuousMapZero.lean
index ce0246b22..41d4b745b 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/ContinuousMapZero.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/ContinuousMapZero.lean
@@ -444,6 +444,7 @@ def nonUnitalStarAlgHom_precomp (f : C(X, Y)₀) : C(Y, R)₀ →⋆ₙₐ[R] C(
   map_star' _ := rfl
   map_smul' _ _ := rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (X) in
 /-- The functor `C(X, ·)₀` from non-unital topological star algebras (with non-unital continuous
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/Star.lean b/mathlib4/Mathlib/Topology/ContinuousMap/Star.lean
index 27143ab13..c491658af 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/Star.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/Star.lean
@@ -155,6 +155,7 @@ variable (𝕜 : Type*) [CommSemiring 𝕜]
 variable (A : Type*) [TopologicalSpace A] [Semiring A] [IsTopologicalSemiring A] [StarRing A]
 variable [ContinuousStar A] [Algebra 𝕜 A]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `ContinuousMap.compStarAlgHom'` as a `StarAlgEquiv` when the continuous map `f` is
 actually a homeomorphism. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean b/mathlib4/Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean
index bb86c4ef0..ccbcb4bf2 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean
@@ -556,6 +556,7 @@ lemma adjoin_id_eq_span_one_add (s : Set 𝕜) :
     StarAlgebra.adjoin_nonUnitalStarSubalgebra_eq_span, mem_sup]
   simp [Set.mem_add]
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma nonUnitalStarAlgebraAdjoin_id_subset_ker_evalStarAlgHom {s : Set 𝕜} (h0 : 0 ∈ s) :
     (adjoin 𝕜 {restrict s (.id 𝕜)} : Set C(s, 𝕜)) ⊆
       RingHom.ker (evalStarAlgHom 𝕜 𝕜 (⟨0, h0⟩ : s)) := by
@@ -593,6 +594,7 @@ lemma ker_evalStarAlgHom_inter_adjoin_id (s : Set 𝕜) (h0 : 0 ∈ s) :
 
 set_option backward.isDefEq.respectTransparency false in
 -- the statement should be in terms of nonunital subalgebras, but we lack API
+set_option backward.isDefEq.respectTransparency.outParams false in
 open RingHom Filter Topology in
 theorem AlgHom.closure_ker_inter {F S K A : Type*} [CommRing K] [Ring A] [Algebra K A]
     [TopologicalSpace K] [T1Space K] [TopologicalSpace A] [ContinuousSub A] [ContinuousSMul K A]
@@ -679,6 +681,7 @@ theorem ContinuousMapZero.induction_on_of_compact {s : Set 𝕜} [Fact (0 ∈ s)
   have := (ContinuousMapZero.adjoin_id_dense s).closure_eq ▸ Set.mem_univ (x := f)
   exact mem_closure_iff_frequently.mp this |>.mp <| .of_forall h
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ContinuousMapZero.nonUnitalStarAlgHom_apply_mul_eq_zero {𝕜 A : Type*}
     [RCLike 𝕜] [NonUnitalSemiring A] [Star A] [TopologicalSpace A] [SeparatelyContinuousMul A]
     [T2Space A] [DistribMulAction 𝕜 A] [IsScalarTower 𝕜 A A] {s : Set 𝕜} [Fact (0 ∈ s)]
@@ -694,6 +697,7 @@ lemma ContinuousMapZero.nonUnitalStarAlgHom_apply_mul_eq_zero {𝕜 A : Type*}
   | smul _ _ h => rw [map_smul, smul_mul_assoc, h, smul_zero]
   | frequently f h => exact h.mem_of_closed <| isClosed_eq (by fun_prop) continuous_zero
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ContinuousMapZero.mul_nonUnitalStarAlgHom_apply_eq_zero {𝕜 A : Type*}
     [RCLike 𝕜] [NonUnitalSemiring A] [Star A] [TopologicalSpace A] [SeparatelyContinuousMul A]
     [T2Space A] [DistribMulAction 𝕜 A] [SMulCommClass 𝕜 A A] {s : Set 𝕜} [Fact (0 ∈ s)]
diff --git a/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean b/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
index 082aed9d9..2924f474d 100644
--- a/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
+++ b/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
@@ -660,6 +660,8 @@ theorem eVariationOn_on_inter_Iic_eq_Iio_add_edist
       sum_le_of_monotoneOn_Iic (by grind [MonotoneOn, StrictMonoOn]) (by grind)
     exact A.trans B
 
+set_option backward.isDefEq.instanceTypes false in
+set_option backward.isDefEq.respectTransparency false in
 /-- The variation of a function on `Ici a` is the sum of the variation on `Ioi a` and the
 contribution of `a`, i.e., the distance between the right limit and the value at `a`.
 We give a version relative to a set `s`. -/
@@ -715,6 +717,8 @@ lemma eVariationOn_Ioc_eq_Icc_of_continuousWithinAt
   have : (𝓝[Ioi a] a).NeBot := nhdsGT_neBot_of_exists_gt ⟨b, hab⟩
   exact eVariationOn_Ioc_eq_Icc_of_continuousWithinAt' h'
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma eVariationOn_Ico_eq_Icc_of_continuousWithinAt'
     [TopologicalSpace α] [OrderTopology α] {f : α → E} {a b : α}
     [h : (𝓝[<] a).NeBot] (h' : ContinuousWithinAt f (Iic a) a) :
@@ -722,6 +726,8 @@ lemma eVariationOn_Ico_eq_Icc_of_continuousWithinAt'
   rw [← comp_ofDual f, ← comp_ofDual f, ← Ioc_toDual, ← Icc_toDual]
   exact eVariationOn_Ioc_eq_Icc_of_continuousWithinAt' h'
 
+set_option backward.isDefEq.respectTransparency.instances false in
+set_option backward.isDefEq.respectTransparency.outParams false in
 lemma eVariationOn_Ico_eq_Icc_of_continuousWithinAt
     [TopologicalSpace α] [OrderTopology α] [DenselyOrdered α] {f : α → E} {a b : α}
     (h' : ContinuousWithinAt f (Iic a) a) :
diff --git a/mathlib4/Mathlib/Topology/VectorBundle/Basic.lean b/mathlib4/Mathlib/Topology/VectorBundle/Basic.lean
index d2087abfa..bbc3e2a32 100644
--- a/mathlib4/Mathlib/Topology/VectorBundle/Basic.lean
+++ b/mathlib4/Mathlib/Topology/VectorBundle/Basic.lean
@@ -662,6 +662,7 @@ theorem localTriv_apply {i : ι} (p : Z.TotalSpace) :
     (Z.localTriv i) p = ⟨p.1, Z.coordChange (Z.indexAt p.1) i p.1 p.2⟩ :=
   rfl
 
+set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The standard local trivializations of a vector bundle constructed from core are linear. -/
 instance localTriv.isLinear (i : ι) : (Z.localTriv i).IsLinear R where
diff --git a/mathlib4/lakefile.lean b/mathlib4/lakefile.lean
index eed55e391..d5bcc970d 100644
--- a/mathlib4/lakefile.lean
+++ b/mathlib4/lakefile.lean
@@ -43,6 +43,7 @@ abbrev mathlibOnlyLinters : Array LeanOption := #[
 abbrev mathlibLeanOptions := #[
     ⟨`pp.unicode.fun, true⟩, -- pretty-prints `fun a ↦ b`
     ⟨`autoImplicit, false⟩,
+    -- ⟨`backward.isDefEq.respectTransparency.outParams, false⟩,
     ⟨`maxSynthPendingDepth, .ofNat 3⟩,
   ] ++ -- options that are used in `lake build`
     mathlibOnlyLinters.map fun s ↦ { s with name := `weak ++ s.name }

From 8c5d0452f7e3ae801acc5daa7168e665abbd7acb Mon Sep 17 00:00:00 2001
From: Paul Reichert <6992158+datokrat@users.noreply.github.com>
Date: Thu, 13 Aug 2026 12:00:57 +0000
Subject: [PATCH 4/7] universe fixes

---
 .../Category/ModuleCat/FilteredColimits.lean        |  4 +---
 .../Algebra/Category/Ring/FilteredColimits.lean     | 13 ++++---------
 2 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
index cdc3914a1..ab2ffe54b 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
@@ -149,7 +149,6 @@ def coconeMorphism (j : J) : F.obj j ⟶ colimit F :=
       (F ⋙ forget₂ (ModuleCat R) AddCommGrpCat.{max v u})).ι.app j).hom with
     map_smul' := by solve_by_elim }
 
-set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit module. -/
 @[implicit_reducible]
 def colimitCocone : Cocone F where
@@ -158,8 +157,7 @@ def colimitCocone : Cocone F where
     { app := coconeMorphism F
       naturality _ _ f := by
         ext
-        simpa using! (Types.TypeMax.colimitCocone
-          (F ⋙ forget (ModuleCat R))).ι.naturality_apply f _ }
+        simpa using! (F ⋙ forget (ModuleCat R)).ιColimitType_map f _ }
 
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a cocone `t` of `F`, the induced monoid linear map from the colimit to the cocone point.
diff --git a/mathlib4/Mathlib/Algebra/Category/Ring/FilteredColimits.lean b/mathlib4/Mathlib/Algebra/Category/Ring/FilteredColimits.lean
index 39ee48e86..428cec9e8 100644
--- a/mathlib4/Mathlib/Algebra/Category/Ring/FilteredColimits.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Ring/FilteredColimits.lean
@@ -113,7 +113,6 @@ instance colimitSemiring : Semiring.{max v u} <| R.{v, u} F :=
 def colimit : SemiRingCat.{max v u} :=
   SemiRingCat.of <| R.{v, u} F
 
-set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit semiring. -/
 def colimitCocone : Cocone F where
   pt := colimit.{v, u} F
@@ -125,7 +124,7 @@ def colimitCocone : Cocone F where
               (F ⋙ forget₂ SemiRingCat.{max v u} AddCommMonCat)).ι.app j).hom with }
       naturality _ _ f := by
         ext
-        simpa using! (Types.TypeMax.colimitCocone (F ⋙ forget SemiRingCat)).ι.naturality_apply f _ }
+        simpa using! (F ⋙ forget SemiRingCat).ιColimitType_map f _ }
 
 namespace colimitCoconeIsColimit
 
@@ -216,7 +215,6 @@ instance colimitCommSemiring : CommSemiring.{max v u} <| R.{v, u} F :=
 def colimit : CommSemiRingCat.{max v u} :=
   CommSemiRingCat.of <| R.{v, u} F
 
-set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit commutative semiring. -/
 def colimitCocone : Cocone F where
   pt := colimit.{v, u} F
@@ -225,8 +223,7 @@ def colimitCocone : Cocone F where
           (F ⋙ forget₂ CommSemiRingCat SemiRingCat.{max v u})).ι.app X).hom
       naturality _ _ f := by
         ext
-        simpa using! (Types.TypeMax.colimitCocone
-          (F ⋙ forget CommSemiRingCat)).ι.naturality_apply f _ }
+        simpa using! (F ⋙ forget CommSemiRingCat).ιColimitType_map f _ }
 
 /-- The proposed colimit cocone is a colimit in `CommSemiRingCat`. -/
 def colimitCoconeIsColimit : IsColimit <| colimitCocone.{v, u} F :=
@@ -275,7 +272,6 @@ instance colimitRing : Ring.{max v u} <| R.{v, u} F :=
 def colimit : RingCat.{max v u} :=
   RingCat.of <| R.{v, u} F
 
-set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit ring. -/
 def colimitCocone : Cocone F where
   pt := colimit.{v, u} F
@@ -284,7 +280,7 @@ def colimitCocone : Cocone F where
           (F ⋙ forget₂ RingCat SemiRingCat.{max v u})).ι.app X).hom
       naturality _ _ f := by
         ext
-        simpa using! (Types.TypeMax.colimitCocone (F ⋙ forget RingCat)).ι.naturality_apply f _ }
+        simpa using! (F ⋙ forget RingCat).ιColimitType_map f _ }
 
 /-- The proposed colimit cocone is a colimit in `Ring`. -/
 def colimitCoconeIsColimit : IsColimit <| colimitCocone.{v, u} F :=
@@ -339,7 +335,6 @@ instance colimitCommRing : CommRing.{max v u} <| R.{v, u} F :=
 def colimit : CommRingCat.{max v u} :=
   CommRingCat.of <| R.{v, u} F
 
-set_option backward.isDefEq.respectTransparency.instances false in
 /-- The cocone over the proposed colimit commutative ring. -/
 def colimitCocone : Cocone F where
   pt := colimit.{v, u} F
@@ -348,7 +343,7 @@ def colimitCocone : Cocone F where
           (F ⋙ forget₂ CommRingCat RingCat.{max v u})).ι.app X).hom
       naturality _ _ f := by
         ext
-        simpa using! (Types.TypeMax.colimitCocone (F ⋙ forget CommRingCat)).ι.naturality_apply f _ }
+        simpa using! (F ⋙ forget CommRingCat).ιColimitType_map f _ }
 
 /-- The proposed colimit cocone is a colimit in `CommRingCat`. -/
 def colimitCoconeIsColimit : IsColimit <| colimitCocone.{v, u} F :=

From ab9db75edf7e457ea5d36d3c3f38d8de64e238b0 Mon Sep 17 00:00:00 2001
From: Paul Reichert <6992158+datokrat@users.noreply.github.com>
Date: Thu, 13 Aug 2026 12:39:53 +0000
Subject: [PATCH 5/7] squash warnings

---
 mathlib4/Mathlib/Algebra/Azumaya/Matrix.lean                | 3 +--
 mathlib4/Mathlib/Analysis/Calculus/VectorField.lean         | 2 +-
 .../Geometry/Manifold/Algebra/LeftInvariantDerivation.lean  | 2 +-
 mathlib4/Mathlib/LinearAlgebra/Alternating/DomCoprod.lean   | 2 +-
 mathlib4/Mathlib/LinearAlgebra/Contraction.lean             | 6 +++---
 mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean              | 2 +-
 mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean      | 2 +-
 7 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/mathlib4/Mathlib/Algebra/Azumaya/Matrix.lean b/mathlib4/Mathlib/Algebra/Azumaya/Matrix.lean
index dda8ae32d..d31903665 100644
--- a/mathlib4/Mathlib/Algebra/Azumaya/Matrix.lean
+++ b/mathlib4/Mathlib/Algebra/Azumaya/Matrix.lean
@@ -54,8 +54,7 @@ lemma AlgHom.mulLeftRightMatrix.comp_inv :
   apply (Matrix.stdBasis _ _ _).ext
   intro ⟨i, j⟩
   simp only [LinearMap.coe_comp, LinearMap.coe_mk, AddHom.coe_mk, Function.comp_apply, map_sum,
-    map_smul, stdBasis_eq_single, LinearMap.coe_sum, Finset.sum_apply,
-    LinearMap.smul_apply, LinearMap.id_coe, id_eq]
+    stdBasis_eq_single, LinearMap.coe_sum, Finset.sum_apply, LinearMap.id_coe, id_eq]
   ext k l
   simp [sum_apply, Matrix.mul_apply, single, Fintype.sum_prod_type, ite_and]
 
diff --git a/mathlib4/Mathlib/Analysis/Calculus/VectorField.lean b/mathlib4/Mathlib/Analysis/Calculus/VectorField.lean
index 59828087f..5b7cfcb19 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/VectorField.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/VectorField.lean
@@ -127,7 +127,7 @@ lemma lieBracketWithin_smul_right {f : E → 𝕜} (hf : DifferentiableWithinAt
     (hW : DifferentiableWithinAt 𝕜 W s x) (hs : UniqueDiffWithinAt 𝕜 s x) :
     lieBracketWithin 𝕜 V (fun y ↦ f y • W y) s x =
       (fderivWithin 𝕜 f s x) (V x) • (W x) + (f x) • lieBracketWithin 𝕜 V W s x := by
-  simp [lieBracketWithin, fderivWithin_fun_smul hs hf hW, map_smul, add_comm, smul_sub,
+  simp [lieBracketWithin, fderivWithin_fun_smul hs hf hW, add_comm, smul_sub,
     add_sub_assoc]
 
 /--
diff --git a/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean b/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
index 3a46e82f9..eae002637 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@@ -163,7 +163,7 @@ instance : AddCommGroup (LeftInvariantDerivation I G) :=
 
 instance : SMul 𝕜 (LeftInvariantDerivation I G) where
   smul r X := ⟨r • X.1, fun g => by
-    simp only [LinearMap.map_smul_of_tower, map_smul]; rw [left_invariant']⟩
+    simp only [LinearMap.map_smul_of_tower]; rw [left_invariant']⟩
 
 variable (r)
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/Alternating/DomCoprod.lean b/mathlib4/Mathlib/LinearAlgebra/Alternating/DomCoprod.lean
index 59f30001e..55d5d7097 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Alternating/DomCoprod.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Alternating/DomCoprod.lean
@@ -170,7 +170,7 @@ def domCoprod' :
       simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, _root_.smul_apply,
         ← MultilinearMap.domCoprod'_apply]
       simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
-        TensorProduct.tmul_smul, map_add, map_smul]
+        TensorProduct.tmul_smul, map_add]
       first | rw [← smul_add] | rw [smul_comm]
       rfl
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/Contraction.lean b/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
index 254d24938..2b4a1dacd 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
@@ -423,9 +423,9 @@ theorem dualDistrib_dualDistribInvOfBasis_left_inverse (b : Basis ι R M) (c : B
   rintro ⟨i', j'⟩
   simp only [dualDistrib, Basis.coe_dualBasis, coe_comp, Function.comp_apply,
     dualDistribInvOfBasis_apply, Basis.coord_apply, Basis.tensorProduct_repr_tmul_apply,
-    Basis.repr_self, _root_.map_sum, map_smul, homTensorHomMap_apply, compRight_apply,
-    Basis.tensorProduct_apply, LinearMap.coe_sum, Finset.sum_apply, smul_apply, LinearEquiv.coe_coe,
-    map_tmul, lid_tmul, smul_eq_mul, id_coe, id_eq]
+    Basis.repr_self, _root_.map_sum, compRight_apply,
+    Basis.tensorProduct_apply, LinearMap.coe_sum, Finset.sum_apply, LinearEquiv.coe_coe,
+    smul_eq_mul, id_coe, id_eq]
   rw [Finset.sum_eq_single i, Finset.sum_eq_single j]
   · simpa using mul_comm _ _
   all_goals { intros; simp [*] at * }
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean b/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
index c95350b01..9131df775 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
@@ -767,7 +767,7 @@ lemma KaehlerDifferential.range_mapBaseChange :
     | zero => simp
     | tmul r s =>
       obtain ⟨x, rfl⟩ := linearCombination_surjective _ _ s
-      simp only [mapBaseChange_tmul, LinearMap.mem_ker, map_smul]
+      simp only [mapBaseChange_tmul, LinearMap.mem_ker]
       induction x using Finsupp.induction_linear
       · simp
       · simp [smul_add, *]
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean b/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
index 173ac31d9..99d6d31df 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
@@ -178,7 +178,7 @@ lemma tensorKaehlerEquiv_left_inv [Algebra.IsPushout R S A B] :
   induction y
   · simp only [map_zero, TensorProduct.tmul_zero]
   · simp only [LinearMap.restrictScalars_comp, Derivation.tensorProductTo_tmul, LinearMap.coe_comp,
-      LinearMap.coe_restrictScalars, Function.comp_apply, LinearMap.liftBaseChange_tmul, map_smul,
+      LinearMap.coe_restrictScalars, Function.comp_apply, LinearMap.liftBaseChange_tmul,
       map_D, LinearMap.map_smul_of_tower, Derivation.liftKaehlerDifferential_comp_D,
       LinearMap.id_coe, id_eq, derivationTensorProduct_algebraMap]
     rw [smul_comm, TensorProduct.smul_tmul', smul_eq_mul, mul_one]

From ead806a444cb9ed2bb202458dd1f64bd473e8431 Mon Sep 17 00:00:00 2001
From: Paul Reichert <6992158+datokrat@users.noreply.github.com>
Date: Fri, 14 Aug 2026 17:40:35 +0200
Subject: [PATCH 6/7] cleanups

---
 .../Mathlib/Algebra/AddConstMap/Basic.lean    |  2 -
 mathlib4/Mathlib/Algebra/Algebra/Basic.lean   |  4 --
 mathlib4/Mathlib/Algebra/Algebra/Equiv.lean   |  1 -
 mathlib4/Mathlib/Algebra/Algebra/Hom.lean     |  2 -
 .../Mathlib/Algebra/Algebra/NonUnitalHom.lean |  5 --
 .../Algebra/Algebra/NonUnitalSubalgebra.lean  |  3 --
 .../Algebra/Spectrum/Quasispectrum.lean       |  1 -
 .../Mathlib/Algebra/Algebra/Unitization.lean  |  1 -
 mathlib4/Mathlib/Algebra/Azumaya/Basic.lean   |  1 -
 .../Mathlib/Algebra/BigOperators/Expect.lean  |  1 -
 .../Algebra/Category/BialgCat/Basic.lean      |  1 -
 .../Algebra/Category/FGModuleCat/Basic.lean   |  1 -
 .../Algebra/Category/Grp/Biproducts.lean      |  1 -
 .../Algebra/Category/Grp/FiniteGrp.lean       |  1 -
 .../Category/ModuleCat/Adjunctions.lean       |  1 -
 .../Category/ModuleCat/Biproducts.lean        |  1 -
 .../Category/ModuleCat/ChangeOfRings.lean     | 12 -----
 .../ModuleCat/Differentials/Presheaf.lean     |  1 -
 .../Category/ModuleCat/FilteredColimits.lean  |  1 -
 .../Algebra/Category/ModuleCat/Free.lean      |  1 -
 .../Algebra/Category/ModuleCat/Images.lean    |  1 -
 .../ModuleCat/InjectiveDimension.lean         |  3 --
 .../Algebra/Category/ModuleCat/Presheaf.lean  |  3 --
 .../ModuleCat/Presheaf/ChangeOfRings.lean     |  1 -
 .../ModuleCat/Presheaf/ColimitFunctor.lean    |  2 -
 .../Category/ModuleCat/Presheaf/Monoidal.lean |  1 -
 .../ModuleCat/Presheaf/Pushforward.lean       |  2 -
 .../ModuleCat/Presheaf/Submodule.lean         |  1 -
 .../ModuleCat/ProjectiveDimension.lean        |  2 -
 .../Category/ModuleCat/Sheaf/LocallyFree.lean |  1 -
 .../Category/ModuleCat/Topology/Basic.lean    |  5 --
 .../Algebra/Category/Ring/Constructions.lean  |  3 --
 .../Category/Ring/EqualizerPushout.lean       |  1 -
 .../Mathlib/Algebra/Colimit/DirectLimit.lean  |  8 ----
 mathlib4/Mathlib/Algebra/Colimit/Module.lean  |  4 --
 .../Mathlib/Algebra/DirectSum/Algebra.lean    |  1 -
 .../Algebra/DirectSum/Decomposition.lean      |  2 -
 .../Mathlib/Algebra/Group/Action/Sigma.lean   |  1 -
 .../Mathlib/Algebra/Group/ForwardDiff.lean    |  1 -
 .../Homology/Embedding/AreComplementary.lean  |  1 -
 .../HomotopyCategory/HomComplexShift.lean     |  2 -
 .../Homology/SpectralObject/Cycles.lean       |  2 -
 mathlib4/Mathlib/Algebra/Lie/Abelian.lean     |  1 -
 mathlib4/Mathlib/Algebra/Lie/BaseChange.lean  |  3 --
 mathlib4/Mathlib/Algebra/Lie/Basic.lean       |  5 --
 mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean |  1 -
 .../Mathlib/Algebra/Lie/CartanCriterion.lean  |  1 -
 .../Mathlib/Algebra/Lie/CartanExists.lean     |  1 -
 mathlib4/Mathlib/Algebra/Lie/Character.lean   |  1 -
 mathlib4/Mathlib/Algebra/Lie/Cochain.lean     |  1 -
 .../Mathlib/Algebra/Lie/Derivation/Basic.lean |  3 --
 mathlib4/Mathlib/Algebra/Lie/Extension.lean   |  3 --
 mathlib4/Mathlib/Algebra/Lie/Free.lean        |  1 -
 mathlib4/Mathlib/Algebra/Lie/Graded.lean      |  3 --
 mathlib4/Mathlib/Algebra/Lie/Loop.lean        |  1 -
 mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean  |  1 -
 .../Algebra/Lie/Semisimple/Lemmas.lean        |  1 -
 mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean  |  1 -
 mathlib4/Mathlib/Algebra/Lie/Submodule.lean   |  1 -
 .../Mathlib/Algebra/Lie/TensorProduct.lean    |  1 -
 mathlib4/Mathlib/Algebra/Lie/TraceForm.lean   |  3 --
 .../Mathlib/Algebra/Lie/TransferInstance.lean |  1 -
 .../Mathlib/Algebra/Lie/Weights/Basic.lean    |  4 --
 .../Mathlib/Algebra/Lie/Weights/Chain.lean    |  1 -
 .../Mathlib/Algebra/Lie/Weights/IsSimple.lean |  1 -
 .../Mathlib/Algebra/Lie/Weights/Killing.lean  |  5 --
 .../Mathlib/Algebra/Lie/Weights/Linear.lean   |  2 -
 .../Algebra/Module/Congruence/Defs.lean       |  1 -
 .../Mathlib/Algebra/Module/Equiv/Basic.lean   |  1 -
 .../Algebra/Module/FinitePresentation.lean    |  1 -
 .../Mathlib/Algebra/Module/Injective.lean     |  3 --
 .../Algebra/Module/LinearMap/Defs.lean        |  5 --
 .../Mathlib/Algebra/Module/LinearMap/End.lean |  2 -
 .../Algebra/Module/LocalizedModule/Basic.lean | 13 -----
 .../Algebra/Module/LocalizedModule/Exact.lean |  1 -
 mathlib4/Mathlib/Algebra/Module/PID.lean      |  1 -
 .../Module/Presentation/RestrictScalars.lean  |  1 -
 .../Mathlib/Algebra/Module/SnakeLemma.lean    |  8 ----
 .../Algebra/Module/Submodule/Bilinear.lean    |  1 -
 .../Algebra/Module/Submodule/LinearMap.lean   |  2 -
 .../Module/Torsion/PrimaryComponent.lean      |  1 -
 .../Algebra/Module/TransferInstance.lean      |  1 -
 .../Algebra/Module/ZLattice/Covolume.lean     |  2 -
 .../Mathlib/Algebra/Order/Hom/Monoid.lean     |  6 ---
 .../Algebra/Order/Module/HahnEmbedding.lean   |  1 -
 .../Mathlib/Algebra/Polynomial/Bivariate.lean |  1 -
 .../Mathlib/Algebra/Polynomial/Coeff.lean     |  1 -
 .../Algebra/Polynomial/Derivation.lean        |  1 -
 .../Mathlib/Algebra/Polynomial/Expand.lean    |  1 -
 .../Algebra/Polynomial/Module/AEval.lean      |  2 -
 .../Algebra/QuadraticAlgebra/Basic.lean       |  2 -
 mathlib4/Mathlib/Algebra/QuaternionBasis.lean |  2 -
 mathlib4/Mathlib/Algebra/RingQuot.lean        |  5 --
 .../Algebra/Star/NonUnitalSubalgebra.lean     |  1 -
 mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean |  6 ---
 mathlib4/Mathlib/Algebra/Star/Subalgebra.lean |  1 -
 .../Mathlib/Algebra/Star/TensorProduct.lean   |  1 -
 .../Algebra/Vertex/HVertexOperator.lean       |  1 -
 .../AlgebraicGeometry/AffineScheme.lean       |  1 -
 .../AffineTransitionLimit.lean                |  1 -
 .../Mathlib/AlgebraicGeometry/Artinian.lean   |  1 -
 .../Mathlib/AlgebraicGeometry/Cover/Open.lean |  1 -
 .../Mathlib/AlgebraicGeometry/Cover/Over.lean |  4 --
 .../AlgebraicGeometry/EffectiveEpi.lean       |  1 -
 .../EllipticCurve/Affine/Point.lean           |  1 -
 .../GammaSpecAdjunction.lean                  |  2 -
 .../Geometrically/Connected.lean              |  1 -
 .../Geometrically/Integral.lean               |  1 -
 .../Geometrically/Irreducible.lean            |  1 -
 .../Geometrically/Reduced.lean                |  1 -
 .../AlgebraicGeometry/Group/Abelian.lean      |  1 -
 .../AlgebraicGeometry/IdealSheaf/Basic.lean   |  1 -
 .../Mathlib/AlgebraicGeometry/Limits.lean     |  3 --
 .../AlgebraicGeometry/Modules/Tilde.lean      |  1 -
 .../AlgebraicGeometry/Morphisms/Basic.lean    |  1 -
 .../AlgebraicGeometry/Morphisms/Finite.lean   |  4 --
 .../Morphisms/FiniteType.lean                 |  1 -
 .../AlgebraicGeometry/Morphisms/Flat.lean     |  1 -
 .../Morphisms/RingHomProperties.lean          |  1 -
 .../Morphisms/UniversallyClosed.lean          |  1 -
 .../Mathlib/AlgebraicGeometry/Noetherian.lean |  1 -
 .../AlgebraicGeometry/Normalization.lean      |  1 -
 .../AlgebraicGeometry/OpenImmersion.lean      |  2 -
 .../ProjectiveSpectrum/Scheme.lean            |  1 -
 .../ProjectiveSpectrum/StructureSheaf.lean    |  1 -
 .../Mathlib/AlgebraicGeometry/Pullbacks.lean  |  1 -
 .../Mathlib/AlgebraicGeometry/Restrict.lean   |  4 --
 .../Mathlib/AlgebraicGeometry/Scheme.lean     |  1 -
 .../AlgebraicGeometry/Sites/Etale.lean        |  1 -
 .../AlgebraicGeometry/Sites/EtalePoint.lean   |  3 --
 mathlib4/Mathlib/AlgebraicGeometry/Spec.lean  |  3 --
 .../AlgebraicGeometry/StructureSheaf.lean     |  8 ----
 .../AnodyneExtensions/UnionProd.lean          |  1 -
 .../SimplicialSet/Degenerate.lean             |  2 -
 .../Mathlib/Analysis/Asymptotics/TVS.lean     |  2 -
 .../Mathlib/Analysis/BoxIntegral/Basic.lean   |  1 -
 .../Analysis/CStarAlgebra/CStarMatrix.lean    |  3 --
 .../ContinuousFunctionalCalculus/Commute.lean |  1 -
 .../Continuity.lean                           |  1 -
 .../NonUnital.lean                            |  2 -
 .../ContinuousFunctionalCalculus/Unique.lean  |  1 -
 .../ContinuousFunctionalCalculus/Unital.lean  |  2 -
 .../CStarAlgebra/GelfandNaimarkSegal.lean     |  6 ---
 .../Mathlib/Analysis/CStarAlgebra/Matrix.lean |  1 -
 .../Analysis/CStarAlgebra/Multiplier.lean     |  1 -
 .../CStarAlgebra/PositiveLinearMap.lean       |  1 -
 .../Analysis/CStarAlgebra/Spectrum.lean       |  1 -
 .../Analysis/CStarAlgebra/Unitization.lean    |  1 -
 .../Calculus/ContDiff/FTaylorSeries.lean      |  1 -
 .../Analysis/Calculus/Deriv/Basic.lean        |  1 -
 .../Analysis/Calculus/FDeriv/Symmetric.lean   |  2 -
 .../Mathlib/Analysis/Calculus/Rademacher.lean |  1 -
 .../Analysis/Complex/Harmonic/Analytic.lean   |  2 -
 .../Analysis/Convex/Approximation.lean        |  2 -
 mathlib4/Mathlib/Analysis/Convex/EGauge.lean  |  1 -
 mathlib4/Mathlib/Analysis/Convex/Side.lean    |  1 -
 .../Distribution/ContDiffMapSupportedIn.lean  |  3 --
 .../Analysis/Distribution/Distribution.lean   |  2 -
 .../Distribution/FourierMultiplier.lean       |  3 --
 .../Distribution/TemperedDistribution.lean    |  6 ---
 .../Analysis/Distribution/TestFunction.lean   |  2 -
 .../BoundedContinuousFunctionChar.lean        |  1 -
 .../FiniteAbelian/PontryaginDuality.lean      |  1 -
 .../Fourier/FourierTransformDeriv.lean        |  1 -
 .../Analysis/InnerProductSpace/Adjoint.lean   |  3 --
 .../Analysis/InnerProductSpace/Basic.lean     |  1 -
 .../Analysis/InnerProductSpace/Coalgebra.lean |  1 -
 .../Analysis/InnerProductSpace/Dual.lean      |  1 -
 .../Analysis/InnerProductSpace/LinearMap.lean |  5 --
 .../InnerProductSpace/LinearPMap.lean         |  1 -
 .../Analysis/InnerProductSpace/NormDet.lean   |  1 -
 .../Analysis/InnerProductSpace/OfNorm.lean    |  1 -
 .../Analysis/InnerProductSpace/PiL2.lean      | 48 -------------------
 .../Analysis/InnerProductSpace/Positive.lean  |  1 -
 .../Analysis/InnerProductSpace/ProdL2.lean    |  9 ----
 .../InnerProductSpace/Reproducing.lean        |  1 -
 .../Analysis/InnerProductSpace/Spectrum.lean  |  2 -
 .../Analysis/InnerProductSpace/Symmetric.lean |  1 -
 .../Analysis/InnerProductSpace/TwoDim.lean    |  1 -
 .../Analysis/InnerProductSpace/l2Space.lean   |  1 -
 .../Analysis/LocallyConvex/WeakDual.lean      |  1 -
 .../Matrix/HermitianFunctionalCalculus.lean   |  1 -
 .../Analysis/Normed/Algebra/Unitization.lean  |  1 -
 .../Mathlib/Analysis/Normed/Module/Bases.lean |  2 -
 .../Mathlib/Analysis/Normed/Module/Basic.lean |  2 -
 .../Normed/Module/FiniteDimension.lean        |  1 -
 .../PiTensorProduct/InjectiveSeminorm.lean    |  1 -
 .../PiTensorProduct/ProjectiveSeminorm.lean   |  1 -
 .../Analysis/Normed/Module/RCLike/Basic.lean  |  1 -
 .../Operator/Compact/FredholmAlternative.lean |  1 -
 .../Analysis/Normed/Operator/Extend.lean      |  1 -
 .../Normed/Unbundled/FiniteExtension.lean     |  1 -
 .../Normed/Unbundled/InvariantExtension.lean  |  5 --
 .../Normed/Unbundled/SpectralNorm.lean        |  1 -
 mathlib4/Mathlib/Analysis/RCLike/Basic.lean   |  1 -
 mathlib4/Mathlib/Analysis/RCLike/Extend.lean  |  1 -
 .../EnoughInjectives.lean                     |  1 -
 .../ModuleEmbedding/GabrielPopescu.lean       |  1 -
 .../Abelian/Pseudoelements.lean               |  1 -
 .../CategoryTheory/Action/Continuous.lean     |  1 -
 .../Mathlib/CategoryTheory/Category/TwoP.lean |  1 -
 .../Mathlib/CategoryTheory/Extensive.lean     |  1 -
 .../Functor/TypeValuedFlat.lean               |  1 -
 .../CategoryTheory/GradedObject/Monoidal.lean |  1 -
 .../WithAlgebraicStructures.lean              |  1 -
 .../Limits/Types/Coproducts.lean              |  1 -
 .../CategoryTheory/Monoidal/Bimod.lean        |  2 -
 .../CategoryTheory/Presentable/Type.lean      |  1 -
 .../CategoryTheory/Subobject/Lattice.lean     |  1 -
 mathlib4/Mathlib/CategoryTheory/Yoneda.lean   |  1 -
 .../Enumerative/Partition/GenFun.lean         |  1 -
 .../SimpleGraph/Coloring/Vertex.lean          |  1 -
 .../Mathlib/Condensed/Light/Functors.lean     |  1 -
 .../Mathlib/Condensed/Light/Sequence.lean     |  2 -
 mathlib4/Mathlib/Data/DFinsupp/Lex.lean       | 13 -----
 .../Mathlib/Data/DFinsupp/WellFounded.lean    |  3 --
 mathlib4/Mathlib/Data/Finset/Defs.lean        |  2 -
 mathlib4/Mathlib/Data/Finset/Image.lean       |  1 -
 mathlib4/Mathlib/FieldTheory/Fixed.lean       |  1 -
 .../Mathlib/FieldTheory/KummerExtension.lean  |  3 --
 .../Mathlib/FieldTheory/NormalizedTrace.lean  |  2 -
 .../FieldTheory/SeparablyGenerated.lean       |  2 -
 .../Mathlib/Geometry/Convex/Cone/Dual.lean    |  1 -
 .../Geometry/Convex/Cone/Face/Basic.lean      |  2 -
 .../Euclidean/Angle/Oriented/RightAngle.lean  |  3 --
 .../Euclidean/Angle/Oriented/Rotation.lean    |  4 --
 .../Geometry/Euclidean/Angle/Sphere.lean      |  2 -
 .../Geometry/Euclidean/MongePoint.lean        |  2 -
 .../Geometry/Euclidean/NinePointCircle.lean   |  2 -
 .../Euclidean/Sphere/SecondInter.lean         |  1 -
 .../Algebra/LeftInvariantDerivation.lean      |  3 --
 .../Geometry/Manifold/Instances/Sphere.lean   |  1 -
 .../Manifold/IntegralCurve/Basic.lean         |  2 -
 .../Geometry/Manifold/IsManifold/Basic.lean   |  2 -
 .../Manifold/MFDeriv/SpecificFunctions.lean   |  1 -
 .../Manifold/Riemannian/PathELength.lean      |  2 -
 .../Manifold/VectorBundle/LocalFrame.lean     |  2 -
 .../Manifold/VectorBundle/Tangent.lean        |  1 -
 .../Manifold/VectorField/LieBracket.lean      |  1 -
 .../RingedSpace/LocallyRingedSpace.lean       |  2 -
 .../LocallyRingedSpace/ResidueField.lean      |  4 --
 .../GroupTheory/SpecificGroups/ZGroup.lean    |  2 -
 .../AffineSpace/AffineEquiv.lean              |  1 -
 .../AffineSpace/AffineSubspace/Basic.lean     |  2 -
 .../AffineSpace/AffineSubspace/Shift.lean     |  2 -
 .../AffineSpace/Combination.lean              |  1 -
 .../Mathlib/LinearAlgebra/Basis/Basic.lean    |  1 -
 .../Mathlib/LinearAlgebra/Basis/Bilinear.lean |  1 -
 .../LinearAlgebra/Basis/Cardinality.lean      |  1 -
 .../Mathlib/LinearAlgebra/Basis/Defs.lean     |  3 --
 .../Mathlib/LinearAlgebra/Basis/Exact.lean    |  1 -
 .../Mathlib/LinearAlgebra/Basis/SMul.lean     |  1 -
 .../LinearAlgebra/Basis/VectorSpace.lean      |  1 -
 .../LinearAlgebra/BilinearForm/Basic.lean     |  1 -
 .../BilinearForm/DualLattice.lean             |  1 -
 .../BilinearForm/Orthogonal.lean              |  2 -
 .../BilinearForm/Properties.lean              |  1 -
 mathlib4/Mathlib/LinearAlgebra/Center.lean    |  1 -
 .../Mathlib/LinearAlgebra/Charpoly/Basic.lean |  1 -
 .../CliffordAlgebra/BaseChange.lean           |  1 -
 .../LinearAlgebra/CliffordAlgebra/Basic.lean  |  1 -
 .../CliffordAlgebra/Contraction.lean          |  5 --
 .../LinearAlgebra/CliffordAlgebra/Equivs.lean |  1 -
 .../LinearAlgebra/CliffordAlgebra/Even.lean   |  5 --
 .../CliffordAlgebra/EvenEquiv.lean            |  1 -
 .../CliffordAlgebra/Inversion.lean            |  3 --
 .../LinearAlgebra/CliffordAlgebra/Star.lean   |  1 -
 .../Mathlib/LinearAlgebra/Complex/Module.lean |  3 --
 .../Mathlib/LinearAlgebra/Contraction.lean    |  2 -
 .../Mathlib/LinearAlgebra/CrossProduct.lean   |  1 -
 mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean  |  1 -
 .../Mathlib/LinearAlgebra/Determinant.lean    | 27 -----------
 .../LinearAlgebra/Dimension/Basic.lean        |  2 -
 .../Dimension/Constructions.lean              |  2 -
 .../Mathlib/LinearAlgebra/Dimension/Free.lean |  1 -
 .../LinearAlgebra/Dimension/RankNullity.lean  |  2 -
 .../Dimension/Torsion/Basic.lean              |  1 -
 .../Dimension/Torsion/Finite.lean             |  1 -
 .../LinearAlgebra/DirectSum/Finsupp.lean      |  2 -
 .../Mathlib/LinearAlgebra/Dual/Basis.lean     |  2 -
 mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean |  1 -
 .../LinearAlgebra/Eigenspace/Matrix.lean      |  1 -
 .../ExteriorAlgebra/OfAlternating.lean        |  4 --
 .../FiniteDimensional/Basic.lean              |  1 -
 .../Mathlib/LinearAlgebra/FiniteSpan.lean     |  1 -
 .../Mathlib/LinearAlgebra/Finsupp/Defs.lean   |  3 --
 .../LinearAlgebra/Finsupp/VectorSpace.lean    |  1 -
 .../LinearAlgebra/FreeModule/Basic.lean       |  2 -
 .../FreeModule/Finite/CardQuotient.lean       |  1 -
 .../Mathlib/LinearAlgebra/FreeModule/Int.lean |  1 -
 .../Mathlib/LinearAlgebra/FreeModule/PID.lean |  5 --
 .../GeneralLinearGroup/AlgEquiv.lean          |  1 -
 .../LinearAlgebra/InvariantBasisNumber.lean   |  1 -
 .../LinearIndependent/Lemmas.lean             |  1 -
 .../LinearAlgebra/Matrix/Adjugate.lean        |  1 -
 .../Mathlib/LinearAlgebra/Matrix/Basis.lean   |  2 -
 .../Matrix/Charpoly/LinearMap.lean            |  1 -
 .../Mathlib/LinearAlgebra/Matrix/Rank.lean    |  1 -
 .../Mathlib/LinearAlgebra/Matrix/ToLin.lean   |  8 ----
 .../Mathlib/LinearAlgebra/Matrix/ZMatrix.lean |  1 -
 .../LinearAlgebra/Multilinear/DFinsupp.lean   |  1 -
 .../PerfectPairing/Restrict.lean              |  1 -
 mathlib4/Mathlib/LinearAlgebra/Pi.lean        |  2 -
 .../LinearAlgebra/PiTensorProduct/Basic.lean  |  3 --
 mathlib4/Mathlib/LinearAlgebra/Prod.lean      |  2 -
 .../LinearAlgebra/QuadraticForm/Basic.lean    | 30 ------------
 .../LinearAlgebra/QuadraticForm/Basis.lean    |  1 -
 .../LinearAlgebra/QuadraticForm/Dual.lean     |  1 -
 .../QuadraticForm/QuadraticModuleCat.lean     |  1 -
 .../QuadraticForm/TensorProduct.lean          |  1 -
 mathlib4/Mathlib/LinearAlgebra/Ray.lean       |  1 -
 .../Mathlib/LinearAlgebra/Reflection.lean     |  6 ---
 .../LinearAlgebra/RootSystem/Base.lean        |  1 -
 .../LinearAlgebra/RootSystem/BaseExists.lean  |  1 -
 .../LinearAlgebra/RootSystem/Basic.lean       |  1 -
 .../RootSystem/CartanMatrix.lean              |  1 -
 .../LinearAlgebra/RootSystem/Defs.lean        |  8 ----
 .../RootSystem/Finite/CanonicalBilinear.lean  |  3 --
 .../LinearAlgebra/RootSystem/Finite/G2.lean   |  4 --
 .../RootSystem/Finite/Nondegenerate.lean      |  2 -
 .../LinearAlgebra/RootSystem/OfBilinear.lean  |  3 --
 .../LinearAlgebra/RootSystem/Reduced.lean     |  1 -
 .../LinearAlgebra/SesquilinearForm/Basic.lean |  2 -
 .../LinearAlgebra/SesquilinearForm/Star.lean  |  1 -
 .../Mathlib/LinearAlgebra/Span/Basic.lean     |  1 -
 mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean |  2 -
 .../LinearAlgebra/SpecialLinearGroup.lean     |  2 -
 .../TensorAlgebra/ToTensorPower.lean          |  1 -
 .../LinearAlgebra/TensorPower/Basic.lean      |  5 --
 .../TensorProduct/Graded/External.lean        |  3 --
 .../TensorProduct/Graded/Internal.lean        |  3 --
 .../TensorProduct/RightExactness.lean         |  2 -
 mathlib4/Mathlib/LinearAlgebra/Trace.lean     |  2 -
 .../LinearAlgebra/Transvection/Basic.lean     |  5 --
 .../Transvection/Generation.lean              |  2 -
 .../MeasureTheory/Function/Jacobian.lean      |  2 -
 .../MeasureTheory/Integral/Bochner/L1.lean    |  1 -
 .../MeasureTheory/Integral/CircleAverage.lean |  1 -
 .../Integral/FinMeasAdditive.lean             |  1 -
 .../Integral/RieszMarkovKakutani/Basic.lean   |  1 -
 .../MeasureTheory/Integral/SetToL1.lean       |  1 -
 .../TaylorExpansion.lean                      |  1 -
 .../MeasureTheory/Measure/Haar/Extension.lean |  8 ----
 .../MeasureTheory/Measure/Haar/OfBasis.lean   |  1 -
 .../Presburger/Semilinear/Basic.lean          |  1 -
 .../NumberTheory/ClassNumber/Finite.lean      |  2 -
 .../LevelOne/DimensionFormula.lean            |  1 -
 .../CanonicalEmbedding/NormLeOne.lean         |  1 -
 .../NumberField/Cyclotomic/Basic.lean         |  1 -
 .../NumberField/Ideal/Asymptotics.lean        |  1 -
 .../NumberField/Units/DirichletTheorem.lean   |  1 -
 .../NumberTheory/Padics/Measure/Basic.lean    |  3 --
 .../Mathlib/NumberTheory/Padics/WithVal.lean  |  1 -
 .../RamificationInertia/Basic.lean            |  1 -
 .../Mathlib/Order/Category/FinBoolAlg.lean    |  1 -
 .../Mathlib/Order/Category/FinPartOrd.lean    |  1 -
 .../Order/Category/NonemptyFinLinOrd.lean     |  1 -
 .../Mathlib/Order/CompleteLattice/PiLex.lean  |  7 ---
 mathlib4/Mathlib/Order/PiLex.lean             |  9 ----
 mathlib4/Mathlib/Order/RelIso/Set.lean        |  1 -
 .../Probability/Distributions/Binomial.lean   |  1 -
 .../Distributions/Gaussian/CharFun.lean       |  3 --
 .../Probability/Moments/CovarianceBilin.lean  |  2 -
 .../Mathlib/RepresentationTheory/Basic.lean   |  3 --
 .../RepresentationTheory/Character.lean       |  2 -
 .../Continuous/Basic.lean                     |  1 -
 .../GroupCohomology/Functoriality.lean        | 19 --------
 .../GroupCohomology/LowDegree.lean            | 11 -----
 .../GroupHomology/Functoriality.lean          |  5 --
 .../Homological/GroupHomology/LowDegree.lean  |  5 --
 .../Homological/Resolution.lean               |  1 -
 .../RepresentationTheory/Intertwining.lean    |  1 -
 .../RepresentationTheory/Invariants.lean      |  1 -
 .../Mathlib/RepresentationTheory/Rep/Iso.lean |  1 -
 .../RepresentationTheory/Submodule.lean       |  1 -
 .../Subrepresentation.lean                    |  6 ---
 .../RingTheory/AdicCompletion/Algebra.lean    |  4 --
 .../RingTheory/AdicCompletion/Basic.lean      |  2 -
 .../AdicCompletion/Completeness.lean          |  1 -
 .../AdicCompletion/Functoriality.lean         |  2 -
 .../RingTheory/AdicCompletion/LocalRing.lean  |  1 -
 .../Mathlib/RingTheory/Adjoin/PowerBasis.lean |  2 -
 mathlib4/Mathlib/RingTheory/AlgebraTower.lean |  1 -
 .../RingTheory/Algebraic/Integral.lean        |  1 -
 .../Mathlib/RingTheory/Bialgebra/Equiv.lean   |  2 -
 .../Mathlib/RingTheory/Bialgebra/Hom.lean     |  2 -
 .../RingTheory/Bialgebra/MonoidAlgebra.lean   |  1 -
 .../RingTheory/DedekindDomain/Different.lean  |  3 --
 .../Mathlib/RingTheory/Derivation/Basic.lean  |  8 ----
 .../RingTheory/DividedPowerAlgebra/Init.lean  |  1 -
 .../Mathlib/RingTheory/Etale/Kaehler.lean     |  2 -
 .../Extension/Cotangent/BaseChange.lean       |  2 -
 .../RingTheory/Extension/Cotangent/Basic.lean |  1 -
 .../RingTheory/Extension/Cotangent/Basis.lean |  3 --
 .../RingTheory/Extension/Cotangent/Free.lean  |  1 -
 .../Extension/Cotangent/LocalizationAway.lean |  1 -
 mathlib4/Mathlib/RingTheory/FiniteType.lean   |  5 --
 .../RingTheory/Flat/EquationalCriterion.lean  |  1 -
 .../RingTheory/Flat/FaithfullyFlat/Basic.lean |  1 -
 .../FractionalIdeal/Operations.lean           |  3 --
 .../Mathlib/RingTheory/HopfAlgebra/Basic.lean |  1 -
 .../Ideal/AssociatedPrime/Basic.lean          |  2 -
 .../Ideal/AssociatedPrime/Finiteness.lean     |  1 -
 .../Mathlib/RingTheory/Ideal/Cotangent.lean   |  2 -
 mathlib4/Mathlib/RingTheory/Ideal/Maps.lean   |  2 -
 .../RingTheory/Ideal/Norm/AbsNorm.lean        |  1 -
 .../RingTheory/Ideal/Quotient/Basic.lean      |  1 -
 .../RingTheory/Ideal/Quotient/Operations.lean |  2 -
 .../RingTheory/IdealFilter/Topology.lean      |  1 -
 .../IsIntegralClosure/Basic.lean              |  1 -
 mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean |  1 -
 .../RingTheory/IsGaloisGroup/Defs.lean        |  1 -
 mathlib4/Mathlib/RingTheory/IsPrimary.lean    |  1 -
 .../Mathlib/RingTheory/IsTensorProduct.lean   |  2 -
 .../Mathlib/RingTheory/Kaehler/Basic.lean     |  3 --
 .../RingTheory/Kaehler/JacobiZariski.lean     |  4 --
 .../RingTheory/Kaehler/Polynomial.lean        |  1 -
 .../RingTheory/Kaehler/TensorProduct.lean     |  2 -
 .../RingTheory/LocalProperties/Injective.lean |  2 -
 .../LocalProperties/IntegrallyClosed.lean     |  1 -
 .../LocalProperties/Projective.lean           |  1 -
 .../LocalRing/ResidueField/Fiber.lean         |  1 -
 .../RingTheory/Localization/Basic.lean        |  1 -
 .../RingTheory/Localization/Finiteness.lean   |  1 -
 .../RingTheory/Localization/Module.lean       |  3 --
 .../Mathlib/RingTheory/Morita/Matrix.lean     |  1 -
 .../MvPolynomial/WeightedHomogeneous.lean     |  1 -
 .../RingTheory/MvPowerSeries/Basic.lean       |  2 -
 .../MvPowerSeries/LinearTopology.lean         |  1 -
 .../RingTheory/MvPowerSeries/Order.lean       |  1 -
 .../MvPowerSeries/Substitution.lean           |  1 -
 .../RingTheory/NoetherNormalization.lean      |  1 -
 mathlib4/Mathlib/RingTheory/NormTrace.lean    |  1 -
 .../Mathlib/RingTheory/PiTensorProduct.lean   |  1 -
 mathlib4/Mathlib/RingTheory/PicardGroup.lean  |  3 --
 .../RingTheory/Polynomial/DegreeLT.lean       |  2 -
 .../Polynomial/Resultant/Basic.lean           |  2 -
 .../UniversalFactorizationRing.lean           |  1 -
 .../RingTheory/PolynomialLaw/Basic.lean       |  3 --
 mathlib4/Mathlib/RingTheory/PowerBasis.lean   |  1 -
 .../RingTheory/QuasiFinite/Weakly.lean        |  1 -
 mathlib4/Mathlib/RingTheory/Regular/Free.lean |  1 -
 .../RingTheory/Regular/IsSMulRegular.lean     |  3 --
 .../Mathlib/RingTheory/Regular/LinearMap.lean |  1 -
 .../RingTheory/Regular/RegularSequence.lean   |  1 -
 .../RingTheory/SimpleModule/Basic.lean        |  2 -
 mathlib4/Mathlib/RingTheory/Smooth/Basic.lean |  1 -
 .../Mathlib/RingTheory/Smooth/Kaehler.lean    |  1 -
 .../Mathlib/RingTheory/Smooth/Quotient.lean   |  2 -
 .../Smooth/StandardSmoothCotangent.lean       |  2 -
 .../RingTheory/Spectrum/Prime/FreeLocus.lean  |  1 -
 .../RingTheory/Spectrum/Prime/Polynomial.lean |  1 -
 mathlib4/Mathlib/RingTheory/Support.lean      |  1 -
 .../TensorProduct/IsBaseChangeFree.lean       |  1 -
 mathlib4/Mathlib/RingTheory/Trace/Basic.lean  |  1 -
 .../Mathlib/RingTheory/Unramified/Field.lean  |  1 -
 .../Mathlib/RingTheory/Unramified/Finite.lean |  1 -
 .../RingTheory/Valuation/LocalSubring.lean    |  1 -
 .../Mathlib/RingTheory/Valuation/RankOne.lean |  2 -
 .../RingTheory/WittVector/Isocrystal.lean     |  1 -
 .../Mathlib/Topology/Algebra/Algebra.lean     |  1 -
 .../Algebra/Category/ProfiniteGrp/Limits.lean |  2 -
 .../Module/ContinuousLinearMap/Basic.lean     |  1 -
 .../Algebra/Module/FiniteDimension.lean       |  1 -
 .../Module/FiniteDimensionBilinear.lean       |  1 -
 .../Topology/Algebra/Module/IsWeak.lean       |  1 -
 .../Algebra/Module/Spaces/CharacterSpace.lean |  3 --
 .../Algebra/Module/UniformConvergence.lean    |  3 --
 .../Mathlib/Topology/Algebra/MulAction.lean   |  1 -
 .../Topology/Algebra/StarSubalgebra.lean      |  1 -
 .../Topology/Category/CompHausLike/Basic.lean |  1 -
 .../Category/CompHausLike/Cartesian.lean      |  2 -
 .../Topology/Category/CompactlyGenerated.lean |  1 -
 .../Mathlib/Topology/Category/FinTopCat.lean  |  1 -
 .../Category/LightProfinite/Basic.lean        |  1 -
 .../Profinite/Nobeling/Successor.lean         |  1 -
 .../Topology/Category/Profinite/Product.lean  |  1 -
 .../Mathlib/Topology/Category/Sequential.lean |  1 -
 .../Category/TopCat/Limits/Products.lean      |  3 --
 .../Topology/Category/TopCat/Monoidal.lean    |  3 --
 .../Topology/Category/TopCat/ULift.lean       |  1 -
 .../Topology/Category/UniformSpace.lean       |  1 -
 .../ContinuousMap/CompactlySupported.lean     |  1 -
 .../ContinuousMap/ContinuousMapZero.lean      |  1 -
 .../Mathlib/Topology/ContinuousMap/Star.lean  |  1 -
 .../ContinuousMap/StoneWeierstrass.lean       |  4 --
 .../EMetricSpace/BoundedVariation.lean        |  2 -
 .../Topology/EMetricSpace/PairReduction.lean  |  1 -
 .../Topology/Homotopy/TopCat/Path.lean        |  1 -
 .../Homotopy/TopCat/ZerothHomotopy.lean       |  1 -
 mathlib4/Mathlib/Topology/Instances/Rat.lean  |  1 -
 .../Topology/Order/Category/AlexDisc.lean     |  1 -
 .../Mathlib/Topology/VectorBundle/Basic.lean  |  1 -
 493 files changed, 1044 deletions(-)

diff --git a/mathlib4/Mathlib/Algebra/AddConstMap/Basic.lean b/mathlib4/Mathlib/Algebra/AddConstMap/Basic.lean
index 234b7d5b2..d15aa99d4 100644
--- a/mathlib4/Mathlib/Algebra/AddConstMap/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/AddConstMap/Basic.lean
@@ -291,7 +291,6 @@ theorem monotone_iff_Icc [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G]
 
 -- Defeq abuse: there is no `AddConstMapClass _ _ Hᵒᵈ _ _`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem antitone_iff_Icc [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Archimedean G]
     [AddCommGroup H] [PartialOrder H] [IsOrderedAddMonoid H]
     [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
@@ -306,7 +305,6 @@ theorem strictMono_iff_Icc [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid
 
 -- Defeq abuse: there is no `AddConstMapClass _ _ Hᵒᵈ _ _`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem strictAnti_iff_Icc [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Archimedean G]
     [AddCommGroup H] [PartialOrder H] [IsOrderedAddMonoid H]
     [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Basic.lean b/mathlib4/Mathlib/Algebra/Algebra/Basic.lean
index 610396623..81ec13d6f 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Basic.lean
@@ -251,7 +251,6 @@ namespace LinearMap
 variable {R : Type*} {A : Type*} {B : Type*} [CommSemiring R] [Semiring A] [Semiring B]
   [Algebra R A] [Algebra R B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An alternate statement of `LinearMap.map_smul` for when `algebraMap` is more convenient to
 work with than `•`. -/
 theorem map_algebraMap_mul (f : A →ₗ[R] B) (a : A) (r : R) :
@@ -504,7 +503,6 @@ section invertibility
 variable {R A B : Type*}
 variable [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If there is a linear map `f : A →ₗ[R] B` that preserves `1`, then `algebraMap R B r` is
 invertible when `algebraMap R A r` is. -/
 abbrev Invertible.algebraMapOfInvertibleAlgebraMap (f : A →ₗ[R] B) (hf : f 1 = 1) {r : R}
@@ -528,7 +526,6 @@ section algebraMap
 
 variable {F E : Type*} [CommSemiring F] [Semiring E] [Algebra F E] (b : F →ₗ[F] E)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `E` is an `F`-algebra, and there exists an injective `F`-linear map from `F` to `E`,
 then the algebra map from `F` to `E` is also injective. -/
 theorem injective_algebraMap_of_linearMap (hb : Injective b) :
@@ -536,7 +533,6 @@ theorem injective_algebraMap_of_linearMap (hb : Injective b) :
   rw [← mul_one x, ← mul_one y, ← smul_eq_mul, ← smul_eq_mul,
     map_smul, map_smul, Algebra.smul_def, Algebra.smul_def, e]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `E` is an `F`-algebra, and there exists a surjective `F`-linear map from `F` to `E`,
 then the algebra map from `F` to `E` is also surjective. -/
 theorem surjective_algebraMap_of_linearMap (hb : Surjective b) :
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Equiv.lean b/mathlib4/Mathlib/Algebra/Algebra/Equiv.lean
index 80f0d7b37..f423163bc 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Equiv.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Equiv.lean
@@ -957,7 +957,6 @@ variable {R S M₁ M₂ : Type*} [CommSemiring R] [AddCommMonoid M₁] [Module R
   [SMulCommClass S R M₁] [SMulCommClass S R M₂] [SMul R S] [IsScalarTower R S M₁]
   [IsScalarTower R S M₂]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (R) in
 /-- A linear equivalence of two modules induces an equivalence of algebras of their
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Hom.lean b/mathlib4/Mathlib/Algebra/Algebra/Hom.lean
index 8cb51f3ef..0942fd932 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Hom.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Hom.lean
@@ -271,7 +271,6 @@ theorem comp_assoc (φ₁ : C →ₐ[R] D) (φ₂ : B →ₐ[R] C) (φ₃ : A 
 instance {φ₁ : B →ₐ[R] C} {φ₂ : A →ₐ[R] B} :
     RingHomCompTriple φ₂.toRingHom φ₁.toRingHom (φ₁.comp φ₂).toRingHom := ⟨rfl⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- R-Alg ⥤ R-Mod -/
 def toLinearMap : A →ₗ[R] B where
   toFun := φ
@@ -298,7 +297,6 @@ theorem comp_toLinearMap (f : A →ₐ[R] B) (g : B →ₐ[R] C) :
 theorem toLinearMap_id : toLinearMap (AlgHom.id R A) = LinearMap.id :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma linearMapMk_toAddHom (f : A →ₐ[R] B) : LinearMap.mk f (map_smul f) = f.toLinearMap :=
   rfl
 
diff --git a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
index cddec230e..17bdad6d8 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalHom.lean
@@ -103,7 +103,6 @@ variable [Semiring R] [Semiring S] {φ : R →+* S}
 -- This needs `DFunLike.coe φ = DFunLike.coe (φ : R →* S)` to hold at `instances` transparency,
 -- which seems reasonable but isn't true at the moment.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 -- see Note [lower instance priority]
 instance (priority := 100) {F R S A B : Type*}
     {_ : Semiring R} {_ : Semiring S} {φ : R →+* S}
@@ -373,7 +372,6 @@ def snd : A × B →ₙₐ[R] B where
 variable {R A B}
 variable [DistribMulAction R C]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The prod of two morphisms is a morphism. -/
 @[simps toFun]
@@ -445,11 +443,9 @@ variable {A B : Type*} [Semiring A] [Semiring B] [Algebra R A]
   [Algebra R B]
 
 -- see Note [lower instance priority]
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) [FunLike F A B] [AlgHomClass F R A B] : NonUnitalAlgHomClass F R A B :=
   { ‹AlgHomClass F R A B› with map_smulₛₗ := map_smul }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A unital morphism of algebras is a `NonUnitalAlgHom`. -/
 @[coe]
 def toNonUnitalAlgHom (f : A →ₐ[R] B) : A →ₙₐ[R] B :=
@@ -473,7 +469,6 @@ variable (R : Type*) {S A B : Type*} [Monoid R] [Monoid S]
     [DistribMulAction S A] [DistribMulAction S B] [DistribMulAction R A] [DistribMulAction R B]
     [IsScalarTower R S A] [IsScalarTower R S B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a monoid `R` acts on another monoid `S`, then a non-unital algebra homomorphism
 over `S` can be viewed as a non-unital algebra homomorphism over `R`. -/
 def restrictScalars (f : A →ₙₐ[S] B) : A →ₙₐ[R] B :=
diff --git a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
index c946d2a2f..47b6fce6d 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@@ -451,7 +451,6 @@ variable [CommSemiring R]
 variable [NonUnitalNonAssocSemiring A] [Module R A] [NonUnitalNonAssocSemiring B] [Module R B]
 variable [NonUnitalNonAssocSemiring C] [Module R C] [FunLike F A B] [NonUnitalAlgHomClass F R A B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Range of an `NonUnitalAlgHom` as a non-unital subalgebra. -/
 protected def range (φ : F) : NonUnitalSubalgebra R B where
   toNonUnitalSubsemiring := NonUnitalRingHom.srange (φ : A →ₙ+* B)
@@ -480,7 +479,6 @@ theorem range_comp_le_range (f : A →ₙₐ[R] B) (g : B →ₙₐ[R] C) :
     NonUnitalAlgHom.range (g.comp f) ≤ NonUnitalAlgHom.range g :=
   SetLike.coe_mono (Set.range_comp_subset_range f g)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Restrict the codomain of a non-unital algebra homomorphism. -/
 def codRestrict (f : F) (S : NonUnitalSubalgebra R B) (hf : ∀ x, f x ∈ S) : A →ₙₐ[R] S :=
   { NonUnitalRingHom.codRestrict (f : A →ₙ+* B) S.toNonUnitalSubsemiring hf with
@@ -506,7 +504,6 @@ This is the bundled version of `Set.rangeFactorization`. -/
 abbrev rangeRestrict (f : F) : A →ₙₐ[R] (NonUnitalAlgHom.range f : NonUnitalSubalgebra R B) :=
   NonUnitalAlgHom.codRestrict f (NonUnitalAlgHom.range f) (NonUnitalAlgHom.mem_range_self f)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The equalizer of two non-unital `R`-algebra homomorphisms -/
 def equalizer (ϕ ψ : F) : NonUnitalSubalgebra R A where
   carrier := {a | (ϕ a : B) = ψ a}
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Spectrum/Quasispectrum.lean b/mathlib4/Mathlib/Algebra/Algebra/Spectrum/Quasispectrum.lean
index e193a7f8e..d8518f393 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Spectrum/Quasispectrum.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Spectrum/Quasispectrum.lean
@@ -268,7 +268,6 @@ instance quasispectrum.instZero [Nontrivial R] (a : A) : Zero (quasispectrum R a
 
 variable {R}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A version of `NonUnitalAlgHom.quasispectrum_apply_subset` which allows for `quasispectrum R`,
 where `R` is a *semi*ring, but `φ` must still function over a scalar ring `S`. In this case, we
diff --git a/mathlib4/Mathlib/Algebra/Algebra/Unitization.lean b/mathlib4/Mathlib/Algebra/Algebra/Unitization.lean
index bb584656c..430cf2088 100644
--- a/mathlib4/Mathlib/Algebra/Algebra/Unitization.lean
+++ b/mathlib4/Mathlib/Algebra/Algebra/Unitization.lean
@@ -729,7 +729,6 @@ theorem algHom_ext' {φ ψ : Unitization R A →ₐ[R] C}
     φ = ψ :=
   algHom_ext'' (NonUnitalAlgHom.congr_fun h)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A non-unital algebra homomorphism from `A` into a unital `R`-algebra `C` lifts to a unital
 algebra homomorphism from the unitization into `C`. This is extended to an `Equiv` in
 `Unitization.lift` and that should be used instead. This declaration only exists for performance
diff --git a/mathlib4/Mathlib/Algebra/Azumaya/Basic.lean b/mathlib4/Mathlib/Algebra/Azumaya/Basic.lean
index 272e285f6..8f5035854 100644
--- a/mathlib4/Mathlib/Algebra/Azumaya/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Azumaya/Basic.lean
@@ -73,7 +73,6 @@ lemma mulLeftRight_comp_congr (e : A ≃ₐ[R] B) :
     (e.toLinearEquiv.conjAlgEquiv R).toAlgHom.comp (AlgHom.mulLeftRight R A) := by
   ext <;> simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem of_AlgEquiv (e : A ≃ₐ[R] B) [IsAzumaya R A] : IsAzumaya R B :=
   let _ : Module.Projective R B := .of_equiv e.toLinearEquiv
   let _ : FaithfulSMul R B := .of_injective e e.injective
diff --git a/mathlib4/Mathlib/Algebra/BigOperators/Expect.lean b/mathlib4/Mathlib/Algebra/BigOperators/Expect.lean
index 506844645..6021bb341 100644
--- a/mathlib4/Mathlib/Algebra/BigOperators/Expect.lean
+++ b/mathlib4/Mathlib/Algebra/BigOperators/Expect.lean
@@ -282,7 +282,6 @@ end bij
 @[simp] lemma expect_neg_index [DecidableEq ι] [InvolutiveNeg ι] (s : Finset ι) (f : ι → M) :
     𝔼 i ∈ -s, f i = 𝔼 i ∈ s, f (-i) := expect_image neg_injective.injOn
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma _root_.map_expect {F : Type*} [FunLike F M N] [LinearMapClass F ℚ≥0 M N]
     (g : F) (f : ι → M) (s : Finset ι) :
diff --git a/mathlib4/Mathlib/Algebra/Category/BialgCat/Basic.lean b/mathlib4/Mathlib/Algebra/Category/BialgCat/Basic.lean
index 94e56a8f9..f23b36200 100644
--- a/mathlib4/Mathlib/Algebra/Category/BialgCat/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Category/BialgCat/Basic.lean
@@ -147,7 +147,6 @@ variable {X Y Z : Type v}
 variable [Ring X] [Ring Y] [Ring Z]
 variable [Bialgebra R X] [Bialgebra R Y] [Bialgebra R Z]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Build an isomorphism in the category `BialgCat R` from a
 `BialgEquiv`. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Algebra/Category/FGModuleCat/Basic.lean b/mathlib4/Mathlib/Algebra/Category/FGModuleCat/Basic.lean
index 47f679079..38f8e641a 100644
--- a/mathlib4/Mathlib/Algebra/Category/FGModuleCat/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@@ -229,7 +229,6 @@ theorem FGModuleCatEvaluation_apply (f : FGModuleCatDual K V) (x : V) :
   contractLeft_apply f x
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `@[simp]`-normal form of `FGModuleCatEvaluation_apply`, where the carriers have been unfolded.
 -/
 @[simp]
diff --git a/mathlib4/Mathlib/Algebra/Category/Grp/Biproducts.lean b/mathlib4/Mathlib/Algebra/Category/Grp/Biproducts.lean
index 0b63e6a5c..c51250a62 100644
--- a/mathlib4/Mathlib/Algebra/Category/Grp/Biproducts.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Grp/Biproducts.lean
@@ -79,7 +79,6 @@ namespace HasLimit
 variable {J : Type w} (f : J → AddCommGrpCat.{max w u})
 
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The map from an arbitrary cone over an indexed family of abelian groups
 to the Cartesian product of those groups.
 -/
diff --git a/mathlib4/Mathlib/Algebra/Category/Grp/FiniteGrp.lean b/mathlib4/Mathlib/Algebra/Category/Grp/FiniteGrp.lean
index 5e50ec220..dc08ec8eb 100644
--- a/mathlib4/Mathlib/Algebra/Category/Grp/FiniteGrp.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Grp/FiniteGrp.lean
@@ -50,7 +50,6 @@ instance : Category FiniteGrp :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 instance : ConcreteCategory FiniteGrp (· →* ·) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toGrp) _
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
index a183e359c..97710a7ea 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
@@ -373,7 +373,6 @@ def embeddingLiftIso (F : C ⥤ D) : embedding R C ⋙ lift R F ≅ F :=
   NatIso.ofComponents fun _ => Iso.refl _
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Two `R`-linear functors out of the `R`-linear completion are isomorphic iff their
 compositions with the embedding functor are isomorphic.
 -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Biproducts.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Biproducts.lean
index 660f2f48b..a28562386 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Biproducts.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Biproducts.lean
@@ -85,7 +85,6 @@ namespace HasLimit
 variable {J : Type w} (f : J → ModuleCat.{max w v} R)
 
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The map from an arbitrary cone over an indexed family of abelian groups
 to the Cartesian product of those groups.
 -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
index a3ca30990..8b79b35a8 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
@@ -99,7 +99,6 @@ lemma forget₂_map_restrictScalars {R : Type u₁} {S : Type u₂} [Ring R] [Ri
   rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) :
     (restrictScalars.{v} f).Faithful where
   map_injective h := by
@@ -423,7 +422,6 @@ theorem map_tmul {M M' : ModuleCat.{v} R} (g : M ⟶ M') (s : S) (m : M) :
 
 variable {f}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[ext]
 lemma hom_ext {M : ModuleCat R} {N : ModuleCat S}
@@ -453,7 +451,6 @@ variable (M : Type v) [AddCommMonoid M] [Module R M]
 -- Porting note: this seems to cause problems related to lack of reducibility
 -- local notation "S'" => (restrictScalars f).obj ⟨S⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given an `R`-module M, consider Hom(S, M) -- the `R`-linear maps between S (as an `R`-module by
 means of restriction of scalars) and M. `S` acts on Hom(S, M) by `s • g = x ↦ g (x • s)`
@@ -564,7 +561,6 @@ namespace RestrictionCoextensionAdj
 
 variable {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given `R`-module X and `S`-module Y, any `g : (restrictScalars f).obj Y ⟶ X`
 corresponds to `Y ⟶ (coextendScalars f).obj X` by sending `y ↦ (s ↦ g (s • y))`
@@ -588,7 +584,6 @@ def HomEquiv.fromRestriction {X : ModuleCat R} {Y : ModuleCat S}
     (g : (restrictScalars f).obj Y ⟶ X) (y) (s : S) :
     (HomEquiv.fromRestriction f g).hom y s = g (s • y) := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given `R`-module X and `S`-module Y, any `g : Y ⟶ (coextendScalars f).obj X`
 corresponds to `(restrictScalars f).obj Y ⟶ X` by `y ↦ g y 1`
@@ -609,7 +604,6 @@ def HomEquiv.toRestriction {X : ModuleCat R} {Y : ModuleCat S} (g : Y ⟶ (coext
     (g : Y ⟶ (coextendScalars f).obj X) (y) :
     (HomEquiv.toRestriction f g).hom y = g.hom y (1 : S) := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Auxiliary definition for `unit'`, to address timeouts. -/
 def app' (Y : ModuleCat S) : Y →ₗ[S] (restrictScalars f ⋙ coextendScalars f).obj Y :=
@@ -625,7 +619,6 @@ def app' (Y : ModuleCat S) : Y →ₗ[S] (restrictScalars f ⋙ coextendScalars
       LinearMap.ext fun t : S => by
         simp [mul_smul] }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The natural transformation from identity functor to the composition of restriction and coextension
 of scalars.
@@ -640,7 +633,6 @@ protected noncomputable def unit' : 𝟭 (ModuleCat S) ⟶ restrictScalars f ⋙
       change s • (g y) = g (s • y)
       rw [map_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The natural transformation from the composition of coextension and restriction of scalars to
 identity functor.
@@ -662,7 +654,6 @@ protected noncomputable def counit' : coextendScalars f ⋙ restrictScalars f 
 end RestrictionCoextensionAdj
 
 set_option backward.isDefEq.instanceTypes false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 -- Porting note: very fiddly universes
 set_option backward.isDefEq.respectTransparency.instances false in
@@ -720,7 +711,6 @@ def HomEquiv.toRestrictScalars {X : ModuleCat R} {Y : ModuleCat S}
 
 set_option backward.isDefEq.respectTransparency false in
 -- Porting note: forced to break apart fromExtendScalars due to timeouts
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The map `S → X →ₗ[R] Y` given by `fun s x => s • (g x)`
 -/
@@ -770,7 +760,6 @@ def HomEquiv.fromExtendScalars {X : ModuleCat R} {Y : ModuleCat S}
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given `R`-module X and `S`-module Y, `S`-linear maps `(extendScalars f).obj X ⟶ Y`
 bijectively correspond to `R`-linear maps `X ⟶ (restrictScalars f).obj Y`.
 -/
@@ -865,7 +854,6 @@ lemma Counit.map_apply_one_tmul {Y : ModuleCat S} (y : Y) :
   change (1 : S) • y = y
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- The natural transformation from the composition of restriction and extension of scalars to the
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
index 89df16a1b..0e207dcfc 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
@@ -230,7 +230,6 @@ noncomputable def relativeDifferentials' :
 attribute [simp] relativeDifferentials'_obj
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma relativeDifferentials'_map_d {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : R.obj X) :
     DFunLike.coe (α := CommRingCat.KaehlerDifferential (φ'.app X))
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
index ab2ffe54b..dce82a3a4 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/FilteredColimits.lean
@@ -123,7 +123,6 @@ instance colimitSMulWithZero : SMulWithZero R (M F) :=
     simp [← colimit_zero_eq] }
 
 instance colimitModule : Module R (M F) :=
-set_option backward.isDefEq.respectTransparency.outParams false in
 { colimitMulAction F,
   colimitSMulWithZero F with
   smul_add := fun r x y => by
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Free.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Free.lean
index 6afcc17f0..e5317f642 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Free.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Free.lean
@@ -92,7 +92,6 @@ end LinearIndependent
 
 section Span
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hS in
 /-- In the commutative diagram
 ```
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Images.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Images.lean
index d2b6cf218..47574ab1b 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Images.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Images.lean
@@ -53,7 +53,6 @@ attribute [local simp] image.fac
 
 variable {f}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- The universal property for the image factorisation -/
 noncomputable def image.lift (F' : MonoFactorisation f) : image f ⟶ F'.I :=
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/InjectiveDimension.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/InjectiveDimension.lean
index 6866ca33c..a697dbe72 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/InjectiveDimension.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/InjectiveDimension.lean
@@ -86,7 +86,6 @@ variable [Small.{v} R] {R' : Type u'} [Ring R'] (eR : R ≃+* R')
 
 attribute [local instance] RingHomInvPair.of_ringEquiv
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 private lemma hasInjectiveDimensionLE_iff_of_semiLinearEquiv_aux [Small.{v} R']
     {M : ModuleCat.{v} R} {N : ModuleCat.{v} R'} (e : M ≃ₛₗ[RingHomClass.toRingHom eR] N)
@@ -127,7 +126,6 @@ private lemma hasInjectiveDimensionLE_iff_of_semiLinearEquiv_aux [Small.{v} R']
     exact (exactS.hasInjectiveDimensionLT_X₃_iff n inferInstance).symm.trans
       ((ih eCoker).trans (exactS'.hasInjectiveDimensionLT_X₃_iff n inferInstance))
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 attribute [local instance] small_lift in
 lemma hasInjectiveDimensionLE_iff_of_semiLinearEquiv [Small.{v'} R']
@@ -140,7 +138,6 @@ lemma hasInjectiveDimensionLE_iff_of_semiLinearEquiv [Small.{v'} R']
   exact hasInjectiveDimensionLE_iff_of_semiLinearEquiv_aux eR ((eM.symm.trans e).trans eN) n
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma injectiveDimension_eq_of_semiLinearEquiv [Small.{v'} R']
     {M : ModuleCat.{v} R} {N : ModuleCat.{v'} R'} (e : M ≃ₛₗ[RingHomClass.toRingHom eR] N) :
     injectiveDimension M = injectiveDimension N := by
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
index df74bc193..a582eec7b 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
@@ -150,7 +150,6 @@ lemma presheaf_obj_coe (X : Cᵒᵖ) :
     (M.presheaf.obj X : Type _) = M.obj X := rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma presheaf_map_apply_coe {X Y : Cᵒᵖ} (f : X ⟶ Y) (x : M.obj X) :
     DFunLike.coe (α := M.obj X) (β := fun _ ↦ M.obj Y) (M.presheaf.map f).hom x = M.map f x := rfl
@@ -179,7 +178,6 @@ lemma toPresheaf_obj_coe (X : Cᵒᵖ) :
     (((toPresheaf R).obj M).obj X : Type _) = M.obj X := rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma toPresheaf_map_app_apply (f : M₁ ⟶ M₂) (X : Cᵒᵖ) (x : M₁.obj X) :
     DFunLike.coe (α := M₁.obj X) (β := fun _ ↦ M₂.obj X)
@@ -218,7 +216,6 @@ lemma ofPresheaf_presheaf : (ofPresheaf M map_smul).presheaf = M := rfl
 end
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The morphism of presheaves of modules `M₁ ⟶ M₂` given by a morphism
 of abelian presheaves `M₁.presheaf ⟶ M₂.presheaf`
 which satisfy a suitable linearity condition. -/
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean
index 8758f1cf6..67319552f 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean
@@ -28,7 +28,6 @@ namespace PresheafOfModules
 variable {C : Type u'} [Category.{v'} C] {R R' : Cᵒᵖ ⥤ RingCat.{u}}
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The restriction of scalars of presheaves of modules, on objects. -/
 @[simps]
 noncomputable def restrictScalarsObj (M' : PresheafOfModules.{v} R') (α : R ⟶ R') :
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
index d28822408..226ca2785 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/ColimitFunctor.lean
@@ -237,7 +237,6 @@ lemma map_smul_homEquiv'_iff {N : ModuleCat.{w} cR.pt}
     congr 1
     exact (smul_eq ..).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- This is the universal property of `PresheafOfModules.ModuleColimit` as a module.
 See also `PresheafOfModules.colimitAdjunction`. -/
@@ -291,7 +290,6 @@ variable {M' : PresheafOfModules.{w} R} {cM' : Cocone M'.presheaf}
 
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The linear map between the colimit modules induced by a morphism of modules. -/
 noncomputable def map (f : M ⟶ M') :
     ModuleColimit hcR hcM →ₗ[cR.pt] ModuleColimit hcR hcM' where
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
index e1b824f72..acdcd9ed7 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Monoidal.lean
@@ -134,7 +134,6 @@ After that, you can remove `instanceTypes false`, too.
 -/
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma tensorObj_map_tmul {X Y : Cᵒᵖ} (f : X ⟶ Y) (m₁ : M₁.obj X) (m₂ : M₂.obj X) :
     DFunLike.coe (α := (M₁.obj X ⊗ M₂.obj X :))
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
index b394d5e25..74a6251a8 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean
@@ -141,7 +141,6 @@ can go.
 -/
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `@[simp]`-normal form of `pushforward_obj_map_apply`. -/
 @[simp]
 lemma pushforward_obj_map_apply' (M : PresheafOfModules.{v} R) {X Y : Cᵒᵖ} (f : X ⟶ Y)
@@ -177,7 +176,6 @@ can go.
 -/
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `@[simp]`-normal form of `pushforward_map_app_apply`. -/
 @[simp]
 lemma pushforward_map_app_apply' {M N : PresheafOfModules.{v} R} (α : M ⟶ N) (X : Cᵒᵖ)
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean
index 76268197a..e7c9fb2cc 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean
@@ -54,7 +54,6 @@ lemma ext {N₁ N₂ : M.Submodule} (h : ∀ X, N₁.obj X = N₂.obj X) :
   cases N₁; cases N₂; congr 1; ext X : 1; exact h X
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[grind .]
 lemma map_mem {X Y : Cᵒᵖ} (f : X ⟶ Y) {x : M.obj X} (hx : x ∈ N.obj X) :
     M.map f x ∈ N.obj Y :=
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ProjectiveDimension.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ProjectiveDimension.lean
index a60ca6f2e..7e830e326 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/ProjectiveDimension.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/ProjectiveDimension.lean
@@ -53,7 +53,6 @@ variable [Small.{v} R] {R' : Type u'} [Ring R'] [Small.{v'} R'] (e : R ≃+* R')
 variable {M : ModuleCat.{v} R} {N : ModuleCat.{v'} R'}
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 lemma hasProjectiveDimensionLE_of_semiLinearEquiv (e' : M ≃ₛₗ[RingHomClass.toRingHom e] N)
     (n : ℕ) [HasProjectiveDimensionLE M n] : HasProjectiveDimensionLE N n := by
@@ -88,7 +87,6 @@ alias _root_.CategoryTheory.hasProjectiveDimensionLE_of_semiLinearEquiv :=
   hasProjectiveDimensionLE_of_semiLinearEquiv
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 lemma projectiveDimension_eq_of_semiLinearEquiv (e' : M ≃ₛₗ[RingHomClass.toRingHom e] N) :
     projectiveDimension M = projectiveDimension N := by
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Sheaf/LocallyFree.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Sheaf/LocallyFree.lean
index aee7ac299..c157a2ada 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Sheaf/LocallyFree.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Sheaf/LocallyFree.lean
@@ -92,7 +92,6 @@ instance (I : Type u) : IsIso (free.generatingSections (R := R) I).π := by
 variable [∀ X, HasSheafify (J.over X) AddCommGrpCat.{u}] [HasBinaryProducts C]
   [∀ X, (J.over X).WEqualsLocallyBijective AddCommGrpCat.{u}] [HasSheafify J AddCommGrpCat]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 instance (I : Type u) :
diff --git a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
index e4dcce5c3..fe3563471 100644
--- a/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Category/ModuleCat/Topology/Basic.lean
@@ -228,7 +228,6 @@ def ofCocone {J : Type*} [Category* J] {F : J ⥤ TopModuleCat R}
     naturality {X Y} f := by ext x; exact congr($(c.ι.naturality f).hom x) }
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a colimit cocone over the underlying modules, equipping the cocone point with
 the coinduced topology gives a colimit cocone in `TopModuleCat R`. -/
 def isColimit {J : Type*} [Category* J] {F : J ⥤ TopModuleCat R}
@@ -267,7 +266,6 @@ variable {R}
 
 variable {M : ModuleCat R} {I : Type*} {X : I → TopModuleCat R} (f : ∀ i, M ⟶ (X i).toModuleCat)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The induced topology on `M` from a family of continuous linear maps from `M`, which is the
 coarsest topology that makes every map continuous. -/
 def induced : TopModuleCat R :=
@@ -405,7 +403,6 @@ def freeObj (X : TopCat.{v}) : TopModuleCat.{max v u} R :=
 
 lemma coe_freeObj (X : TopCat.{v}) : freeObj R X = (X →₀ R) := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.instances false in
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
@@ -430,7 +427,6 @@ lemma freeMap_map {X Y : TopCat.{v}} (f : X ⟶ Y) (v : X →₀ R) :
     (freeMap R f : (X →₀ R) → (Y →₀ R)) v = Finsupp.mapDomain f.hom v := rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The free topological module over a topological space as a functor.
 This is left adjoint to the forgetful functor. -/
 @[simps] noncomputable
@@ -441,7 +437,6 @@ def free : TopCat.{v} ⥤ TopModuleCat.{max v u} R :=
     map_comp f g := by ext; exact DFunLike.congr_fun (Finsupp.lmapDomain_comp _ _ f.hom g.hom) _ }
 
 set_option backward.isDefEq.instanceTypes false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.instances false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
diff --git a/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean b/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
index 7c900f7f5..309ddebc0 100644
--- a/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Ring/Constructions.lean
@@ -315,7 +315,6 @@ The categorical product of rings is the Cartesian product of rings. This is its
 def piFan : Fan R :=
   Fan.mk (CommRingCat.of ((i : ι) → R i)) (fun i ↦ ofHom <| Pi.evalRingHom _ i)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The categorical product of rings is the Cartesian product of rings.
 -/
@@ -344,7 +343,6 @@ namespace Limits
 
 variable {J : Type u'} [SmallCategory J] (F : J ⥤ CommRingCat.{u}) {c : Cone F}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem isUnit_iff_forall_isUnit (hc : IsLimit c) (r : c.pt) : IsUnit r ↔
     ∀ (j : J), IsUnit (c.π.app j r) := by
@@ -485,7 +483,6 @@ def pullbackConeIsLimit (f : A ⟶ C) (g : B ⟶ C) :
 
 open WalkingCospan
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance pullbackFst_isLocalHom (f : A ⟶ C) (g : B ⟶ C) [IsLocalHom g.hom] :
     IsLocalHom (pullback.fst f g).hom := by
   refine Limits.π_isLocalHom _ (limit.isLimit _) left fun x hx i ↦ ?_
diff --git a/mathlib4/Mathlib/Algebra/Category/Ring/EqualizerPushout.lean b/mathlib4/Mathlib/Algebra/Category/Ring/EqualizerPushout.lean
index e1935a4a9..c2b9c00e3 100644
--- a/mathlib4/Mathlib/Algebra/Category/Ring/EqualizerPushout.lean
+++ b/mathlib4/Mathlib/Algebra/Category/Ring/EqualizerPushout.lean
@@ -34,7 +34,6 @@ section Fork
 variable {R S : CommRingCat.{u}} (f : R ⟶ S)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `f : R ⟶ S` is a faithfully flat map in `CommRingCat`, then the fork
 ```
         S ---inl---> pushout f f
diff --git a/mathlib4/Mathlib/Algebra/Colimit/DirectLimit.lean b/mathlib4/Mathlib/Algebra/Colimit/DirectLimit.lean
index 272555f0e..c00d58f3f 100644
--- a/mathlib4/Mathlib/Algebra/Colimit/DirectLimit.lean
+++ b/mathlib4/Mathlib/Algebra/Colimit/DirectLimit.lean
@@ -523,7 +523,6 @@ instance [∀ i, AddZeroClass (G i)] [∀ i, DistribSMul R (G i)]
   smul_add r := DirectLimit.induction₂ _ fun i _ _ ↦ by
     simp_rw [add_def, smul_def, smul_add, add_def]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance [Monoid R] [∀ i, AddMonoid (G i)] [∀ i, DistribMulAction R (G i)]
     [∀ i j h, DistribMulActionHomClass (T h) R (G i) (G j)] :
     DistribMulAction R (DirectLimit G f) :=
@@ -635,7 +634,6 @@ lemma map₀_algebraMap (i : ι) (r : R) :
     map₀ f (fun i ↦ algebraMap R (G i) r) = ⟦⟨i, algebraMap R (G i) r⟩⟧ :=
   map₀_def _ _ (fun _ _ _ => AlgHomClass.commutes _ _) i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 instance : Algebra R (DirectLimit G f) where
   algebraMap := map₀RingHom (f := f).comp (algebraMap R (∀ i, G i))
@@ -663,7 +661,6 @@ variable [Semiring R] [∀ i, AddCommMonoid (G i)] [∀ i, Module R (G i)]
 variable [∀ i j h, LinearMapClass (T h) R (G i) (G j)]
 variable (R ι G f) [Nonempty ι]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The canonical map from a component to the direct limit. -/
 @[simps]
 def of (i) : G i →ₗ[R] DirectLimit G f where
@@ -677,7 +674,6 @@ theorem of_f {i j hij x} : of R ι G f j (f i j hij x) = of R ι G f i x := .sym
 
 variable {P : Type*} [AddCommMonoid P] [Module R P]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R ι G f) in
 /-- The universal property of the direct limit: maps from the components to another module
 that respect the directed system structure (i.e. make some diagram commute) give rise
@@ -903,7 +899,6 @@ variable [∀ i, NonUnitalNonAssocSemiring (G i)] [∀ i, DistribMulAction R (G
 variable [∀ i j h, NonUnitalAlgHomClass (T h) R (G i) (G j)]
 variable [Nonempty ι]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (G f) in
 /-- The canonical map from a component to the direct limit. -/
 def of (i) : G i →ₙₐ[R] DirectLimit G f where
@@ -915,7 +910,6 @@ lemma of_f {i j} (hij) (x) : of G f j (f i j hij x) = of G f i x := .symm <| eq_
 
 variable (P : Type*) [NonUnitalNonAssocSemiring P] [DistribMulAction R P]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (G f) in
 /-- The universal property of the direct limit: maps from the components to another R-algebra
 that respect the directed system structure (i.e. make some diagram commute) give rise
@@ -930,11 +924,9 @@ def lift (g : ∀ i, G i →ₙₐ[R] P) (Hg : ∀ i j hij x, g j (f i j hij x)
 
 variable (g : ∀ i, G i →ₙₐ[R] P) (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem lift_comp_of {i} : (lift G f P g Hg).comp (of G f i) = g i := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem lift_of (i x) : lift G f P g Hg (of G f i x) = g i x := rfl
 
 @[ext]
diff --git a/mathlib4/Mathlib/Algebra/Colimit/Module.lean b/mathlib4/Mathlib/Algebra/Colimit/Module.lean
index cc4e85317..9e4d148fa 100644
--- a/mathlib4/Mathlib/Algebra/Colimit/Module.lean
+++ b/mathlib4/Mathlib/Algebra/Colimit/Module.lean
@@ -51,7 +51,6 @@ inductive DirectLimit.Eqv [DecidableEq ι] : DirectSum ι G → DirectSum ι G 
   | of_map {i j} (h : i ≤ j) (x : G i) :
     Eqv (DirectSum.lof R ι G i x) (DirectSum.lof R ι G j <| f i j h x)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The congruence relation to quotient the direct sum by to obtain the direct limit. -/
 def DirectLimit.moduleCon [DecidableEq ι] : ModuleCon R (DirectSum ι G) :=
   SMulCon.addConGen' (Eqv f) <| by rintro _ _ _ ⟨⟩; simpa only [← map_smul] using .of_map ..
@@ -92,7 +91,6 @@ variable {R ι G f}
 
 theorem quotMk_of (i x) : Quot.mk _ (.of G i x) = of R ι G f i x := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem of_f {i j hij x} : of R ι G f j (f i j hij x) = of R ι G f i x :=
   (AddCon.eq _).mpr <| .symm <| .of _ _ (.of_map _ _)
@@ -125,7 +123,6 @@ protected theorem induction_on [Nonempty ι] [IsDirectedOrder ι] {C : DirectLim
 
 variable {P : Type*} [AddCommMonoid P] [Module R P]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R ι G f) in
 /-- The universal property of the direct limit: maps from the components to another module
 that respect the directed system structure (i.e. make some diagram commute) give rise
@@ -138,7 +135,6 @@ def lift (g : ∀ i, G i →ₗ[R] P) (Hg : ∀ i j hij x, g j (f i j hij x) = g
 
 variable (g : ∀ i, G i →ₗ[R] P) (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] theorem lift_of {i} (x) : lift R ι G f g Hg (of R ι G f i x) = g i x :=
   DirectSum.toModule_lof R _ _
 
diff --git a/mathlib4/Mathlib/Algebra/DirectSum/Algebra.lean b/mathlib4/Mathlib/Algebra/DirectSum/Algebra.lean
index 02dd38b7d..cdaafbd69 100644
--- a/mathlib4/Mathlib/Algebra/DirectSum/Algebra.lean
+++ b/mathlib4/Mathlib/Algebra/DirectSum/Algebra.lean
@@ -106,7 +106,6 @@ theorem algebraMap_toAddMonoid_hom :
     ↑(algebraMap R (⨁ i, A i)) = (DirectSum.of A 0).comp (GAlgebra.toFun : R →+ A 0) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A family of `LinearMap`s preserving `DirectSum.GOne.one` and `DirectSum.GMul.mul`
 describes an `AlgHom` on `⨁ i, A i`. This is a stronger version of `DirectSum.toSemiring`.
 
diff --git a/mathlib4/Mathlib/Algebra/DirectSum/Decomposition.lean b/mathlib4/Mathlib/Algebra/DirectSum/Decomposition.lean
index d803ac190..fb3138888 100644
--- a/mathlib4/Mathlib/Algebra/DirectSum/Decomposition.lean
+++ b/mathlib4/Mathlib/Algebra/DirectSum/Decomposition.lean
@@ -256,7 +256,6 @@ abbrev Decomposition.ofLinearMap (decompose : M →ₗ[R] ⨁ i, ℳ i)
 
 variable [Decomposition ℳ]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `M` is graded by `ι` with degree `i` component `ℳ i`, then it is isomorphic as
 a module to a direct sum of components. -/
 def decomposeLinearEquiv : M ≃ₗ[R] ⨁ i, ℳ i :=
@@ -269,7 +268,6 @@ theorem decomposeLinearEquiv_apply (m : M) :
 theorem decomposeLinearEquiv_symm_apply (m : ⨁ i, ℳ i) :
     (decomposeLinearEquiv ℳ).symm m = (decompose ℳ).symm m := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem decompose_smul (r : R) (x : M) : decompose ℳ (r • x) = r • decompose ℳ x :=
   map_smul (decomposeLinearEquiv ℳ) r x
diff --git a/mathlib4/Mathlib/Algebra/Group/Action/Sigma.lean b/mathlib4/Mathlib/Algebra/Group/Action/Sigma.lean
index e0e835c84..f593f1244 100644
--- a/mathlib4/Mathlib/Algebra/Group/Action/Sigma.lean
+++ b/mathlib4/Mathlib/Algebra/Group/Action/Sigma.lean
@@ -38,7 +38,6 @@ variable [∀ i, SMul M (α i)] [∀ i, SMul N (α i)] (a : M) (i : ι) (b : α
 instance : SMul M (Σ i, α i) :=
   ⟨fun a => (Sigma.map id) fun _ => (a • ·)⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 theorem smul_def : a • x = x.map id fun _ => (a • ·) :=
   rfl
diff --git a/mathlib4/Mathlib/Algebra/Group/ForwardDiff.lean b/mathlib4/Mathlib/Algebra/Group/ForwardDiff.lean
index 0abd31c1e..895643625 100644
--- a/mathlib4/Mathlib/Algebra/Group/ForwardDiff.lean
+++ b/mathlib4/Mathlib/Algebra/Group/ForwardDiff.lean
@@ -140,7 +140,6 @@ open fwdDiff_aux
 
 section newton_formulae
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 Express the `n`-th forward difference of `f` at `y` in terms of the values `f (y + k)`, for
 `0 ≤ k ≤ n`.
diff --git a/mathlib4/Mathlib/Algebra/Homology/Embedding/AreComplementary.lean b/mathlib4/Mathlib/Algebra/Homology/Embedding/AreComplementary.lean
index 726fe0ac0..4668f5903 100644
--- a/mathlib4/Mathlib/Algebra/Homology/Embedding/AreComplementary.lean
+++ b/mathlib4/Mathlib/Algebra/Homology/Embedding/AreComplementary.lean
@@ -310,7 +310,6 @@ noncomputable def shortComplexTruncLEX₃ToTruncGE :
   cokernel.desc _ (K.πTruncGE e₂) (ac.hom_ext _)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp)]
 lemma g_shortComplexTruncLEX₃ToTruncGE :
     (K.shortComplexTruncLE e₁).g ≫ K.shortComplexTruncLEX₃ToTruncGE ac = K.πTruncGE e₂ :=
diff --git a/mathlib4/Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean b/mathlib4/Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
index 504fb8185..daba20952 100644
--- a/mathlib4/Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
+++ b/mathlib4/Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
@@ -390,7 +390,6 @@ lemma shift_units_smul (a : ℤ) (x : Rˣ) :
   dsimp
   simp only [shift_v', units_smul_v]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma rightUnshift_smul {n' a : ℤ} (γ : Cochain K (L⟦a⟧) n') (n : ℤ) (hn : n' + a = n) (x : R) :
     (x • γ).rightUnshift n hn = x • γ.rightUnshift n hn := by
@@ -403,7 +402,6 @@ lemma rightUnshift_units_smul {n' a : ℤ} (γ : Cochain K (L⟦a⟧) n') (n : 
     (x • γ).rightUnshift n hn = x • γ.rightUnshift n hn := by
   apply rightUnshift_smul
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma leftUnshift_smul {n' a : ℤ} (γ : Cochain (K⟦a⟧) L n') (n : ℤ) (hn : n + a = n') (x : R) :
     (x • γ).leftUnshift n hn = x • γ.leftUnshift n hn := by
diff --git a/mathlib4/Mathlib/Algebra/Homology/SpectralObject/Cycles.lean b/mathlib4/Mathlib/Algebra/Homology/SpectralObject/Cycles.lean
index 983ef28c8..457f4629d 100644
--- a/mathlib4/Mathlib/Algebra/Homology/SpectralObject/Cycles.lean
+++ b/mathlib4/Mathlib/Algebra/Homology/SpectralObject/Cycles.lean
@@ -295,7 +295,6 @@ noncomputable def toCycles (n : ℤ) :
   kernel.lift _ ((X.H n).map (twoδ₁Toδ₀ f g fg h)) (by simp)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (n : ℤ) : Epi (X.toCycles f g fg h n) :=
   (ShortComplex.exact_iff_epi_kernel_lift _).1 (X.exact₃ f g fg h n (n + 1))
 
@@ -328,7 +327,6 @@ noncomputable def fromOpcycles (n : ℤ) :
   cokernel.desc _ ((X.H n).map (twoδ₂Toδ₁ f g fg h)) (by simp)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (n : ℤ) : Mono (X.fromOpcycles f g fg h n) :=
   (ShortComplex.exact_iff_mono_cokernel_desc _).1 (X.exact₁ f g fg h (n - 1) n)
 
diff --git a/mathlib4/Mathlib/Algebra/Lie/Abelian.lean b/mathlib4/Mathlib/Algebra/Lie/Abelian.lean
index be9b489f1..f5aeda58e 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Abelian.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Abelian.lean
@@ -205,7 +205,6 @@ theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M
 
 variable {R L M N}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `maxTrivSubmodule` is functorial. -/
 def maxTrivHom (f : M →ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M →ₗ⁅R,L⁆ maxTrivSubmodule R L N where
diff --git a/mathlib4/Mathlib/Algebra/Lie/BaseChange.lean b/mathlib4/Mathlib/Algebra/Lie/BaseChange.lean
index 0cbe83d88..75dd94397 100644
--- a/mathlib4/Mathlib/Algebra/Lie/BaseChange.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/BaseChange.lean
@@ -111,7 +111,6 @@ instance instLieRing : LieRing (A ⊗[R] L) where
 
 instance instBaseLieAlgebra : LieAlgebra R (A ⊗[R] L) where lie_smul := by simp [bracket_def]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance instLieAlgebra : LieAlgebra A (A ⊗[R] L) where lie_smul _a _x _y := map_smul _ _ _
 
 set_option backward.privateInPublic true in
@@ -121,7 +120,6 @@ instance instLieRingModule : LieRingModule (A ⊗[R] L) (A ⊗[R] M) where
   lie_add x y z := by simp only [bracket_def, map_add]
   leibniz_lie := bracket_leibniz_lie R A L M
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance instLieModule : LieModule A (A ⊗[R] L) (A ⊗[R] M) where
   smul_lie t x m := by simp only [bracket_def, map_smul, LinearMap.smul_apply]
@@ -185,7 +183,6 @@ variable (N : LieSubmodule R L M)
 
 open LieModule
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable {R L M} in
 /-- If `A` is an `R`-algebra, any Lie submodule of a Lie module `M` with coefficients in `R` may be
diff --git a/mathlib4/Mathlib/Algebra/Lie/Basic.lean b/mathlib4/Mathlib/Algebra/Lie/Basic.lean
index 559abaaef..381271a19 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Basic.lean
@@ -245,7 +245,6 @@ instance : LieModule ℤ L M where
   smul_lie n x m := zsmul_lie x m n
   lie_smul n x m := lie_zsmul x m n
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance LinearMap.instLieRingModule : LieRingModule L (M →ₗ[R] N) where
   bracket x f :=
@@ -272,7 +271,6 @@ instance LinearMap.instLieRingModule : LieRingModule L (M →ₗ[R] N) where
 theorem LieHom.lie_apply (f : M →ₗ[R] N) (x : L) (m : M) : ⁅x, f⁆ m = ⁅x, f m⁆ - f ⁅x, m⁆ :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance LinearMap.instLieModule : LieModule R L (M →ₗ[R] N) where
   smul_lie t x f := by
@@ -488,7 +486,6 @@ theorem LieRingModule.compLieHom_apply (x : L₁) (m : M) :
     ⁅x, m⁆ = ⁅f x, m⁆ :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A Lie module may be pulled back along a morphism of Lie algebras. -/
 theorem LieModule.compLieHom [Module R M] [LieModule R L₂ M] :
@@ -567,7 +564,6 @@ theorem toLinearEquiv_injective : Injective ((↑) : (L₁ ≃ₗ⁅R⁆ L₂) 
 theorem coe_injective : @Injective (L₁ ≃ₗ⁅R⁆ L₂) (L₁ → L₂) (↑) :=
   LinearEquiv.coe_injective.comp toLinearEquiv_injective
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : LinearEquivClass (L₁ ≃ₗ⁅R⁆ L₂) R L₁ L₂ where
   map_add _ _ _ := by
     rw [← coe_toLinearEquiv, map_add]
@@ -951,7 +947,6 @@ theorem toEquiv_injective : Function.Injective (toEquiv : (M ≃ₗ⁅R,L⁆ N)
 theorem ext (e₁ e₂ : M ≃ₗ⁅R,L⁆ N) (h : ∀ m, e₁ m = e₂ m) : e₁ = e₂ :=
   toEquiv_injective (Equiv.ext h)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : LinearEquivClass (M ≃ₗ⁅R,L⁆ N) R M N where
   map_add _ _ _ := by
     rw [← coe_toLinearEquiv, map_add]
diff --git a/mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean b/mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean
index 00a32c56d..0b0ee9794 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Basis/Basic.lean
@@ -300,7 +300,6 @@ lemma linearIndependent_baseSupp [IsDomain R] [CharZero R] :
   have hv : LinearIndependent R v := Basis.linearIndependent_coord _
   simpa [Int.cast_smul_eq_zsmul] using! hv.sum_smul_of_nondegenerate this
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma baseSupp_apply_smul_e (i : ι) (x : H) :
     b.baseSupp i x • b.e i = ⁅x, b.e i⁆ := by
   obtain ⟨x, hx⟩ := x
diff --git a/mathlib4/Mathlib/Algebra/Lie/CartanCriterion.lean b/mathlib4/Mathlib/Algebra/Lie/CartanCriterion.lean
index db30a4989..5eb3e2e7a 100644
--- a/mathlib4/Mathlib/Algebra/Lie/CartanCriterion.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/CartanCriterion.lean
@@ -70,7 +70,6 @@ lemma exists_polynomial_eval_sub_aux
 variable [AddCommGroup M] [LieRingModule L M]
 attribute [local instance 100] LieRing.ofAssociativeRing
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An auxiliary lemma used to prove `LieModule.isNilpotent_derivedSeries_of_traceForm_eq_zero`
 which proves the same result except without the algebraically closed assumption. -/
 theorem isNilpotent_derivedSeries_of_traceForm_eq_zero_aux {K : Type*}
diff --git a/mathlib4/Mathlib/Algebra/Lie/CartanExists.lean b/mathlib4/Mathlib/Algebra/Lie/CartanExists.lean
index d28e96f0d..64c74afcf 100644
--- a/mathlib4/Mathlib/Algebra/Lie/CartanExists.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/CartanExists.lean
@@ -95,7 +95,6 @@ set_option backward.privateInPublic.warn false in
 lemma lieCharpoly_natDegree [Nontrivial R] : (lieCharpoly R M x y).natDegree = finrank R M := by
   rw [lieCharpoly, (polyCharpoly_monic _ _).natDegree_map, polyCharpoly_natDegree]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.privateInPublic true in
 set_option backward.privateInPublic.warn false in
 variable {R} in
diff --git a/mathlib4/Mathlib/Algebra/Lie/Character.lean b/mathlib4/Mathlib/Algebra/Lie/Character.lean
index 8bf66f495..230e525f1 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Character.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Character.lean
@@ -49,7 +49,6 @@ theorem lieCharacter_apply_lie (χ : LieCharacter R L) (x y : L) : χ ⁅x, y⁆
 theorem lieCharacter_apply_lie' (χ : LieCharacter R L) (x y : L) : ⁅χ x, χ y⁆ = 0 := by
   rw [LieRing.of_associative_ring_bracket, mul_comm, sub_self]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem lieCharacter_apply_of_mem_derived (χ : LieCharacter R L) {x : L}
     (h : x ∈ derivedSeries R L 1) : χ x = 0 := by
   rw [derivedSeries_def, derivedSeriesOfIdeal_succ, derivedSeriesOfIdeal_zero, ←
diff --git a/mathlib4/Mathlib/Algebra/Lie/Cochain.lean b/mathlib4/Mathlib/Algebra/Lie/Cochain.lean
index 5659934a0..4370193d3 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Cochain.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Cochain.lean
@@ -118,7 +118,6 @@ lemma d₁₂_apply_apply_ofTrivial [LieModule.IsTrivial L M] (f : oneCochain R
     d₁₂ R L M f x y = - f ⁅x, y⁆ := by
   simp [trivial_lie_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The coboundary operator taking degree 2 cochains to a space containing degree 3 cochains. -/
 def d₂₃ : twoCochain R L M →ₗ[R] L →ₗ[R] L →ₗ[R] L →ₗ[R] M where
   toFun a := {
diff --git a/mathlib4/Mathlib/Algebra/Lie/Derivation/Basic.lean b/mathlib4/Mathlib/Algebra/Lie/Derivation/Basic.lean
index 44894a344..564378d8f 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Derivation/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Derivation/Basic.lean
@@ -107,7 +107,6 @@ lemma apply_lie_eq_add (D : LieDerivation R L L) (a b : L) :
     D ⁅a, b⁆ = ⁅a, D b⁆ + ⁅D a, b⁆ := by
   rw [LieDerivation.apply_lie_eq_sub, sub_eq_add_neg, lie_skew]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Two Lie derivations equal on a set are equal on its Lie span. -/
 theorem eqOn_lieSpan {s : Set L} (h : Set.EqOn D1 D2 s) :
@@ -319,7 +318,6 @@ instance : LieRing (LieDerivation R L L) where
   leibniz_lie d e f := by
     ext a; simp only [commutator_apply, add_apply, map_sub]; abel
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The set of Lie derivations from a Lie algebra `L` to itself is a Lie algebra. -/
 instance instLieAlgebra : LieAlgebra R (LieDerivation R L L) where
@@ -385,7 +383,6 @@ instance instLieRingModule : LieRingModule L (LieDerivation R L M) where
     ⁅x, (D : L →ₗ[R] M)⁆ = ⁅x, D⁆ := by
   ext; simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance instLieModule : LieModule R L (LieDerivation R L M) where
   smul_lie t x D := by ext; simp
diff --git a/mathlib4/Mathlib/Algebra/Lie/Extension.lean b/mathlib4/Mathlib/Algebra/Lie/Extension.lean
index 75460b534..80fbb9a4f 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Extension.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Extension.lean
@@ -299,7 +299,6 @@ lemma lie_incl_mem_ker {E : Extension R M L} (x : E.L) (y : M) :
     ⁅x, E.incl y⁆ ∈ E.proj.ker := by
   rw [LieHom.mem_ker, LieHom.map_lie, proj_incl, lie_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- The Lie algebra isomorphism from the kernel of an extension to the kernel of the projection. -/
 noncomputable def toKer (E : Extension R M L) :
@@ -352,7 +351,6 @@ lemma ringModuleOf_bracket_proj [IsLieAbelian M] (E : Extension R M L) (y : M) (
     Subtype.ext_iff, LieSubmodule.coe_bracket, lie_toKer_apply, ZeroMemClass.coe_zero, ← hx,
     LieHom.coe_toLinearMap, ← LieHom.map_lie, trivial_lie_zero M M x y, map_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given an extension of `L` by `M` whose kernel `M` is abelian, the kernel `M` gets an `R`-linear
 `L`-module structure. We do not make this an instance, because we may have to work with more than
 one extension. -/
@@ -425,7 +423,6 @@ noncomputable def twoCocycleOf [IsLieAbelian M] (E : Extension R M L) {s : L →
       sub_add_cancel_right, map_add, neg_add_rev]
     abel_nf
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The 1-cochain attached to a pair of splittings of an extension. -/
 @[simps]
 noncomputable def oneCochainOfTwoSplitting (E : Extension R M L) {s₁ s₂ : L →ₗ[R] E.L}
diff --git a/mathlib4/Mathlib/Algebra/Lie/Free.lean b/mathlib4/Mathlib/Algebra/Lie/Free.lean
index a430832ce..83833f85c 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Free.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Free.lean
@@ -185,7 +185,6 @@ variable {L : Type w} [LieRing L] [LieAlgebra R L]
 def liftAux (f : X → CommutatorRing L) :=
   lib.lift R f
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem liftAux_map_smul (f : X → L) (t : R) (a : lib R X) :
     liftAux R f (t • a) = t • liftAux R f a :=
   map_smul _ t a
diff --git a/mathlib4/Mathlib/Algebra/Lie/Graded.lean b/mathlib4/Mathlib/Algebra/Lie/Graded.lean
index 644e27a48..5c7729945 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Graded.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Graded.lean
@@ -83,7 +83,6 @@ lemma decompose_symm_bracket (x y : ⨁ i, ℒ i) :
   simp only [← decomposeLinearEquiv_symm_apply]
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance : LieAlgebra R (⨁ i, ℒ i) where
   add_smul _ _ _ := by simp [add_smul]
@@ -143,7 +142,6 @@ lemma ofGradingSum_of (φ : ι →+ R) (i : ι) (a : ℒ i) :
     ofGradingSum ℒ φ (of (ℒ ·) i a) = (φ i) • (of (ℒ ·) i a) := by
   simp [← lof_eq_of R, ofGradingSum]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The Lie derivation on a graded Lie algebra that scalar-multiplies by an additive function of
 the degree. -/
@@ -154,7 +152,6 @@ def ofGrading (φ : ι →+ R) :
   map_smul' _ _ := by simp
   leibniz' x y := by simp [decomposeLinearEquiv_apply, decomposeLinearEquiv_symm_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma ofGrading_apply_apply (φ : ι →+ R) {i : ι} {a : L} (ha : a ∈ ℒ i) :
     ofGrading ℒ φ a = φ i • a := by
diff --git a/mathlib4/Mathlib/Algebra/Lie/Loop.lean b/mathlib4/Mathlib/Algebra/Lie/Loop.lean
index 4d3cf1a94..7ce93dfbd 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Loop.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Loop.lean
@@ -122,7 +122,6 @@ lemma toFinsupp_single_tmul (c : A) (z : L) :
     (toFinsupp R A L (AddMonoidAlgebra.single c 1 ⊗ₜ[R] z)) = Finsupp.single c z := by
   simp [← toFinsupp_symm_single]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open Finsupp in
 set_option backward.isDefEq.respectTransparency false in
 /-- The residue pairing on the loop algebra.  When `A = ℤ` and the elements are viewed as Laurent
diff --git a/mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean b/mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean
index be02de91b..0532ebe7a 100644
--- a/mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/SemiDirect.lean
@@ -96,7 +96,6 @@ instance : LieRing (K ⋊⁅ψ⁆ L) where
   lie_self _ := by simp
   leibniz_lie _ _ _ := by simp; grind [lie_skew]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance : LieAlgebra R (K ⋊⁅ψ⁆ L) where
   lie_smul _ _ _ := by simp [smul_sub, smul_add]
diff --git a/mathlib4/Mathlib/Algebra/Lie/Semisimple/Lemmas.lean b/mathlib4/Mathlib/Algebra/Lie/Semisimple/Lemmas.lean
index 4e12cad34..37d353285 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Semisimple/Lemmas.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Semisimple/Lemmas.lean
@@ -79,7 +79,6 @@ theorem hasTrivialRadical_of_isIrreducible_of_isFaithful
 variable {k L M}
 variable {R : Type*} [CommRing R] [LieAlgebra R L] [Module R M] [LieModule R L M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open LinearMap in
 lemma trace_toEnd_eq_zero {s : Set L} (hs : ∀ x ∈ s, LinearMap.trace R _ (toEnd R _ M x) = 0)
     {x : L} (hx : x ∈ LieSubalgebra.lieSpan R L s) :
diff --git a/mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean b/mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean
index fd5ff8a36..c0100e63d 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Subalgebra.lean
@@ -549,7 +549,6 @@ variable {K K'} in
 variable (R L)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance wellFoundedGT_of_noetherian [IsNoetherian R L] : WellFoundedGT (LieSubalgebra R L) :=
   RelHomClass.isWellFounded (⟨toSubmodule, @fun _ _ h ↦ h⟩ : _ →r (· > ·))
 
diff --git a/mathlib4/Mathlib/Algebra/Lie/Submodule.lean b/mathlib4/Mathlib/Algebra/Lie/Submodule.lean
index 7cf72d82e..01f465b63 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Submodule.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Submodule.lean
@@ -521,7 +521,6 @@ variable (R L M)
 -- Defeq abuse: need `FunLike _ (LieSubmodule R L M) (Submodule R M)ᵒᵈ`, get
 -- `FunLike _ (LieSubmodule R L M)ᵒᵈ (Submodule R M)ᵒᵈ`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance wellFoundedGT_of_noetherian [IsNoetherian R M] : WellFoundedGT (LieSubmodule R L M) :=
   RelHomClass.isWellFounded (toSubmodule_orderEmbedding R L M).dual.ltEmbedding
 
diff --git a/mathlib4/Mathlib/Algebra/Lie/TensorProduct.lean b/mathlib4/Mathlib/Algebra/Lie/TensorProduct.lean
index fbb1ba22e..3db802952 100644
--- a/mathlib4/Mathlib/Algebra/Lie/TensorProduct.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/TensorProduct.lean
@@ -66,7 +66,6 @@ instance lieRingModule : LieRingModule L (M ⊗[R] N) where
       map_add, LieHom.lie_apply, Module.End.lie_apply, LinearMap.lTensor_tmul]
     abel
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The tensor product of two Lie modules is a Lie module. -/
 instance lieModule : LieModule R L (M ⊗[R] N) where
diff --git a/mathlib4/Mathlib/Algebra/Lie/TraceForm.lean b/mathlib4/Mathlib/Algebra/Lie/TraceForm.lean
index 337fa99c4..b8117c7d2 100644
--- a/mathlib4/Mathlib/Algebra/Lie/TraceForm.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/TraceForm.lean
@@ -114,7 +114,6 @@ open scoped TensorProduct in
     traceForm A (A ⊗[R] L) (A ⊗[R] M) = (traceForm R L M).baseChange A := by
   ext; simp [traceForm_apply_apply, ← LinearMap.baseChange_comp, Algebra.algebraMap_eq_smul_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable {R L M} in
 lemma trace_toEnd_mul_eq_zero_of_traceForm_eq_zero (h : traceForm R L M = 0)
     (y : End R M) (hy : ∀ z ∈ LieHom.range φ, ⁅y, z⁆ ∈ LieHom.range φ)
@@ -135,7 +134,6 @@ lemma trace_toEnd_mul_eq_zero_of_traceForm_eq_zero (h : traceForm R L M = 0)
   | add u v _ _ hu hv => simp [add_mul, hu, hv]
   | smul t u _ hu => simp [hu]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma traceForm_genWeightSpace_eq [Module.Free R M]
     [IsDomain R] [IsPrincipalIdealRing R]
@@ -218,7 +216,6 @@ lemma eq_zero_of_mem_genWeightSpace_mem_posFitting [LieRing.IsNilpotent L]
   obtain ⟨m, rfl⟩ := (mem_posFittingCompOf R x m₁).mp hm₁ k
   simp [hB, hk]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma trace_toEnd_eq_zero_of_mem_lcs
     {k : ℕ} {x : L} (hk : 1 ≤ k) (hx : x ∈ lowerCentralSeries R L L k) :
     trace R _ (toEnd R L M x) = 0 := by
diff --git a/mathlib4/Mathlib/Algebra/Lie/TransferInstance.lean b/mathlib4/Mathlib/Algebra/Lie/TransferInstance.lean
index 7b0d22ce3..c5f8ac587 100644
--- a/mathlib4/Mathlib/Algebra/Lie/TransferInstance.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/TransferInstance.lean
@@ -39,7 +39,6 @@ lemma AddEquiv.bracket_def (e : M ≃+ L) (x y : M) :
     letI := e.lieRing
     ⁅x, y⁆ = e.symm ⁅e x, e y⁆ := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Transfer `LieAlgebra` across a `LinearEquiv` -/
 protected abbrev LinearEquiv.lieAlgebra (e : M ≃ₗ[R] L) :
     letI := e.toAddEquiv.lieRing
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/Basic.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/Basic.lean
index 4aba6a4a1..d7a5aac91 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/Basic.lean
@@ -72,7 +72,6 @@ section notation_genWeightSpaceOf
 /-- Until we define `LieModule.genWeightSpaceOf`, it is useful to have some notation as follows: -/
 local notation3 "𝕎("M", " χ", " x")" => (toEnd R L M x).maxGenEigenspace χ
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- See also `bourbaki1975b` Chapter VII §1.1, Proposition 2 (ii). -/
 protected theorem weight_vector_multiplication (M₁ M₂ M₃ : Type*)
     [AddCommGroup M₁] [Module R M₁] [LieRingModule L M₁] [LieModule R L M₁] [AddCommGroup M₂]
@@ -507,7 +506,6 @@ lemma map_posFittingComp_le :
   use f n
   rw [LieModule.toEnd_pow_apply_map, hn]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma map_genWeightSpace_le :
     (genWeightSpace M χ).map f ≤ genWeightSpace M₂ χ := by
   rw [LieSubmodule.map_le_iff_le_comap]
@@ -522,7 +520,6 @@ lemma map_genWeightSpace_le :
 
 variable {f}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma comap_genWeightSpace_eq_of_injective (hf : Injective f) :
     (genWeightSpace M₂ χ).comap f = genWeightSpace M χ := by
   refine le_antisymm (fun m hm ↦ ?_) ?_
@@ -738,7 +735,6 @@ lemma iSup_genWeightSpaceOf_eq_top [IsTriangularizable R L M] (x : L) :
   dsimp [genWeightSpaceOf]
   exact IsTriangularizable.maxGenEigenspace_eq_top x
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open LinearMap Module in
 @[simp]
 lemma trace_toEnd_genWeightSpace [IsDomain R] [IsPrincipalIdealRing R]
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/Chain.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/Chain.lean
index 846b44ccb..92e837262 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/Chain.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/Chain.lean
@@ -174,7 +174,6 @@ section IsCartanSubalgebra
 variable [H.IsCartanSubalgebra] [IsNoetherian R L]
 attribute [local instance 100] LieRing.ofAssociativeRing
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma trace_toEnd_genWeightSpaceChain_eq_zero
     (hp : genWeightSpace M (p • α + χ) = ⊥)
     (hq : genWeightSpace M (q • α + χ) = ⊥)
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/IsSimple.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/IsSimple.lean
index 57587412d..6fb2317ca 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/IsSimple.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/IsSimple.lean
@@ -293,7 +293,6 @@ private theorem chi_in_q_aux (h_chi_in_q : ↑χ ∈ q) :
 
 include hq hα₀ hy
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private theorem chi_not_in_q_aux (h_chi_not_in_q : ↑χ ∉ q) :
     ⁅x_χ, m_α⁆ ∈ ⨆ α : {α : Weight K H L // ↑α ∈ q ∧ α.IsNonZero}, sl2SubmoduleOfRoot α.2.2 := by
   let S := rootSystem H
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/Killing.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/Killing.lean
index 2ad88c21d..5913e4f43 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/Killing.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/Killing.lean
@@ -239,7 +239,6 @@ variable {K L H}
 noncomputable def coroot (α : Weight K H L) : H :=
   2 • (α <| (cartanEquivDual H).symm α)⁻¹ • (cartanEquivDual H).symm α
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma traceForm_coroot (α : Weight K H L) (x : H) :
     traceForm K H L (coroot α) x = 2 • (α <| (cartanEquivDual H).symm α)⁻¹ • α x := by
   have : cartanEquivDual H ((cartanEquivDual H).symm α) x = α x := by
@@ -474,7 +473,6 @@ lemma coe_corootSpace_eq_span_singleton (α : Weight K H L) :
     change (K ∙ (2 • (α α')⁻¹ • α')) = _
     simpa [← Nat.cast_smul_eq_nsmul K, smul_smul] using Submodule.span_singleton_smul_eq this _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma eq_coroot_of_mem_corootSpace_of_two (α : Weight K H L) {x : H}
     (h_mem : x ∈ corootSpace α) (h_two : α x = 2) :
     x = coroot α := by
@@ -554,7 +552,6 @@ lemma traceForm_eq_zero_of_mem_ker_of_mem_span_coroot {α : Weight K H L} {x y :
         root_apply_coroot hβ]
     · simp [root_apply_coroot hα]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma exists_isSl2Triple_of_weight_isNonZero {α : Weight K H L} (hα : α.IsNonZero) :
     ∃ h e f : L, IsSl2Triple h e f ∧ e ∈ rootSpace H α ∧ f ∈ rootSpace H (-α) := by
   obtain ⟨e, heα : e ∈ rootSpace H α, he₀ : e ≠ 0⟩ := α.exists_ne_zero
@@ -583,7 +580,6 @@ lemma exists_isSl2Triple_of_weight_isNonZero {α : Weight K H L} (hα : α.IsNon
     rw [lie_smul, lie_smul, smul_lie, this]
     simp [← smul_assoc, f, hh, mul_comm _ (2 * (α h)⁻¹)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma _root_.IsSl2Triple.h_eq_coroot {α : Weight K H L} (hα : α.IsNonZero)
     {h e f : L} (ht : IsSl2Triple h e f) (heα : e ∈ rootSpace H α) (hfα : f ∈ rootSpace H (-α)) :
     h = coroot α := by
@@ -697,7 +693,6 @@ lemma coe_coroot_mem_corootSubmodule (α : Weight K H L) :
   (LieSubmodule.mem_map _).mpr
     ⟨⟨coroot α, (coroot α).property⟩, coroot_mem_corootSpace α, rfl⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 open Submodule in
 lemma sl2SubmoduleOfRoot_eq_sup (α : Weight K H L) (hα : α.IsNonZero) :
diff --git a/mathlib4/Mathlib/Algebra/Lie/Weights/Linear.lean b/mathlib4/Mathlib/Algebra/Lie/Weights/Linear.lean
index 7566648c8..312681d6a 100644
--- a/mathlib4/Mathlib/Algebra/Lie/Weights/Linear.lean
+++ b/mathlib4/Mathlib/Algebra/Lie/Weights/Linear.lean
@@ -96,7 +96,6 @@ end Weight
 
 attribute [local instance 100] LieRing.ofAssociativeRing
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- For an Abelian Lie algebra, the weights of any Lie module are linear. -/
 instance instLinearWeightsOfIsLieAbelian [IsLieAbelian L] [IsDomain R] [Module.IsTorsionFree R M] :
     LinearWeights R L M :=
@@ -136,7 +135,6 @@ lemma zero_lt_finrank_genWeightSpace {χ : L → R} (hχ : genWeightSpace M χ 
   rwa [← LieSubmodule.nontrivial_iff_ne_bot, ← rank_pos_iff_nontrivial (R := R), ← finrank_eq_rank,
     Nat.cast_pos] at hχ
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- In characteristic zero, the weights of any finite-dimensional Lie module are linear and vanish
 on the derived ideal. -/
 instance instLinearWeightsOfCharZero [CharZero R] :
diff --git a/mathlib4/Mathlib/Algebra/Module/Congruence/Defs.lean b/mathlib4/Mathlib/Algebra/Module/Congruence/Defs.lean
index e42b572f8..5c8216b2c 100644
--- a/mathlib4/Mathlib/Algebra/Module/Congruence/Defs.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Congruence/Defs.lean
@@ -150,7 +150,6 @@ def ModuleCon.ker [Monoid R] [Monoid S] [AddMonoid M] [AddMonoid N] [DistribMulA
   __ := SMulCon.ker f.toMulActionHom
   __ := AddCon.ker f
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The first isomorphism theorem for semimodules in the case of a surjective homomorphism. -/
 noncomputable def ModuleCon.quotientKerEquivOfSurjective [Semiring S] [AddCommMonoid M]
     [AddCommMonoid N] [Module S M] [Module S N] (f : M →ₗ[S] N) (hf : Function.Surjective f) :
diff --git a/mathlib4/Mathlib/Algebra/Module/Equiv/Basic.lean b/mathlib4/Mathlib/Algebra/Module/Equiv/Basic.lean
index 4da0cab8b..a805a427a 100644
--- a/mathlib4/Mathlib/Algebra/Module/Equiv/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Equiv/Basic.lean
@@ -347,7 +347,6 @@ theorem piApply_apply_apply {V : M → Type*}
 variable (R S M)
 variable [Semiring R] [Semiring S] [AddCommMonoid M] [Module R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The equivalence between R-linear maps from `R` to `M`, and points of `M` itself.
 This says that the forgetful functor from `R`-modules to types is representable, by `R`.
 
diff --git a/mathlib4/Mathlib/Algebra/Module/FinitePresentation.lean b/mathlib4/Mathlib/Algebra/Module/FinitePresentation.lean
index 61cde903f..f706ac8c5 100644
--- a/mathlib4/Mathlib/Algebra/Module/FinitePresentation.lean
+++ b/mathlib4/Mathlib/Algebra/Module/FinitePresentation.lean
@@ -517,7 +517,6 @@ lemma Module.FinitePresentation.exists_notMem_bijective [Module.Finite R M]
   obtain ⟨g, hg, h⟩ := exists_bijective_map_powers p.primeCompl fM fN f hf
   exact ⟨g, hg, h g dvd_rfl⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open IsLocalizedModule in
 /--
 Let `M` `N` be a finitely presented `R`-modules.
diff --git a/mathlib4/Mathlib/Algebra/Module/Injective.lean b/mathlib4/Mathlib/Algebra/Module/Injective.lean
index 98e03f538..79a3d21da 100644
--- a/mathlib4/Mathlib/Algebra/Module/Injective.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Injective.lean
@@ -181,7 +181,6 @@ theorem ExtensionOf.le_max {c : Set (ExtensionOf i f)} (hchain : IsChain (· ≤
 
 variable (i f) [Fact <| Function.Injective i]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance ExtensionOf.inhabited : Inhabited (ExtensionOf i f) where
   default :=
     { domain := LinearMap.range i
@@ -332,7 +331,6 @@ theorem ExtensionOfMaxAdjoin.extensionToFun_wd (h : Module.Baer R Q) {y : N}
   rw [Subtype.coe_mk, add_sub, ← eq1]
   exact eq_sub_of_add_eq (ExtensionOfMaxAdjoin.eqn i x).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The linear map `M ⊔ ⟨y⟩ ⟶ Q` by `x + r • y ↦ f x + φ r` is an extension of `f` -/
 def extensionOfMaxAdjoin (h : Module.Baer R Q) (y : N) : ExtensionOf i f where
   domain := supExtensionOfMaxSingleton i f y -- (extensionOfMax i f).domain ⊔ Submodule.span R {y}
@@ -476,7 +474,6 @@ instance Module.Injective.pi
     exact DFunLike.congr_fun (hl i) x⟩
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 universe u' in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 theorem Module.Injective.of_ringEquiv {R : Type u} [Ring R] [Small.{v} R] {S : Type u'} [Ring S]
diff --git a/mathlib4/Mathlib/Algebra/Module/LinearMap/Defs.lean b/mathlib4/Mathlib/Algebra/Module/LinearMap/Defs.lean
index c37756dae..a56f661b2 100644
--- a/mathlib4/Mathlib/Algebra/Module/LinearMap/Defs.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LinearMap/Defs.lean
@@ -124,7 +124,6 @@ abbrev LinearMapClass (F : Type*) (R : outParam Type*) (M M₂ : Type*)
     [FunLike F M M₂] :=
   SemilinearMapClass F (RingHom.id R) M M₂
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected lemma LinearMapClass.map_smul {R M M₂ : outParam Type*} [Semiring R] [AddCommMonoid M]
     [AddCommMonoid M₂] [Module R M] [Module R M₂]
     {F : Type*} [FunLike F M M₂] [LinearMapClass F R M M₂] (f : F) (r : R) (x : M) :
@@ -334,7 +333,6 @@ protected theorem map_zero : f 0 = 0 :=
 protected theorem map_smulₛₗ (c : R) (x : M) : f (c • x) = σ c • f x :=
   map_smulₛₗ f c x
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem map_smul (c : R) (x : M) : fₗ (c • x) = c • fₗ x :=
   map_smul fₗ c x
 
@@ -363,13 +361,11 @@ section
 
 variable {R S : Type*} [Semiring S] [SMul R M] [Module S M] [SMul R M₂] [Module S M₂]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) IsScalarTower.compatibleSMul [SMul R S]
     [IsScalarTower R S M] [IsScalarTower R S M₂] :
     CompatibleSMul M M₂ R S :=
   ⟨fun fₗ c x ↦ by rw [← smul_one_smul S c x, ← smul_one_smul S c (fₗ x), map_smul]⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance IsScalarTower.compatibleSMul' [SMul R S] [IsScalarTower R S M] :
     CompatibleSMul S M R S where
   map_smul := (IsScalarTower.smulHomClass R S M (S →ₗ[S] M)).map_smulₛₗ
@@ -384,7 +380,6 @@ theorem _root_.LinearMapClass.map_smul_of_tower {F : Type*} [CompatibleSMul M M
     fₗ (c • x) = c • fₗ x :=
   LinearMap.CompatibleSMul.map_smul (fₗ : M →ₗ[S] M₂) c x
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R R) in
 theorem isScalarTower_of_injective [SMul R S] [CompatibleSMul M M₂ R S] [IsScalarTower R S M₂]
     (f : M →ₗ[S] M₂) (hf : Function.Injective f) : IsScalarTower R S M where
diff --git a/mathlib4/Mathlib/Algebra/Module/LinearMap/End.lean b/mathlib4/Mathlib/Algebra/Module/LinearMap/End.lean
index 587c0e24b..c60fb89dc 100644
--- a/mathlib4/Mathlib/Algebra/Module/LinearMap/End.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LinearMap/End.lean
@@ -311,7 +311,6 @@ section SMulRight
 variable [Semiring R] [AddCommMonoid M] [AddCommMonoid M₁] [Module R M] [Module R M₁]
 variable [Semiring S] [Module R S] [Module S M] [IsScalarTower R S M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- When `f` is an `R`-linear map taking values in `S`, then `fun b ↦ f b • x` is an `R`-linear
 map. -/
 def smulRight (f : M₁ →ₗ[R] S) (x : M) : M₁ →ₗ[R] M where
@@ -380,7 +379,6 @@ variable [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [AddCommMonoid
 variable [Module R M] [Module R M₂] [Module R M₃]
 variable (f : M →ₗ[R] M₂)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Applying a linear map at `v : M`, seen as a linear map from `M →ₗ[R] M₂` to `M₂`.
 See also `LinearMap.applyₗ'` for a version that works with two different semirings.
 
diff --git a/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Basic.lean b/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Basic.lean
index f57adb880..696e97105 100644
--- a/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Basic.lean
@@ -563,7 +563,6 @@ lemma IsLocalizedModule.injective_iff_isRegular [IsLocalizedModule S f] :
     Function.Injective f ↔ ∀ c : S, IsSMulRegular M c := by
   simp_rw [IsSMulRegular, Function.Injective, eq_iff_exists S, exists_imp, forall_comm (α := S)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance IsLocalizedModule.of_linearEquiv (e : M' ≃ₗ[R] M'') [hf : IsLocalizedModule S f] :
     IsLocalizedModule S (e ∘ₗ f : M →ₗ[R] M'') where
@@ -581,7 +580,6 @@ instance IsLocalizedModule.of_linearEquiv (e : M' ≃ₗ[R] M'') [hf : IsLocaliz
       EmbeddingLike.apply_eq_iff_eq] at h
     exact hf.exists_of_eq h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance IsLocalizedModule.of_linearEquiv_right (e : M'' ≃ₗ[R] M) [hf : IsLocalizedModule S f] :
     IsLocalizedModule S (f ∘ₗ e : M'' →ₗ[R] M') where
@@ -621,7 +619,6 @@ lemma isLocalizedModule_id (R') [CommSemiring R'] [Algebra R R'] [IsLocalization
 
 namespace LocalizedModule
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
 there is a linear map `LocalizedModule S M → M''`.
@@ -649,7 +646,6 @@ theorem lift'_mk (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Mo
     LocalizedModule.lift' S g h (LocalizedModule.mk m s) = (h s).unit⁻¹.val (g m) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem lift'_add (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
     (x y) :
     LocalizedModule.lift' S g h (x + y) =
@@ -669,7 +665,6 @@ theorem lift'_add (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (M
         rfl)
     x y
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem lift'_smul (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
     (r : R) (m) : r • LocalizedModule.lift' S g h m = LocalizedModule.lift' S g h (r • m) :=
   m.induction_on fun a b => by
@@ -812,7 +807,6 @@ namespace IsLocalizedModule
 
 variable [IsLocalizedModule S f]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `(M', f : M ⟶ M')` satisfies universal property of localized module, there is a canonical
 map `LocalizedModule S M ⟶ M'`.
 -/
@@ -831,7 +825,6 @@ theorem fromLocalizedModule'_mk (m : M) (s : S) :
       (IsLocalizedModule.map_units f s).unit⁻¹.val (f m) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem fromLocalizedModule'_add (x y : LocalizedModule S M) :
     fromLocalizedModule' S f (x + y) = fromLocalizedModule' S f x + fromLocalizedModule' S f y :=
   LocalizedModule.induction_on₂
@@ -846,7 +839,6 @@ theorem fromLocalizedModule'_add (x y : LocalizedModule S M) :
       · rw [Submonoid.coe_mul, LinearMap.map_smul_of_tower, mul_comm, mul_smul, Submonoid.smul_def])
     x y
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem fromLocalizedModule'_smul (r : R) (x : LocalizedModule S M) :
     r • fromLocalizedModule' S f x = fromLocalizedModule' S f (r • x) :=
   LocalizedModule.induction_on
@@ -869,7 +861,6 @@ theorem fromLocalizedModule_mk (m : M) (s : S) :
       (IsLocalizedModule.map_units f s).unit⁻¹.val (f m) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem fromLocalizedModule.inj : Function.Injective <| fromLocalizedModule S f := fun x y eq1 => by
   induction x with | _ a b
   induction y with | _ a' b'
@@ -1140,7 +1131,6 @@ theorem mk_eq_mk' (s : S) (m : M) :
   rw [eq_comm, mk'_eq_iff, Submonoid.smul_def, LocalizedModule.smul'_mk, ← Submonoid.smul_def,
     LocalizedModule.mk_cancel, LocalizedModule.mkLinearMap_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (A) in
 lemma mk'_smul_mk' (x : R) (m : M) (s t : S) :
@@ -1181,7 +1171,6 @@ lemma liftOfLE_comp : (liftOfLE S₁ S₂ h f₁ f₂).comp f₁ = f₂ := lift_
 
 @[simp] lemma liftOfLE_apply (x) : liftOfLE S₁ S₂ h f₁ f₂ (f₁ x) = f₂ x := lift_apply ..
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The image of `m/s` under `liftOfLE` is `m/s`. -/
 @[simp]
@@ -1208,7 +1197,6 @@ instance : IsLocalizedModule S₂ (liftOfLE S₁ S₂ h f₁ f₂) where
 
 end liftOfLE
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include S in
 lemma injective_of_map_eq {N : Type*} [AddCommMonoid N] [Module R N]
     {g : M' →ₗ[R] N} (H : ∀ {x y}, g (f x) = g (f y) → f x = f y) :
@@ -1338,7 +1326,6 @@ theorem map_comp' (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) :
 
 section Algebra
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem mkOfAlgebra {R S S' : Type*} [CommSemiring R] [Ring S] [Ring S'] [Algebra R S]
     [Algebra R S'] (M : Submonoid R) (f : S →ₐ[R] S') (h₁ : ∀ x ∈ M, IsUnit (algebraMap R S' x))
diff --git a/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Exact.lean b/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Exact.lean
index d2d1f5f4c..1c058bc1c 100644
--- a/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Exact.lean
+++ b/mathlib4/Mathlib/Algebra/Module/LocalizedModule/Exact.lean
@@ -32,7 +32,6 @@ variable (f₁ : M₁ →ₗ[R] M₁') [IsLocalizedModule S f₁]
 variable {M₂ M₂'} [AddCommMonoid M₂] [AddCommMonoid M₂'] [Module R M₂] [Module R M₂']
 variable (f₂ : M₂ →ₗ[R] M₂') [IsLocalizedModule S f₂]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Localization of modules is an exact functor, proven here for `LocalizedModule`.
 See `IsLocalizedModule.map_exact` for the more general version. -/
 lemma LocalizedModule.map_exact (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) (ex : Exact g h) :
diff --git a/mathlib4/Mathlib/Algebra/Module/PID.lean b/mathlib4/Mathlib/Algebra/Module/PID.lean
index c7518db61..9b4a981df 100644
--- a/mathlib4/Mathlib/Algebra/Module/PID.lean
+++ b/mathlib4/Mathlib/Algebra/Module/PID.lean
@@ -269,7 +269,6 @@ theorem equiv_free_prod_directSum [h' : Module.Finite R M] :
           (h.prodCongr g).trans <| LinearEquiv.prodComm.{u, u} R _ (Fin n →₀ R) ⟩⟩
   rw [range_subtype, ker_mkQ]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open LinearMap in
 theorem exists_ker_toSpanSingleton_eq_annihilator [Module.Finite R M] :
diff --git a/mathlib4/Mathlib/Algebra/Module/Presentation/RestrictScalars.lean b/mathlib4/Mathlib/Algebra/Module/Presentation/RestrictScalars.lean
index c6a8c438d..151e13dbf 100644
--- a/mathlib4/Mathlib/Algebra/Module/Presentation/RestrictScalars.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Presentation/RestrictScalars.lean
@@ -42,7 +42,6 @@ abbrev RestrictScalarsData : Type _ :=
 
 variable (data : presM.RestrictScalarsData presB)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A presentation of the restriction of scalars from `B` to `A` of a `B`-module `M`,
 given a presentation of `M` as a `B`-module, a presentation of `B` as an `A`-module,
 and an additional data. -/
diff --git a/mathlib4/Mathlib/Algebra/Module/SnakeLemma.lean b/mathlib4/Mathlib/Algebra/Module/SnakeLemma.lean
index 7bbe581d1..6c18efd98 100644
--- a/mathlib4/Mathlib/Algebra/Module/SnakeLemma.lean
+++ b/mathlib4/Mathlib/Algebra/Module/SnakeLemma.lean
@@ -82,7 +82,6 @@ lemma SnakeLemma.eq_of_eq (x : K₃)
   rw [← sub_eq_zero, ← map_sub, hz₁, hπ₁]
   exact ⟨_, rfl⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /--
 **Snake Lemma**
@@ -123,13 +122,11 @@ def SnakeLemma.δ : K₃ →ₗ[R] C₁ :=
       apply eq_of_eq i₁ i₂ f₁ f₂ hf g₁ h₁ ρ hρ ι₃ π₁ hπ₁ (r • x) _ (H₁ _) _ (H₂ _)
         (r • σ (ι₃ x)) (by simp only [map_smul, H₁]) _ (by simp only [map_smul, H₂]) }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma SnakeLemma.δ_eq (x : K₃) (y) (hy : f₂ y = ι₃ x) (z) (hz : g₁ z = i₂ y) :
     δ i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ σ hσ ρ hρ ι₃ hι₃ π₁ hπ₁ x = π₁ z :=
   eq_of_eq i₁ i₂ f₁ f₂ hf g₁ h₁ ρ hρ ι₃ π₁ hπ₁ x _ (congr_fun hσ _) _
     (δ_aux i₂ i₃ f₂ g₁ g₂ hg h₂ σ hσ ρ hρ ι₃ hι₃ _) y hy z hz
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hι₂ in
 /--
 Suppose we have an exact commutative diagram
@@ -169,7 +166,6 @@ lemma SnakeLemma.exact_δ_right (F : K₂ →ₗ[R] K₃) (hF : f₂.comp ι₂
     exact (δ_eq i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ σ hσ ρ hρ ι₃ hι₃ π₁ hπ₁ _ (ι₂ y) congr($hF y)
       _ (by rw [map_zero, hι₂.apply_apply_eq_zero])).trans π₁.map_zero
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hπ₂ in
 /--
 Suppose we have an exact commutative diagram
@@ -207,7 +203,6 @@ lemma SnakeLemma.exact_δ_left (G : C₁ →ₗ[R] C₂) (hF : G.comp π₁ = π
     simp only [δ, coe_mk, AddHom.coe_mk]
     rw [← G.comp_apply, hF, π₂.comp_apply, H₂, hπ₂.apply_apply_eq_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 Suppose we have an exact commutative diagram
 ```
@@ -234,13 +229,11 @@ Also see `SnakeLemma.δ` for a computable version.
 noncomputable def SnakeLemma.δ' (hf₂ : Surjective f₂) (hg₁ : Injective g₁) : K₃ →ₗ[R] C₁ :=
   δ i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ _ (funext (surjInv_eq hf₂)) _ (invFun_comp hg₁) ι₃ hι₃ π₁ hπ₁
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma SnakeLemma.δ'_eq (hf₂ : Surjective f₂) (hg₁ : Injective g₁)
     (x : K₃) (y) (hy : f₂ y = ι₃ x) (z) (hz : g₁ z = i₂ y) :
     δ' i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ ι₃ hι₃ π₁ hπ₁ hf₂ hg₁ x = π₁ z :=
   SnakeLemma.δ_eq _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ‹_› ‹_› _ ‹_›
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hι₂ in
 /--
 Suppose we have an exact commutative diagram
@@ -268,7 +261,6 @@ lemma SnakeLemma.exact_δ'_right (hf₂ : Surjective f₂) (hg₁ : Injective g
     Exact F (δ' i₁ i₂ i₃ f₁ f₂ hf g₁ g₂ hg h₁ h₂ ι₃ hι₃ π₁ hπ₁ hf₂ hg₁) :=
   SnakeLemma.exact_δ_right _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ‹_› _ _ _ _ _ ‹_› ‹_›
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hπ₂ in
 /--
 Suppose we have an exact commutative diagram
diff --git a/mathlib4/Mathlib/Algebra/Module/Submodule/Bilinear.lean b/mathlib4/Mathlib/Algebra/Module/Submodule/Bilinear.lean
index b51c565c1..658cfd25f 100644
--- a/mathlib4/Mathlib/Algebra/Module/Submodule/Bilinear.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Submodule/Bilinear.lean
@@ -57,7 +57,6 @@ theorem map₂_le {f : M →ₗ[R] N →ₗ[R] P} {p : Submodule R M} {q : Submo
   ⟨fun H _m hm _n hn => H <| apply_mem_map₂ _ hm hn, fun H =>
     iSup_le fun ⟨m, hm⟩ => map_le_iff_le_comap.2 fun n hn => H m hm n hn⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (R) in
 theorem map₂_span_span (f : M →ₗ[R] N →ₗ[R] P) (s : Set M) (t : Set N) :
diff --git a/mathlib4/Mathlib/Algebra/Module/Submodule/LinearMap.lean b/mathlib4/Mathlib/Algebra/Module/Submodule/LinearMap.lean
index 43bcb0528..af088ed60 100644
--- a/mathlib4/Mathlib/Algebra/Module/Submodule/LinearMap.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Submodule/LinearMap.lean
@@ -185,7 +185,6 @@ section
 variable {M₂' : Type*} [AddCommMonoid M₂'] [Module R₂ M₂']
   (p : M₂' →ₗ[R₂] M₂) (hp : Injective p) (h : ∀ c, f c ∈ range p)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A linear map `f : M → M₂` whose values lie in the image of an injective linear map
 `p : M₂' → M₂` admits a unique lift to a linear map `M → M₂'`. -/
@@ -195,7 +194,6 @@ noncomputable def codLift :
   map_add' b c := by apply hp; simp_rw [map_add, (h _).choose_spec, ← map_add, (h _).choose_spec]
   map_smul' r c := by apply hp; simp_rw [map_smul, (h _).choose_spec, map_smulₛₗ]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] theorem codLift_apply (x : M) :
     (f.codLift p hp h x) = (h x).choose :=
   rfl
diff --git a/mathlib4/Mathlib/Algebra/Module/Torsion/PrimaryComponent.lean b/mathlib4/Mathlib/Algebra/Module/Torsion/PrimaryComponent.lean
index 5fc63e747..b5e35a5f8 100644
--- a/mathlib4/Mathlib/Algebra/Module/Torsion/PrimaryComponent.lean
+++ b/mathlib4/Mathlib/Algebra/Module/Torsion/PrimaryComponent.lean
@@ -61,7 +61,6 @@ theorem primaryComponent_mem (x : M) :
       simp [torsionBySet_le_torsionBySet_pow]
   · aesop (add safe Submodule.mem_iSup_of_mem)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem primaryComponent_map_mem (φ : M₁ →ₗ[A] M₂) (c : primaryComponent M₁ I) :
     φ c ∈ primaryComponent M₂ I := by
   obtain ⟨c, hc⟩ := c
diff --git a/mathlib4/Mathlib/Algebra/Module/TransferInstance.lean b/mathlib4/Mathlib/Algebra/Module/TransferInstance.lean
index de31c2add..39c5d5b39 100644
--- a/mathlib4/Mathlib/Algebra/Module/TransferInstance.lean
+++ b/mathlib4/Mathlib/Algebra/Module/TransferInstance.lean
@@ -73,7 +73,6 @@ lemma linearEquiv_symm_apply (b : β) [AddCommMonoid β] [Module R β] :
     letI := Equiv.module R e
     (e.linearEquiv R).symm b = e.symm b := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (R) in
 /-- Transfer `Module.IsTorsionFree` across an `Equiv` -/
diff --git a/mathlib4/Mathlib/Algebra/Module/ZLattice/Covolume.lean b/mathlib4/Mathlib/Algebra/Module/ZLattice/Covolume.lean
index 4384ef603..dcdd7b8ea 100644
--- a/mathlib4/Mathlib/Algebra/Module/ZLattice/Covolume.lean
+++ b/mathlib4/Mathlib/Algebra/Module/ZLattice/Covolume.lean
@@ -222,7 +222,6 @@ variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
 variable {L : Submodule ℤ E} [DiscreteTopology L] [IsZLattice ℝ L]
 variable {ι : Type*} [Fintype ι] (b : Basis ι ℤ L)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- A version of `ZLattice.covolume.tendsto_card_div_pow` for the general case;
 see the `Naming convention` section in the introduction. -/
@@ -254,7 +253,6 @@ private theorem tendsto_card_le_div''_aux
     (inv_pos_of_pos hc).le, inv_pow, inv_mul_le_iff₀ (pow_pos hc _), mul_one, and_congr_left_iff]
   exact fun _ ↦ ⟨fun h ↦ (smul_inv_smul₀ hc.ne' x) ▸ hX h hc, fun h ↦ hX h (inv_pos_of_pos hc)⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A version of `ZLattice.covolume.tendsto_card_le_div` for the general case;
 see the `Naming conventions` section in the introduction. -/
 theorem tendsto_card_le_div'' [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
diff --git a/mathlib4/Mathlib/Algebra/Order/Hom/Monoid.lean b/mathlib4/Mathlib/Algebra/Order/Hom/Monoid.lean
index 2e43af442..e3b6c7f86 100644
--- a/mathlib4/Mathlib/Algebra/Order/Hom/Monoid.lean
+++ b/mathlib4/Mathlib/Algebra/Order/Hom/Monoid.lean
@@ -234,17 +234,14 @@ variable [iamhc : AddMonoidHomClass F α β]
 
 -- Defeq abuse: `iamhc` is not an instance about `βᵒᵈ`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem antitone_iff_map_nonpos : Antitone (f : α → β) ↔ ∀ a, 0 ≤ a → f a ≤ 0 :=
   monotone_toDual_comp_iff.symm.trans <| monotone_iff_map_nonneg (β := βᵒᵈ) (iamhc := iamhc) _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem monotone_iff_map_nonpos : Monotone (f : α → β) ↔ ∀ a ≤ 0, f a ≤ 0 :=
   antitone_comp_ofDual_iff.symm.trans <| antitone_iff_map_nonpos (α := αᵒᵈ) (iamhc := iamhc) _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem antitone_iff_map_nonneg : Antitone (f : α → β) ↔ ∀ a ≤ 0, 0 ≤ f a :=
   monotone_comp_ofDual_iff.symm.trans <| monotone_iff_map_nonneg (α := αᵒᵈ) (iamhc := iamhc) _
 
@@ -257,17 +254,14 @@ theorem strictMono_iff_map_pos :
     exact lt_add_of_pos_left _ (h _ <| sub_pos.2 hl)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem strictAnti_iff_map_neg : StrictAnti (f : α → β) ↔ ∀ a, 0 < a → f a < 0 :=
   strictMono_toDual_comp_iff.symm.trans <| strictMono_iff_map_pos (β := βᵒᵈ) (iamhc := iamhc) _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem strictMono_iff_map_neg : StrictMono (f : α → β) ↔ ∀ a < 0, f a < 0 :=
   strictAnti_comp_ofDual_iff.symm.trans <| strictAnti_iff_map_neg (α := αᵒᵈ) (iamhc := iamhc) _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem strictAnti_iff_map_pos : StrictAnti (f : α → β) ↔ ∀ a < 0, 0 < f a :=
   strictMono_comp_ofDual_iff.symm.trans <| strictMono_iff_map_pos (α := αᵒᵈ) (iamhc := iamhc) _
 
diff --git a/mathlib4/Mathlib/Algebra/Order/Module/HahnEmbedding.lean b/mathlib4/Mathlib/Algebra/Order/Module/HahnEmbedding.lean
index b56451a46..0f551ec4d 100644
--- a/mathlib4/Mathlib/Algebra/Order/Module/HahnEmbedding.lean
+++ b/mathlib4/Mathlib/Algebra/Order/Module/HahnEmbedding.lean
@@ -819,7 +819,6 @@ theorem truncLT_eval_mem_range_extendFun [IsOrderedAddMonoid R] [Archimedean R]
     obtain ⟨y, hy⟩ := h
     exact ⟨y, Set.mem_of_mem_of_subset hy (by simpa using (ball_strictAnti K).antitone hdc)⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem truncLT_mem_range_extendFun [IsOrderedAddMonoid R] [Archimedean R] {x : M}
     (hx : x ∉ f.val.domain) (y : (f.extendFun hx).domain) (c : FiniteArchimedeanClass M) :
     toLex (HahnSeries.truncLTLinearMap K c (ofLex (f.extendFun hx y))) ∈
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Bivariate.lean b/mathlib4/Mathlib/Algebra/Polynomial/Bivariate.lean
index 665fe594e..33d87021a 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Bivariate.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Bivariate.lean
@@ -342,7 +342,6 @@ lemma equivMvPolynomial_symm_X_1 : (equivMvPolynomial R).symm (.X 1) = X := by
 lemma equivMvPolynomial_symm_C (a : R) : (equivMvPolynomial R).symm (.C a) = C (C a) := by
   simp [equivMvPolynomial]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma pderiv_zero_equivMvPolynomial {R : Type*} [CommRing R] (p : R[X][Y]) :
     (equivMvPolynomial R p).pderiv 0 = equivMvPolynomial R
       (PolynomialModule.equivPolynomialSelf (derivative'.mapCoeffs p)) := by
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Coeff.lean b/mathlib4/Mathlib/Algebra/Polynomial/Coeff.lean
index 6f5aa67b1..83b0733ca 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Coeff.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Coeff.lean
@@ -64,7 +64,6 @@ theorem card_support_mul_le : #(p * q).support ≤ #p.support * #q.support := by
       grw [AddMonoidAlgebra.support_coeff_mul_subset]
     _ ≤ #p.support * #q.support := Finset.card_image₂_le ..
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `Polynomial.sum` as a linear map. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Derivation.lean b/mathlib4/Mathlib/Algebra/Polynomial/Derivation.lean
index 190eb6682..41dbee4c2 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Derivation.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Derivation.lean
@@ -110,7 +110,6 @@ open Polynomial Module
 
 set_option backward.isDefEq.respectTransparency false in
 set_option linter.style.whitespace false in -- manual alignment is not recognised
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 For a derivation `d : A → M` and an element `a : A`, `d.compAEval a` is the
 derivation of `R[X]` which takes a polynomial `f` to `d(aeval a f)`.
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Expand.lean b/mathlib4/Mathlib/Algebra/Polynomial/Expand.lean
index f6161eef2..75ea931ca 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Expand.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Expand.lean
@@ -59,7 +59,6 @@ theorem expand_C (r : R) : expand R p (C r) = C r :=
 theorem expand_X : expand R p X = X ^ p :=
   eval₂_X _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem expand_monomial (r : R) : expand R p (monomial q r) = monomial (q * p) r := by
diff --git a/mathlib4/Mathlib/Algebra/Polynomial/Module/AEval.lean b/mathlib4/Mathlib/Algebra/Polynomial/Module/AEval.lean
index 6124c1804..e92faff4d 100644
--- a/mathlib4/Mathlib/Algebra/Polynomial/Module/AEval.lean
+++ b/mathlib4/Mathlib/Algebra/Polynomial/Module/AEval.lean
@@ -70,7 +70,6 @@ lemma of_aeval_smul (f : R[X]) (m : M) : of R M a (aeval a f • m) = f • of R
 @[simp] lemma of_symm_smul (f : R[X]) (m : AEval R M a) :
     (of R M a).symm (f • m) = aeval a f • (of R M a).symm m := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma C_smul (t : R) (m : AEval R M a) : C t • m = t • m :=
   (of R M a).symm.injective <| by simp
@@ -85,7 +84,6 @@ lemma of_symm_X_smul (m : AEval R M a) :
     (of R M a).symm ((X : R[X]) • m) = a • (of R M a).symm m := by
   rw [of_symm_smul, aeval_X]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance instIsScalarTowerOrigPolynomial : IsScalarTower R R[X] <| AEval R M a where
   smul_assoc r f m := by
     apply (of R M a).symm.injective
diff --git a/mathlib4/Mathlib/Algebra/QuadraticAlgebra/Basic.lean b/mathlib4/Mathlib/Algebra/QuadraticAlgebra/Basic.lean
index c3d25768d..9eed3c5bf 100644
--- a/mathlib4/Mathlib/Algebra/QuadraticAlgebra/Basic.lean
+++ b/mathlib4/Mathlib/Algebra/QuadraticAlgebra/Basic.lean
@@ -90,7 +90,6 @@ theorem mk_eq_add_smul_omega (x y : R) :
 
 variable {A : Type*} [Ring A] [Algebra R A]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[ext]
 theorem algHom_ext {f g : QuadraticAlgebra R a b →ₐ[R] A}
@@ -98,7 +97,6 @@ theorem algHom_ext {f g : QuadraticAlgebra R a b →ₐ[R] A}
   ext ⟨x, y⟩
   simp [mk_eq_add_smul_omega, h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The unique `AlgHom` from `QuadraticAlgebra R a b` to an `R`-algebra `A`,
 constructed by replacing `ω` with the provided root.
diff --git a/mathlib4/Mathlib/Algebra/QuaternionBasis.lean b/mathlib4/Mathlib/Algebra/QuaternionBasis.lean
index 9499ffe35..925163a09 100644
--- a/mathlib4/Mathlib/Algebra/QuaternionBasis.lean
+++ b/mathlib4/Mathlib/Algebra/QuaternionBasis.lean
@@ -161,7 +161,6 @@ theorem range_liftHom (B : Basis A c₁ c₂ c₃) :
       <;> [use (Basis.self R).i; use (Basis.self R).j; use (Basis.self R).k]
     all_goals simp [lift]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Transform a `QuaternionAlgebra.Basis` through an `AlgHom`. -/
 @[simps i j k]
 def compHom (F : A →ₐ[R] B) : Basis B c₁ c₂ c₃ where
@@ -175,7 +174,6 @@ def compHom (F : A →ₐ[R] B) : Basis B c₁ c₂ c₃ where
 
 end Basis
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 /-- A quaternionic basis on `A` is equivalent to a map from the quaternion algebra to `A`. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Algebra/RingQuot.lean b/mathlib4/Mathlib/Algebra/RingQuot.lean
index 28140f5f6..e3e4ef0ee 100644
--- a/mathlib4/Mathlib/Algebra/RingQuot.lean
+++ b/mathlib4/Mathlib/Algebra/RingQuot.lean
@@ -491,7 +491,6 @@ theorem ringQuot_ext' {s : A → A → Prop} (f g : RingQuot s →ₐ[S] B)
 set_option backward.isDefEq.respectTransparency false in
 irreducible_def preLiftAlgHom {s : A → A → Prop} {f : A →ₐ[S] B}
   (h : ∀ ⦃x y⦄, s x y → f x = f y) : RingQuot s →ₐ[S] B :=
-set_option backward.isDefEq.respectTransparency.outParams false in
 { toFun := fun x ↦ Quot.lift f
             (by
               rintro _ _ r
@@ -513,7 +512,6 @@ set_option backward.isDefEq.respectTransparency.outParams false in
     rintro x
     simp [← one_quot, smul_quot, Algebra.algebraMap_eq_smul_one] }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Any `S`-algebra homomorphism `f : A →ₐ[S] B` which respects a relation `s : A → A → Prop`
 factors uniquely through a morphism `RingQuot s →ₐ[S] B`.
 -/
@@ -540,13 +538,11 @@ theorem liftAlgHom_mkAlgHom_apply (f : A →ₐ[S] B) {s : A → A → Prop}
   rfl
 
 -- note this is essentially `(liftAlgHom S).symm_apply_eq.mp h`
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem liftAlgHom_unique (f : A →ₐ[S] B) {s : A → A → Prop} (w : ∀ ⦃x y⦄, s x y → f x = f y)
     (g : RingQuot s →ₐ[S] B) (h : g.comp (mkAlgHom S s) = f) : g = liftAlgHom S ⟨f, w⟩ := by
   ext
   simp [h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem eq_liftAlgHom_comp_mkAlgHom {s : A → A → Prop} (f : RingQuot s →ₐ[S] B) :
     f = liftAlgHom S ⟨f.comp (mkAlgHom S s), fun _ _ h ↦ congr_arg f (mkAlgHom_rel S h)⟩ :=
   liftAlgHom_unique S (f.comp (mkAlgHom S s)) (fun _ _ h ↦ congr_arg (⇑f) (mkAlgHom_rel S h)) f rfl
@@ -555,7 +551,6 @@ open scoped Function -- required for scoped `on` notation
 
 variable {S}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If two `S`-algebras are `S`-equivalent and their quotients by a relation `rel` are defined,
 then their quotients are also `S`-equivalent.
 
diff --git a/mathlib4/Mathlib/Algebra/Star/NonUnitalSubalgebra.lean b/mathlib4/Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
index 71441edb2..4f9e0b65f 100644
--- a/mathlib4/Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
+++ b/mathlib4/Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@@ -1049,7 +1049,6 @@ instance instIsMulCommutative_iSup [Nonempty ι] [Preorder ι] [IsDirectedOrder
     IsMulCommutative (⨆ i, S i : NonUnitalStarSubalgebra R A) :=
   isMulCommutative_iSup S.monotone.directed_le
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Define a non-unital star algebra homomorphism on a directed supremum of non-unital star
 subalgebras by defining it on each non-unital star subalgebra, and proving that it agrees on the
diff --git a/mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean b/mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean
index 371c1a638..1ab72e19f 100644
--- a/mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean
+++ b/mathlib4/Mathlib/Algebra/Star/StarAlgHom.lean
@@ -128,7 +128,6 @@ theorem coe_toNonUnitalAlgHom {f : A →⋆ₙₐ[R] B} : (f.toNonUnitalAlgHom :
 theorem ext {f g : A →⋆ₙₐ[R] B} (h : ∀ x, f x = g x) : f = g :=
   DFunLike.ext _ _ h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Copy of a `NonUnitalStarAlgHom` with a new `toFun` equal to the old one. Useful
 to fix definitional equalities. -/
 protected def copy (f : A →⋆ₙₐ[R] B) (f' : A → B) (h : f' = f) : A →⋆ₙₐ[R] B where
@@ -452,7 +451,6 @@ instance : Monoid (A →⋆ₐ[R] A) where
   one_mul := id_comp
   mul_one := comp_id
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A unital morphism of ⋆-algebras is a `NonUnitalStarAlgHom`. -/
 def toNonUnitalStarAlgHom (f : A →⋆ₐ[R] B) : A →⋆ₙₐ[R] B :=
   { f with map_smul' := map_smul f }
@@ -652,7 +650,6 @@ class NonUnitalAlgEquivClass (F : Type*) (R A B : outParam Type*)
   extends RingEquivClass F A B, MulActionSemiHomClass F (@id R) A B where
 
 -- See note [lower instance priority]
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) {F R A B : Type*} [Monoid R] [NonUnitalNonAssocSemiring A]
     [DistribMulAction R A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [EquivLike F A B]
     [NonUnitalAlgEquivClass F R A B] :
@@ -661,7 +658,6 @@ instance (priority := 100) {F R A B : Type*} [Monoid R] [NonUnitalNonAssocSemiri
 
 set_option backward.isDefEq.respectTransparency false in
 -- See note [lower instance priority]
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) (F R A B : Type*) [CommSemiring R] [Semiring A]
     [Algebra R A] [Semiring B] [Algebra R B] [EquivLike F A B] [NonUnitalAlgEquivClass F R A B] :
     AlgEquivClass F R A B :=
@@ -1042,7 +1038,6 @@ theorem symm_arrowCongr (e₁ : A₁ ≃⋆ₐ[R] A₁') (e₂ : A₂ ≃⋆ₐ[
     (arrowCongr e₁ e₂).symm = arrowCongr e₁.symm e₂.symm :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Construct a star algebra equivalence from a pair of star algebra homomorphisms. -/
 @[simps]
 def ofStarAlgHom {R A B : Type*} [CommSemiring R]
@@ -1083,7 +1078,6 @@ variable [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [Star B]
 variable [FunLike F A B] [NonUnitalAlgHomClass F R A B] [StarHomClass F A B]
 variable [FunLike G B A] [NonUnitalAlgHomClass G R B A] [StarHomClass G B A]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Promote a bijective star algebra homomorphism to a star algebra equivalence. -/
 noncomputable def ofBijective (f : F) (hf : Function.Bijective f) : A ≃⋆ₐ[R] B :=
   {
diff --git a/mathlib4/Mathlib/Algebra/Star/Subalgebra.lean b/mathlib4/Mathlib/Algebra/Star/Subalgebra.lean
index e6a726eeb..c9039e2bb 100644
--- a/mathlib4/Mathlib/Algebra/Star/Subalgebra.lean
+++ b/mathlib4/Mathlib/Algebra/Star/Subalgebra.lean
@@ -857,7 +857,6 @@ theorem injective_codRestrict (f : A →⋆ₐ[R] B) (S : StarSubalgebra R B) (h
 def rangeRestrict (f : A →⋆ₐ[R] B) : A →⋆ₐ[R] f.range :=
   StarAlgHom.codRestrict f _ fun x => ⟨x, rfl⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The `StarAlgEquiv` onto the range corresponding to an injective `StarAlgHom`. -/
 @[simps]
 noncomputable def _root_.StarAlgEquiv.ofInjective (f : A →⋆ₐ[R] B)
diff --git a/mathlib4/Mathlib/Algebra/Star/TensorProduct.lean b/mathlib4/Mathlib/Algebra/Star/TensorProduct.lean
index 85e04d469..73b725302 100644
--- a/mathlib4/Mathlib/Algebra/Star/TensorProduct.lean
+++ b/mathlib4/Mathlib/Algebra/Star/TensorProduct.lean
@@ -43,7 +43,6 @@ noncomputable instance : StarAddMonoid (A ⊗[R] B) where
 -- Would require `DFunLike.coe (starRingEnd R) = star` at `instances` transparency, which sounds
 -- reasonable but does not hold at the moment.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : StarModule R (A ⊗[R] B) where
   star_smul := map_smulₛₗ _
 
diff --git a/mathlib4/Mathlib/Algebra/Vertex/HVertexOperator.lean b/mathlib4/Mathlib/Algebra/Vertex/HVertexOperator.lean
index 2df773e79..457307099 100644
--- a/mathlib4/Mathlib/Algebra/Vertex/HVertexOperator.lean
+++ b/mathlib4/Mathlib/Algebra/Vertex/HVertexOperator.lean
@@ -129,7 +129,6 @@ theorem compHahnSeries_add (u v : U) :
   simp only [compHahnSeries_coeff, map_add, coeff_apply_apply, HahnSeries.coeff_add', Pi.add_apply]
   rw [← HahnSeries.coeff_add]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem compHahnSeries_smul (r : R) (u : U) :
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/AffineScheme.lean b/mathlib4/Mathlib/AlgebraicGeometry/AffineScheme.lean
index a97e22b24..1204020a0 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/AffineScheme.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/AffineScheme.lean
@@ -628,7 +628,6 @@ theorem ι_basicOpen_preimage (r : Γ(X, ⊤)) :
   exact hU.basicOpen _
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hU in
 theorem exists_basicOpen_le {V : X.Opens} (x : V) (h : ↑x ∈ U) :
     ∃ f : Γ(X, U), X.basicOpen f ≤ V ∧ ↑x ∈ X.basicOpen f := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean b/mathlib4/Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
index 7a2c0050a..9c81bfdff 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
@@ -979,7 +979,6 @@ end sections
 section IsAffine
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hc in
 /-- Suppose `{ Xᵢ }` is an inverse system of qcqs schemes with affine transition maps.
 If `lim Xᵢ` is quasi-affine, then some `Xᵢ` is quasi-affine. -/
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Artinian.lean b/mathlib4/Mathlib/AlgebraicGeometry/Artinian.lean
index 91de55b17..f465a94b5 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Artinian.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Artinian.lean
@@ -143,7 +143,6 @@ theorem isLocallyArtinian_iff_of_isOpenCover {ι : Type*} {U : ι → X.Opens}
 instance (priority := low) {X : Scheme} [IsEmpty X] : IsLocallyArtinian X where
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := low) {X : Scheme} [DiscreteTopology X] [IsReduced X] :
     IsLocallyArtinian X := by
   wlog hX : Subsingleton X generalizing X
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Cover/Open.lean b/mathlib4/Mathlib/AlgebraicGeometry/Cover/Open.lean
index 8812e5201..3e6ccb4fd 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Cover/Open.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Cover/Open.lean
@@ -201,7 +201,6 @@ lemma OpenCover.pullbackCoverAffineRefinementObjIso_inv_pullbackHom
   exact pullbackRightPullbackFstIso_hom_fst _ _ _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A family of elements spanning the unit ideal of `R` gives an affine open cover of `Spec R`. -/
 @[simps]
 noncomputable
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Cover/Over.lean b/mathlib4/Mathlib/AlgebraicGeometry/Cover/Over.lean
index 84e753b43..12498f903 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Cover/Over.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Cover/Over.lean
@@ -90,7 +90,6 @@ instance (j : 𝒰.I₀) : ((𝒰.pullbackCoverOver S f).X j).Over S where
   hom := (pullback (f.asOver S) ((𝒰.f j).asOver S)).hom
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (𝒰.pullbackCoverOver S f).Over S where
   isOver_map j := { comp_over := by exact Over.w (pullback.fst (f.asOver S) ((𝒰.f j).asOver S)) }
 
@@ -118,7 +117,6 @@ instance (j : 𝒰.I₀) : ((𝒰.pullbackCoverOver' S f).X j).Over S where
   hom := (pullback ((𝒰.f j).asOver S) (f.asOver S)).hom
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (𝒰.pullbackCoverOver' S f).Over S where
   isOver_map j := { comp_over := by exact Over.w (pullback.snd ((𝒰.f j).asOver S) (f.asOver S)) }
 
@@ -158,7 +156,6 @@ instance (j : 𝒰.I₀) : ((𝒰.pullbackCoverOverProp S f hX hW hQ).X j).Over
     ((𝒰.f j).asOverProp (hX := hQ j) (hY := hX) S)).hom
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (𝒰.pullbackCoverOverProp S f hX hW hQ).Over S where
   isOver_map j :=
     { comp_over := by exact (pullback.fst (f.asOverProp S) ((𝒰.f j).asOverProp S)).w }
@@ -192,7 +189,6 @@ instance (j : 𝒰.I₀) : ((𝒰.pullbackCoverOverProp' S f hX hW hQ).X j).Over
     (f.asOverProp (hX := hW) (hY := hX) S)).hom
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (𝒰.pullbackCoverOverProp' S f hX hW hQ).Over S where
   isOver_map j :=
     { comp_over := by exact (pullback.snd ((𝒰.f j).asOverProp S) (f.asOverProp S)).w }
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/EffectiveEpi.lean b/mathlib4/Mathlib/AlgebraicGeometry/EffectiveEpi.lean
index a1a36cf33..f00263dc5 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/EffectiveEpi.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/EffectiveEpi.lean
@@ -54,7 +54,6 @@ instance effectiveEpi_base_of_flat {X Y : Scheme.{u}} {f : X ⟶ Y} [Flat f] [Su
 namespace EffectiveEpiConstruction
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `π : X ⟶ Y` is a surjective and flat morphism between affine schemes, then any morphism
 `f : X ⟶ S` to an affine scheme `S` whose two pullbacks to `X ×[Y] X` agree descends to a morphism
 `u : Y ⟶ S` with `π ≫ u = f`. -/
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean b/mathlib4/Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean
index e5e0211ce..31a412369 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean
@@ -406,7 +406,6 @@ lemma mk_XYIdeal'_mul_mk_XYIdeal' [DecidableEq F] {x₁ x₂ y₁ y₂ : F} (h
 
 /-! ## Norms on the affine coordinate ring -/
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma norm_smul_basis (p q : R[X]) : Algebra.norm R[X] (p • (1 : W'.CoordinateRing) + q • mk W' Y) =
     p ^ 2 - p * q * (C W'.a₁ * X + C W'.a₃) -
       q ^ 2 * (X ^ 3 + C W'.a₂ * X ^ 2 + C W'.a₄ * X + C W'.a₆) := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean b/mathlib4/Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
index e129a1375..aa0d42e7e 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
@@ -213,7 +213,6 @@ theorem toStalk_stalkMap_toΓSpec (x : X) :
   exact (X.toΓSpecBase _* X.presheaf).germ_res le_top.hom _ _
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The canonical morphism from `X` to the spectrum of its global sections. -/
 @[simps! base]
 def toΓSpec : X ⟶ Spec.locallyRingedSpaceObj (Γ.obj (op X)) :=
@@ -237,7 +236,6 @@ def toΓSpec : X ⟶ Spec.locallyRingedSpaceObj (Γ.obj (op X)) :=
     exact ht.mul <| (IsLocalization.map_units (R := Γ.obj (op X)) S s).map _)
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- On a locally ringed space `X`, the preimage of the zero locus of the prime spectrum
 of `Γ(X, ⊤)` under `toΓSpec` agrees with the associated zero locus on `X`. -/
 lemma toΓSpec_preimage_zeroLocus_eq {X : LocallyRingedSpace.{u}}
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Connected.lean b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Connected.lean
index 7ae613dca..73c6dad02 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Connected.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Connected.lean
@@ -64,7 +64,6 @@ instance (s : S) [GeometricallyConnected f] :
   MorphismProperty.pullback_snd _ _ inferInstance
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (s : S) [GeometricallyConnected f] : ConnectedSpace (f.fiber s) :=
   GeometricallyConnected.geometrically_connectedSpace _ _ _ (.of_hasPullback _ _)
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Integral.lean b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Integral.lean
index 16a2e65e8..8eade6294 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Integral.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Integral.lean
@@ -83,7 +83,6 @@ instance (s : S) [GeometricallyIntegral f] :
   MorphismProperty.pullback_snd _ _ inferInstance
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (s : S) [GeometricallyIntegral f] : IsIntegral (f.fiber s) :=
   GeometricallyIntegral.geometrically_isIntegral _ _ _ (.of_hasPullback _ _)
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Irreducible.lean b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Irreducible.lean
index 62392544d..e6072e861 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Irreducible.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Irreducible.lean
@@ -66,7 +66,6 @@ instance (s : S) [GeometricallyIrreducible f] :
   MorphismProperty.pullback_snd _ _ inferInstance
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (s : S) [GeometricallyIrreducible f] : IrreducibleSpace (f.fiber s) :=
   GeometricallyIrreducible.geometrically_irreducibleSpace _ _ _ (.of_hasPullback _ _)
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Reduced.lean b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Reduced.lean
index 731487df8..e7e7f0362 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Reduced.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Geometrically/Reduced.lean
@@ -68,7 +68,6 @@ instance (s : S) [GeometricallyReduced f] :
   MorphismProperty.pullback_snd _ _ inferInstance
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (s : S) [GeometricallyReduced f] : IsReduced (f.fiber s) :=
   GeometricallyReduced.geometrically_isReduced _ _ _ (.of_hasPullback _ _)
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Group/Abelian.lean b/mathlib4/Mathlib/AlgebraicGeometry/Group/Abelian.lean
index 133229a84..289cd1c38 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Group/Abelian.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Group/Abelian.lean
@@ -37,7 +37,6 @@ instance (G : Over (Spec (.of K))) [GrpObj G] : IsClosedImmersion η[G].left :=
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCommMonObj_of_isProper_of_isIntegral_tensorObj_of_isAlgClosed [IsAlgClosed K]
     (G : Over (Spec (.of K))) [IsProper G.hom] [IsIntegral (G ⊗ G).left] [GrpObj G] :
     IsCommMonObj G := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/IdealSheaf/Basic.lean b/mathlib4/Mathlib/AlgebraicGeometry/IdealSheaf/Basic.lean
index 261d002ad..f8b70f468 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/IdealSheaf/Basic.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/IdealSheaf/Basic.lean
@@ -558,7 +558,6 @@ lemma radical_mul {I J : IdealSheafData X} :
   simp only [radical_ideal, ideal_mul, Pi.mul_apply, Ideal.radical_mul, ideal_inf, Pi.inf_apply]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The vanishing ideal sheaf of a closed set,
 which is the largest ideal sheaf whose support is equal to it.
 The reduced induced scheme structure on the closed set is the quotient of this ideal. -/
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Limits.lean b/mathlib4/Mathlib/AlgebraicGeometry/Limits.lean
index ec5de63a6..9e0aee575 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Limits.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Limits.lean
@@ -358,7 +358,6 @@ lemma nonempty_isColimit_cofanMk_of [Small.{u} σ]
 variable (X Y : Scheme.{u})
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- (Implementation Detail)
 The coproduct of the two schemes is given by indexed coproducts over `WalkingPair`. -/
 noncomputable
@@ -366,12 +365,10 @@ def coprodIsoSigma : X ⨿ Y ≅ ∐ fun i : ULift.{u} WalkingPair ↦ i.1.cases
   Sigma.whiskerEquiv Equiv.ulift.symm (fun _ ↦ by exact Iso.refl _)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ι_left_coprodIsoSigma_inv : Sigma.ι _ ⟨.left⟩ ≫ (coprodIsoSigma X Y).inv = coprod.inl :=
   Sigma.ι_comp_map' _ _ _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ι_right_coprodIsoSigma_inv : Sigma.ι _ ⟨.right⟩ ≫ (coprodIsoSigma X Y).inv = coprod.inr :=
   Sigma.ι_comp_map' _ _ _
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Modules/Tilde.lean b/mathlib4/Mathlib/AlgebraicGeometry/Modules/Tilde.lean
index fe84ee3e8..bc2a390b3 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Modules/Tilde.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Modules/Tilde.lean
@@ -424,7 +424,6 @@ instance : IsIso (Scheme.Modules.fromTildeΓ (SheafOfModules.unit.{u} (Spec R).r
   isIso_fromTildeΓ_iff.mpr ⟨_, ⟨tildeSelf⟩⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Tilde of direct sums of `R` as an `R`-module is isomorphic to the free sheaf. -/
 noncomputable
 def tildeFinsupp (ι : Type u) : tilde (ModuleCat.of R (ι →₀ R)) ≅ SheafOfModules.free.{u} ι :=
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Basic.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
index 00b6856ac..c6b523966 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
@@ -585,7 +585,6 @@ theorem iff_of_isAffine [IsAffine Y] : P f ↔ Q f := by
     Q.cancel_left_of_respectsIso]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 900) : IsZariskiLocalAtTarget P := by
   let := isLocal_affineProperty P
   apply IsZariskiLocalAtTarget.mk'
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Finite.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Finite.lean
index 8eb5382fc..cf6826b55 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Finite.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Finite.lean
@@ -52,19 +52,16 @@ instance : HasAffineProperty @IsFinite
   simp [isFinite_iff]
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : IsStableUnderComposition @IsFinite :=
   HasAffineProperty.affineAnd_isStableUnderComposition inferInstance
     RingHom.finite_stableUnderComposition
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : IsStableUnderBaseChange @IsFinite :=
   HasAffineProperty.affineAnd_isStableUnderBaseChange inferInstance
     RingHom.finite_respectsIso RingHom.finite_isStableUnderBaseChange
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ContainsIdentities @IsFinite :=
   HasAffineProperty.affineAnd_containsIdentities inferInstance
     RingHom.finite_respectsIso RingHom.finite_containsIdentities
@@ -159,7 +156,6 @@ lemma comp_iff {f : X ⟶ Y} {g : Y ⟶ Z} [IsFinite g] :
   ⟨fun _ ↦ .of_comp f g, fun _ ↦ inferInstance⟩
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance {U V X : Scheme.{u}} (f : U ⟶ X) (g : V ⟶ X) [IsFinite f] [IsFinite g] :
     IsFinite (Limits.coprod.desc f g) := by
   refine HasAffineProperty.coprodDesc_affineAnd inferInstance RingHom.finite_respectsIso
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean
index 9c61f604c..b4babad01 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean
@@ -144,7 +144,6 @@ nonrec lemma LocallyOfFiniteType.jacobsonSpace
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The category of affine schemes locally of finite type over a fixed base scheme is essentially small.
 TODO: extend this to (relatively) quasi-compact schemes.
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Flat.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Flat.lean
index f9db1af6e..d1c1232c4 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Flat.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/Flat.lean
@@ -336,7 +336,6 @@ lemma mono_pushoutSection_of_iSup_eq {ι : Type*} [Finite ι] (VX : ι → X.Ope
     ext x j
     simp [ψY, H₂, -CommRingCat.hom_comp, ← CategoryTheory.comp_apply, pushoutSection, ψ]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 lemma isIso_pushoutSection_of_iSup_eq
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
index b9279235a..072da1940 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
@@ -379,7 +379,6 @@ theorem iff_of_iSup_eq_top [IsAffine Y] {ι : Type*}
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : IsZariskiLocalAtSource P := by
   apply HasAffineProperty.isZariskiLocalAtSource
   intro X Y f _ 𝒰
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
index c3ff3d749..8245fe731 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
@@ -112,7 +112,6 @@ instance (f : X ⟶ Y) (V : Y.Opens) [UniversallyClosed f] : UniversallyClosed (
   IsZariskiLocalAtTarget.restrict ‹_› V
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 open Scheme.Pullback _root_.PrimeSpectrum MvPolynomial in
 /-- If `X` is universally closed over a field, then `X` is quasi-compact. -/
 lemma compactSpace_of_universallyClosed
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Noetherian.lean b/mathlib4/Mathlib/AlgebraicGeometry/Noetherian.lean
index 5dc0dd940..69e87d817 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Noetherian.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Noetherian.lean
@@ -162,7 +162,6 @@ instance {U : X.OpenCover} (i) [IsLocallyNoetherian X] : IsLocallyNoetherian (U.
   isLocallyNoetherian_of_isOpenImmersion (U.f i)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `𝒰` is an open cover of a scheme `X`, then `X` is locally Noetherian if and only if
 `𝒰.X i` are all locally Noetherian. -/
 theorem isLocallyNoetherian_iff_openCover (𝒰 : Scheme.OpenCover X) :
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Normalization.lean b/mathlib4/Mathlib/AlgebraicGeometry/Normalization.lean
index 878bbd2fa..8cc726c24 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Normalization.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Normalization.lean
@@ -344,7 +344,6 @@ instance : IsDominant f.toNormalization := by
   exact ⟨dense_iff_closure_eq.mpr this⟩
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 @[stacks 0AXN]
 instance [IsReduced X] : IsReduced f.normalization :=
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/OpenImmersion.lean b/mathlib4/Mathlib/AlgebraicGeometry/OpenImmersion.lean
index 8b9209a0d..d56d38d37 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/OpenImmersion.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/OpenImmersion.lean
@@ -45,7 +45,6 @@ instance IsOpenImmersion.comp {X Y Z : Scheme.{u}} (f : X ⟶ Y) (g : Y ⟶ Z)
 namespace LocallyRingedSpace.IsOpenImmersion
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- To show that a locally ringed space is a scheme, it suffices to show that it has a jointly
 surjective family of open immersions from affine schemes. -/
 protected def scheme (X : LocallyRingedSpace.{u})
@@ -361,7 +360,6 @@ lemma _root_.AlgebraicGeometry.IsOpenImmersion.of_isLocalization {R S} [CommRing
   infer_instance
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem exists_affine_mem_range_and_range_subset
     {X : Scheme.{u}} {x : X} {U : X.Opens} (hxU : x ∈ U) :
     ∃ R, ∃ (f : Spec R ⟶ X), IsOpenImmersion f ∧ x ∈ Set.range f ∧ Set.range f ⊆ U := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean b/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
index d10f52c75..86ddc9903 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
@@ -827,7 +827,6 @@ lemma stalkMap_toSpec (f) (x : pbo f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
   rw [awayToΓ_ΓToStalk, ← toStalk_specStalkEquiv, Category.assoc]; rfl
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma isIso_toSpec (f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
     IsIso (toSpec 𝒜 f) := by
   have : IsIso (toSpec 𝒜 f).base := toSpec_base_isIso 𝒜 f_deg hm
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean b/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
index 24c17d4b4..af6d17878 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
@@ -279,7 +279,6 @@ theorem stalkToFiberRingHom_germ (U : Opens (ProjectiveSpectrum.top 𝒜))
   RingHom.ext_iff.1 (CommRingCat.hom_ext_iff.mp (germ_comp_stalkToFiberRingHom 𝒜 U x hx)) s
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mem_basicOpen_den (x : ProjectiveSpectrum.top 𝒜)
     (f : HomogeneousLocalization.NumDenSameDeg 𝒜 x.asHomogeneousIdeal.toIdeal.primeCompl) :
     x ∈ ProjectiveSpectrum.basicOpen 𝒜 f.den := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Pullbacks.lean b/mathlib4/Mathlib/AlgebraicGeometry/Pullbacks.lean
index c83b2f0fd..2f852a88c 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Pullbacks.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Pullbacks.lean
@@ -479,7 +479,6 @@ instance left_affine_comp_pullback_hasPullback {X Y Z : Scheme} (f : X ⟶ Z) (g
     hasPullback_assoc_symm f (Z.affineCover.f i) (Z.affineCover.f i) g
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance {X Y Z : Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) : HasPullback f g :=
   hasPullback_of_cover (Z.affineCover.pullback₁ f) f g
 
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Restrict.lean b/mathlib4/Mathlib/AlgebraicGeometry/Restrict.lean
index d03e96e00..b7b0a0769 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Restrict.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Restrict.lean
@@ -120,7 +120,6 @@ lemma ι_preimage_self : U.ι ⁻¹ᵁ U = ⊤ :=
   Opens.inclusion'_map_eq_top _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_ι_image_iff {x : U} {V : Opens U} : (x : X) ∈ U.ι ''ᵁ V ↔ x ∈ V :=
   U.ι.apply_mem_image_iff
@@ -154,7 +153,6 @@ def stalkIso {X : Scheme.{u}} (U : X.Opens) (x : U) :
   X.restrictStalkIso (Opens.isOpenEmbedding _) _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp)]
 lemma germ_stalkIso_hom {X : Scheme.{u}} (U : X.Opens)
     {V : U.toScheme.Opens} (x : U) (hx : x ∈ V) :
@@ -163,7 +161,6 @@ lemma germ_stalkIso_hom {X : Scheme.{u}} (U : X.Opens)
     PresheafedSpace.restrictStalkIso_hom_eq_germ _ U.isOpenEmbedding _ _ _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc]
 lemma germ_stalkIso_inv {X : Scheme.{u}} (U : X.Opens) (V : U.toScheme.Opens) (x : U)
     (hx : x ∈ V) : X.presheaf.germ (U.ι ''ᵁ V) x ⟨x, hx, rfl⟩ ≫
@@ -237,7 +234,6 @@ lemma Scheme.Opens.ι_image_basicOpen_topIso_inv (r : Γ(X, U)) :
   rw [ι_image_basicOpen', basicOpen_res_eq, topIso_inv, basicOpen_res_eq X]
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma Scheme.Opens.mem_basicOpen_toScheme {U : X.Opens} {V : Scheme.Opens U} {r : Γ(U, V)} {x : U} :
     x ∈ U.toScheme.basicOpen r ↔ (x : X) ∈ X.basicOpen r := by
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Scheme.lean b/mathlib4/Mathlib/AlgebraicGeometry/Scheme.lean
index 1f43f76ac..f93f889c2 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Scheme.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Scheme.lean
@@ -890,7 +890,6 @@ lemma Scheme.inv_hom_apply {X Y : Scheme.{u}} (e : X ≅ Y) (y : Y) :
   simp
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Spec_zeroLocus_eq_zeroLocus {R : CommRingCat} (s : Set R) :
     (Spec R).zeroLocus ((Scheme.ΓSpecIso R).inv '' s) = PrimeSpectrum.zeroLocus s := by
   ext x
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Sites/Etale.lean b/mathlib4/Mathlib/AlgebraicGeometry/Sites/Etale.lean
index 942d366c9..9b790dbf9 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Sites/Etale.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Sites/Etale.lean
@@ -56,7 +56,6 @@ set_option backward.isDefEq.respectTransparency.types false in
 def smallEtalePretopology (X : Scheme.{u}) : Pretopology X.Etale :=
   X.smallPretopology (Q := @Etale) (P := @Etale)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 lemma ofArrows_mem_smallEtaleTopology_iff
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Sites/EtalePoint.lean b/mathlib4/Mathlib/AlgebraicGeometry/Sites/EtalePoint.lean
index 3e4865b51..0bbd1ed50 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Sites/EtalePoint.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Sites/EtalePoint.lean
@@ -93,7 +93,6 @@ noncomputable def pointSmallEtale : (smallEtaleTopology S).Point where
 
 variable {s₀ : S} (hs₀ : s default = s₀)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a morphism `s : Spec (.of Ω) ⟶ S` with image `s₀ : S` where `Ω` is a
 separably closed field, this is the canonical map
 `(pointSmallEtale s).fiber.obj X ⟶ X.hom ⁻¹' {s₀}` for `X : S.Etale`. -/
@@ -111,7 +110,6 @@ instance {Y X : Scheme.{u}} (f : Y ⟶ X) [Etale f] (x : X) :
   dsimp [Hom.fiberToSpecResidueField]
   infer_instance
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma pointSmallEtaleFiberObjToPreimage_surjective (X : S.Etale) :
     Function.Surjective (pointSmallEtaleFiberObjToPreimage s hs₀ (X := X)) := by
@@ -124,7 +122,6 @@ lemma pointSmallEtaleFiberObjToPreimage_surjective (X : S.Etale) :
   refine ⟨Over.homMk (l ≫ X.hom.fiberι t) ?_, rfl⟩
   simp [X.hom.fiber_fac, reassoc_of% hl]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isConservative_pointSmallEtale
     {ι : Type*} {S : Scheme.{u}}
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/Spec.lean b/mathlib4/Mathlib/AlgebraicGeometry/Spec.lean
index 4dc2f26ed..6d84a46dc 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/Spec.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/Spec.lean
@@ -238,7 +238,6 @@ theorem localRingHom_comp_stalkIso {R S : CommRingCat.{u}} (f : R ⟶ S) (p : Pr
   exact stalkMap_toStalk_apply f p x
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The induced map of a ring homomorphism on the prime spectra, as a morphism of locally ringed spaces.
 -/
@@ -370,7 +369,6 @@ def toPushforwardStalkAlgHom :
     commutes' := fun _ => rfl }
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isLocalizedModule_toPushforwardStalkAlgHom_aux (y) :
     ∃ x : S × p.asIdeal.primeCompl, x.2 • y = toPushforwardStalkAlgHom R S p x.1 := by
   obtain ⟨U, hp, s, e⟩ := TopCat.Presheaf.exists_germ_eq _ y
@@ -404,7 +402,6 @@ theorem isLocalizedModule_toPushforwardStalkAlgHom_aux (y) :
   congr 1
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance isLocalizedModule_toPushforwardStalkAlgHom :
     IsLocalizedModule p.asIdeal.primeCompl (toPushforwardStalkAlgHom R S p).toLinearMap := by
   apply IsLocalizedModule.mkOfAlgebra
diff --git a/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean b/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
index a5434f420..941f30261 100644
--- a/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
+++ b/mathlib4/Mathlib/AlgebraicGeometry/StructureSheaf.lean
@@ -414,7 +414,6 @@ def toBasicOpenₗ (f : R) :
     exact Submonoid.powers_le (P := (IsUnit.submonoid _).comap (algebraMap R _)).mpr
       (isUnit_basicOpen_end ..)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 @[simp]
 theorem toBasicOpenₗ_mk (s : R) (f : M) (g : Submonoid.powers s) :
@@ -626,7 +625,6 @@ instance (x : PrimeSpectrum.Top R) :
       ↑(TopCat.Presheaf.stalk (moduleStructurePresheaf R M).presheaf x) :=
   .of_algebraMap_smul fun _ _ ↦ rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 variable (R M) in
 def modulePresheafStalkIso (x : PrimeSpectrum.Top R) :
@@ -660,7 +658,6 @@ instance (x : PrimeSpectrum.Top R) :
       ((structurePresheafInModuleCat R M).stalk x) :=
   (modulePresheafStalkIso R M x).toAddEquiv.symm.module _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma toStalk_smul (x : PrimeSpectrum.Top R) (r : R)
     (m : (structurePresheafInModuleCat R M).stalk x) :
     toStalk R x r • m = r • m := by
@@ -684,7 +681,6 @@ theorem toOpenₗ_germ (U : Opens (PrimeSpectrum.Top R)) (x : PrimeSpectrum.Top
   rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isUnit_toStalk (x : PrimeSpectrum.Top R) (f : R) (hf : x ∈ basicOpen f) :
     IsUnit (toStalk R x f) := by
   convert! (isUnit_basicOpen f).map ((structurePresheafInCommRingCat R).germ _ x hf).hom
@@ -713,7 +709,6 @@ def localizationtoStalkₗ (x : PrimeSpectrum.Top R) :
     (LocalizedModule.mkLinearMap x.asIdeal.primeCompl M)
     (toStalkₗ' R M x).hom fun f ↦ isUnit_toStalkₗ' x f.1 f.2 :)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem localizationtoStalkₗ_mk (x : PrimeSpectrum.Top R) (f : M) (s) :
@@ -827,7 +822,6 @@ instance (x : PrimeSpectrum.Top R) :
   rw! [PrimeSpectrum.basicOpen_one]
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (R M) in
 /-- The canonical ring homomorphism interpreting an element of `R` as an element of
@@ -865,7 +859,6 @@ instance (x : PrimeSpectrum.Top R) : IsLocalizedModule x.asIdeal.primeCompl (toS
   exact congr($this _)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R) in
 /-- The stalk of `Spec R` at `x` is isomorphic to the stalk of `R^~` at `x`. -/
 @[expose] public
@@ -994,7 +987,6 @@ instance to_basicOpen_epi (r : R) :
     (CommRingCat.hom_ext_iff.mp h))⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The ring isomorphism between the ring `R` and the global sections `Γ(X, 𝒪ₓ)`. -/
 @[simps! inv]
 def globalSectionsIso : CommRingCat.of R ≅ (structureSheaf R).1.obj (op ⊤) :=
diff --git a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/AnodyneExtensions/UnionProd.lean b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/AnodyneExtensions/UnionProd.lean
index 939b41ae3..791c67365 100644
--- a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/AnodyneExtensions/UnionProd.lean
+++ b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/AnodyneExtensions/UnionProd.lean
@@ -595,7 +595,6 @@ lemma type₁_pairingCore {m : ℕ} (k : Fin (m + 1)) {n : ℕ}
     (pairingCore k n).type₁ s = s.x :=
   Subcomplex.N.cast_eq_self _ s.hd
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
 /-- A weak rank function for `pairingCore k n`. -/
diff --git a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/Degenerate.lean b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/Degenerate.lean
index 57804626b..e87c92954 100644
--- a/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/Degenerate.lean
+++ b/mathlib4/Mathlib/AlgebraicTopology/SimplicialSet/Degenerate.lean
@@ -264,7 +264,6 @@ variable {X} (A : X.Subcomplex)
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma mem_degenerate_iff {n : ℕ} (x : A.obj (op ⦋n⦌)) :
     dsimp% x ∈ degenerate A n ↔ x.val ∈ X.degenerate n := by
   rw [SSet.mem_degenerate_iff, SSet.mem_degenerate_iff]
@@ -280,7 +279,6 @@ lemma mem_degenerate_iff {n : ℕ} (x : A.obj (op ⦋n⦌)) :
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma mem_nonDegenerate_iff {n : ℕ} (x : A.obj (op ⦋n⦌)) :
     dsimp% x ∈ nonDegenerate A n ↔ x.val ∈ X.nonDegenerate n := by
   rw [mem_nonDegenerate_iff_notMem_degenerate,
diff --git a/mathlib4/Mathlib/Analysis/Asymptotics/TVS.lean b/mathlib4/Mathlib/Analysis/Asymptotics/TVS.lean
index f5bbb010e..941f097ec 100644
--- a/mathlib4/Mathlib/Analysis/Asymptotics/TVS.lean
+++ b/mathlib4/Mathlib/Analysis/Asymptotics/TVS.lean
@@ -417,7 +417,6 @@ lemma isLittleOTVS_sup : f =o[𝕜; l₁ ⊔ l₂] g ↔ f =o[𝕜; l₁] g ∧
 lemma IsLittleOTVS.sup (hf₁ : f =o[𝕜; l₁] g) (hf₂ : f =o[𝕜; l₂] g) : f =o[𝕜; l₁ ⊔ l₂] g :=
   isLittleOTVS_sup.mpr ⟨hf₁, hf₂⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma _root_.ContinuousLinearMap.isBigOTVS_id {l : Filter E} (f : E →L[𝕜] F) : f =O[𝕜; l] id :=
   ⟨fun U hU ↦ ⟨f ⁻¹' U, (map_continuous f).tendsto' 0 0 (map_zero f) hU, .of_forall <|
     (mapsTo_preimage f U).egauge_le 𝕜 f⟩⟩
@@ -428,7 +427,6 @@ lemma _root_.ContinuousLinearMap.isBigOTVS_comp (g : E →L[𝕜] F) : (g ∘ f)
 lemma _root_.ContinuousLinearMap.isBigOTVS_fun_comp (g : E →L[𝕜] F) : (g <| f ·) =O[𝕜; l] f :=
   g.isBigOTVS_comp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma _root_.LinearMap.isBigOTVS_rev_comp (g : E →ₗ[𝕜] F) (hg : comap g (𝓝 0) ≤ 𝓝 0) :
     f =O[𝕜; l] (g ∘ f) := by
   constructor
diff --git a/mathlib4/Mathlib/Analysis/BoxIntegral/Basic.lean b/mathlib4/Mathlib/Analysis/BoxIntegral/Basic.lean
index a58891581..39e9aba59 100644
--- a/mathlib4/Mathlib/Analysis/BoxIntegral/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/BoxIntegral/Basic.lean
@@ -148,7 +148,6 @@ theorem integralSum_neg (f : ℝⁿ → E) (vol : ι →ᵇᵃ E →L[ℝ] F) (
     integralSum (-f) vol π = -integralSum f vol π := by
   simp only [integralSum, Pi.neg_apply, (vol _).map_neg, Finset.sum_neg_distrib]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem integralSum_smul (c : ℝ) (f : ℝⁿ → E) (vol : ι →ᵇᵃ E →L[ℝ] F) (π : TaggedPrepartition I) :
     integralSum (c • f) vol π = c • integralSum f vol π := by
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/CStarMatrix.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/CStarMatrix.lean
index e0c570e30..9d2e53320 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/CStarMatrix.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/CStarMatrix.lean
@@ -587,7 +587,6 @@ lemma norm_def {M : CStarMatrix m n A} : ‖M‖ = ‖toCLM M‖ := rfl
 
 lemma norm_def' {M : CStarMatrix n n A} : ‖M‖ = ‖toCLMNonUnitalAlgHom (A := A) M‖ := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma normedSpaceCore : NormedSpace.Core ℂ (CStarMatrix m n A) where
   norm_nonneg M := (toCLM M).opNorm_nonneg
   norm_smul c M := by rw [norm_def, norm_def, map_smul, norm_smul _ (toCLM M)]
@@ -820,11 +819,9 @@ noncomputable instance instNormedRing : NormedRing (CStarMatrix n n A) where
   dist_eq _ _ := rfl
   norm_mul_le := norm_mul_le
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance instNormedAlgebra : NormedAlgebra ℂ (CStarMatrix n n A) where
   norm_smul_le r M := by simpa only [norm_def, map_smul] using (toCLM M).opNorm_smul_le r
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Matrices with entries in a unital C⋆-algebra form a unital C⋆-algebra. -/
 noncomputable instance instCStarAlgebra : CStarAlgebra (CStarMatrix n n A) where
 
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Commute.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Commute.lean
index f82e9f31f..d0ad5f139 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Commute.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Commute.lean
@@ -131,7 +131,6 @@ variable [NonUnitalContinuousFunctionalCalculus 𝕜 A p] [IsTopologicalRing A]
 
 open ContinuousMapZero
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open NonUnitalStarAlgebra.elemental in
 protected theorem Commute.cfcₙHom {a b : A} (ha : p a) (hb₁ : Commute a b)
     (hb₂ : Commute (star a) b) (f : C(quasispectrum 𝕜 a, 𝕜)₀) :
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Continuity.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Continuity.lean
index e7e13e562..7fd03a672 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Continuity.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Continuity.lean
@@ -735,7 +735,6 @@ variable {X 𝕜 A : Type*} {p : A → Prop} [RCLike 𝕜] [NonUnitalNormedRing
     [NormedSpace 𝕜 A] [IsScalarTower 𝕜 A A] [SMulCommClass 𝕜 A A] [ContinuousStar A]
     [NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped NonUnitalContinuousFunctionalCalculus ContinuousMapZero in
 /-- `cfcₙHomSuperset` is continuous in the variable `a : A` when `s : Set 𝕜` is compact and `a`
 varies over elements whose spectrum is contained in `s`, all of which satisfy the predicate `p`. -/
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
index fee27a742..9c1539fa6 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
@@ -191,7 +191,6 @@ end cfcₙHom
 
 section cfcₙL
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `cfcₙHom` bundled as a continuous linear map. -/
 @[simps apply]
 noncomputable def cfcₙL {a : A} (ha : p a) : C(σₙ R a, R)₀ →L[R] A :=
@@ -412,7 +411,6 @@ lemma cfcₙ_sum_univ {ι : Type*} [Fintype ι] (f : ι → R → R) (a : A)
     cfcₙ (∑ i, f i) a = ∑ i, cfcₙ (f i) a :=
   cfcₙ_sum f a _ (fun i _ ↦ hf i) (fun i _ ↦ hf0 i)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cfcₙ_smul {S : Type*} [SMulZeroClass S R] [ContinuousConstSMul S R]
     [SMulZeroClass S A] [IsScalarTower S R A] [IsScalarTower S R (R → R)]
     (s : S) (f : R → R) (a : A) (hf : ContinuousOn f (σₙ R a) := by cfc_cont_tac)
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unique.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unique.lean
index 8204209ff..45f381d02 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unique.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@@ -284,7 +284,6 @@ section IsTopologicalRing
 
 variable [TopologicalSpace A] [IsSemitopologicalRing A]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a non-unital star `ℝ≥0`-algebra homomorphism `φ` from `C(X, ℝ≥0)₀` into a non-unital
 `ℝ`-algebra `A`, this is the unique extension of `φ` from `C(X, ℝ)₀` to `A` as a non-unital
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean
index 536c43d33..9587d3ffd 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean
@@ -284,7 +284,6 @@ end cfcHom
 
 section cfcL
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `cfcHom` bundled as a continuous linear map. -/
 @[simps apply]
 noncomputable def cfcL {a : A} (ha : p a) : C(spectrum R a, R) →L[R] A :=
@@ -518,7 +517,6 @@ lemma cfc_sum_univ {ι : Type*} [Fintype ι] (f : ι → R → R) (a : A)
     cfc (∑ i, f i) a = ∑ i, cfc (f i) a :=
   cfc_sum f a _ fun i _ ↦ hf i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cfc_smul {S : Type*} [SMul S R] [ContinuousConstSMul S R]
     [SMulZeroClass S A] [IsScalarTower S R A] [IsScalarTower S R (R → R)]
     (s : S) (f : R → R) (a : A) (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac) :
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/GelfandNaimarkSegal.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/GelfandNaimarkSegal.lean
index bb00cbac6..3a577b007 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/GelfandNaimarkSegal.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/GelfandNaimarkSegal.lean
@@ -69,7 +69,6 @@ lemma ofPreGNS_toPreGNS (a : A) : f.ofPreGNS (f.toPreGNS a) = a := rfl
 
 variable [StarOrderedRing A]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The (semi-)inner product space whose elements are the elements of `A`, but which has an
 inner product-induced norm that is different from the norm on `A` and which is induced by `f`.
@@ -86,15 +85,12 @@ noncomputable instance : SeminormedAddCommGroup f.PreGNS :=
 noncomputable instance : InnerProductSpace ℂ f.PreGNS :=
   InnerProductSpace.ofCore f.preGNSpreInnerProdSpace
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma preGNS_inner_def (a b : f.PreGNS) :
     ⟪a, b⟫_ℂ = f (star (f.ofPreGNS a) * f.ofPreGNS b) := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma preGNS_norm_def (a : f.PreGNS) :
     ‖a‖ = √(f (star (f.ofPreGNS a) * f.ofPreGNS a)).re := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma preGNS_norm_sq (a : f.PreGNS) :
     ‖a‖ ^ 2 = f (star (f.ofPreGNS a) * f.ofPreGNS a) := by
   have : 0 ≤ f (star (f.ofPreGNS a) * f.ofPreGNS a) := f.map_nonneg (star_mul_self_nonneg _)
@@ -133,7 +129,6 @@ lemma leftMulMapPreGNS_mul_eq_comp (a b : A) :
     f.leftMulMapPreGNS (a * b) = f.leftMulMapPreGNS a ∘L f.leftMulMapPreGNS b := by
   ext c; simp [mul_assoc]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 This proves map_smul' of gnsNonUnitalStarAlgHom so that map_zero' can be proven as a direct
 consequence.
@@ -148,7 +143,6 @@ private lemma completion_leftMulMapPreGNS_map_smul (m : ℂ) (x : A) :
       (m • (f.leftMulMapPreGNS x).completion).continuous
   | ih a => simp [smul_mul_assoc]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The non-unital ⋆-homomorphism/⋆-representation of `A` into the algebra of bounded operators on
 a Hilbert space that is constructed from a positive linear functional `f` on a possibly non-unital
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/Matrix.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/Matrix.lean
index bc4bee359..177e5295e 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/Matrix.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/Matrix.lean
@@ -249,7 +249,6 @@ lemma l2_opNorm_diagonal (v : n → 𝕜) : ‖(diagonal v : Matrix n n 𝕜)‖
 lemma l2_opNNNorm_diagonal (v : n → 𝕜) : ‖(diagonal v : Matrix n n 𝕜)‖₊ = ‖v‖₊ :=
   Subtype.ext <| l2_opNorm_diagonal (n := n) (𝕜 := 𝕜) v
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The normed algebra structure on `Matrix n n 𝕜` arising from the operator norm given by the
 identification with (continuous) linear endomorphisms of `EuclideanSpace 𝕜 n`. -/
 @[instance_reducible]
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/Multiplier.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/Multiplier.lean
index c0b2526ac..5ba03960d 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/Multiplier.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/Multiplier.lean
@@ -460,7 +460,6 @@ theorem coe_eq_algebraMap : (DoubleCentralizer.coe 𝕜 : 𝕜 → 𝓜(𝕜, 
   · refine ContinuousLinearMap.ext fun y => ?_
     exact mul_comm y x  -- `snd` multiplies on the wrong side
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The coercion of an algebra into its multiplier algebra as a non-unital star algebra
 homomorphism. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/PositiveLinearMap.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/PositiveLinearMap.lean
index b0ee372fb..22ba7dd88 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/PositiveLinearMap.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/PositiveLinearMap.lean
@@ -56,7 +56,6 @@ lemma norm_apply_le_of_nonneg [StarOrderedRing B₂] (f : B₁ →ₚ[ℂ] B₂)
   rw [← Algebra.algebraMap_eq_smul_one]
   exact IsSelfAdjoint.le_algebraMap_norm_self <| .of_nonneg hx
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open Complex Filter in
 /--
 If `f` is a positive map, then it is bounded (and therefore continuous).
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/Spectrum.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/Spectrum.lean
index 55825c2da..951ea294c 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/Spectrum.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/Spectrum.lean
@@ -323,7 +323,6 @@ open scoped ComplexStarModule
 
 variable {F A : Type*} [CStarAlgebra A] [FunLike F A ℂ] [hF : AlgHomClass F ℂ A ℂ]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- This instance is provided instead of `StarHomClass` to avoid type class inference loops.
 See note [lower instance priority] -/
 noncomputable instance (priority := 100) Complex.instStarHomClass : StarHomClass F A ℂ where
diff --git a/mathlib4/Mathlib/Analysis/CStarAlgebra/Unitization.lean b/mathlib4/Mathlib/Analysis/CStarAlgebra/Unitization.lean
index 68fef0820..7416f4df1 100644
--- a/mathlib4/Mathlib/Analysis/CStarAlgebra/Unitization.lean
+++ b/mathlib4/Mathlib/Analysis/CStarAlgebra/Unitization.lean
@@ -56,7 +56,6 @@ variable [DenselyNormedField 𝕜] [NonUnitalNormedRing E] [StarRing E] [CStarRi
 variable [NormedSpace 𝕜 E] [IsScalarTower 𝕜 E E] [SMulCommClass 𝕜 E E]
 variable (E)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A C⋆-algebra over a densely normed field is a regular normed algebra. -/
 instance CStarRing.instRegularNormedAlgebra : RegularNormedAlgebra 𝕜 E where
diff --git a/mathlib4/Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean b/mathlib4/Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean
index b9eb6b079..084664a10 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean
@@ -979,7 +979,6 @@ lemma iteratedFDeriv_comp_sub (n : ℕ) (a : E) (x : E) :
     iteratedFDeriv 𝕜 n (fun z ↦ f (z - a)) x = iteratedFDeriv 𝕜 n f (x - a) := by
   simp [iteratedFDeriv_comp_sub']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma iteratedFDerivWithin_comp_neg {f : 𝕜 → F} {s : Set 𝕜} (n : ℕ) (a : 𝕜) :
     iteratedFDerivWithin 𝕜 n (fun x ↦ f (-x)) s a
       = (-1 : 𝕜) ^ n • iteratedFDerivWithin 𝕜 n f (-s) (-a) := by
diff --git a/mathlib4/Mathlib/Analysis/Calculus/Deriv/Basic.lean b/mathlib4/Mathlib/Analysis/Calculus/Deriv/Basic.lean
index bb4df2f72..99b298181 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/Deriv/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/Deriv/Basic.lean
@@ -456,7 +456,6 @@ theorem norm_derivWithin_eq_norm_fderivWithin : ‖derivWithin f s x‖ = ‖fde
 
 theorem fderiv_apply_one_eq_deriv : (fderiv 𝕜 f x : 𝕜 → F) 1 = deriv f x := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem fderiv_eq_smul_deriv (y : 𝕜) : (fderiv 𝕜 f x : 𝕜 → F) y = y • deriv f x := by
   rw [← fderiv_apply_one_eq_deriv, ← map_smul]
diff --git a/mathlib4/Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean b/mathlib4/Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean
index 600dd4cd3..513adb09e 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean
@@ -212,7 +212,6 @@ variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddComm
 section
 include s_conv hf xs hx
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Assume that `f` is differentiable inside a convex set `s`, and that its derivative `f'` is
 differentiable at a point `x`. Then, given two vectors `v` and `w` pointing inside `s`, one can
@@ -392,7 +391,6 @@ theorem Convex.second_derivative_within_at_symmetric_of_mem_interior {v w : E}
 
 end
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If a function is differentiable inside a convex set with nonempty interior, and has a second
 derivative at a point of this convex set, then this second derivative is symmetric. -/
diff --git a/mathlib4/Mathlib/Analysis/Calculus/Rademacher.lean b/mathlib4/Mathlib/Analysis/Calculus/Rademacher.lean
index 22c4169c9..fb1a49805 100644
--- a/mathlib4/Mathlib/Analysis/Calculus/Rademacher.lean
+++ b/mathlib4/Mathlib/Analysis/Calculus/Rademacher.lean
@@ -201,7 +201,6 @@ theorem integral_lineDeriv_mul_eq
     · exact h'g.mul_left
   · exact (hf.continuous.mul hg.continuous).integrable_of_hasCompactSupport h'g.mul_left
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The line derivative of a Lipschitz function is almost everywhere linear with respect to fixed
 coefficients. -/
 theorem ae_lineDeriv_sum_eq
diff --git a/mathlib4/Mathlib/Analysis/Complex/Harmonic/Analytic.lean b/mathlib4/Mathlib/Analysis/Complex/Harmonic/Analytic.lean
index a49864ae2..bcf8efc29 100644
--- a/mathlib4/Mathlib/Analysis/Complex/Harmonic/Analytic.lean
+++ b/mathlib4/Mathlib/Analysis/Complex/Harmonic/Analytic.lean
@@ -63,7 +63,6 @@ theorem HarmonicAt.analyticAt_complex_partial (hf : HarmonicAt f x) :
     (fun _ hy ↦ (HarmonicAt.differentiableAt_complex_partial hy).differentiableWithinAt)
     ((isOpen_setOfPred_harmonicAt f).mem_nhds hf)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-
 If a function `f : ℂ → ℝ` is harmonic on an open ball, then `f` is the real part of a function
 `F : ℂ → ℂ` that is holomorphic on the ball.
@@ -104,7 +103,6 @@ theorem InnerProductSpace.HarmonicOnNhd.exists_analyticOnNhd_ball_re_eq {z : ℂ
 alias harmonic_is_realOfHolomorphic :=
   InnerProductSpace.HarmonicOnNhd.exists_analyticOnNhd_ball_re_eq
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 If a function `f : ℂ → ℝ` is harmonic, then `f` is the real part of a holomorphic function.
 -/
diff --git a/mathlib4/Mathlib/Analysis/Convex/Approximation.lean b/mathlib4/Mathlib/Analysis/Convex/Approximation.lean
index 2795408d5..5ed0b00ca 100644
--- a/mathlib4/Mathlib/Analysis/Convex/Approximation.lean
+++ b/mathlib4/Mathlib/Analysis/Convex/Approximation.lean
@@ -62,7 +62,6 @@ section RCLike
 variable [AddCommGroup E] [Module ℝ E] [Module 𝕜 E] [IsScalarTower ℝ 𝕜 E] [IsTopologicalAddGroup E]
   [ContinuousSMul 𝕜 E] [LocallyConvexSpace ℝ E]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `φ : E → ℝ` be a convex and lower-semicontinuous function on a closed convex subset `s`. For
 any point `x ∈ s` and `a < φ x`, there exists a continuous affine linear function `f` in `E` such
 that `f ≤ φ` on `s` and `f x = a`. This is an auxiliary lemma used in the proof of
@@ -89,7 +88,6 @@ lemma exists_affine_le_of_lt {x : E} {a : ℝ} (hx : x ∈ s) (hax : a < φ x) (
       using mul_le_mul_of_nonneg_left (hine z.2).le hc.le
   · simp [u, c, smul_re]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma exists_affine_le_of_lt_real {s : Set ℝ} {f : ℝ → ℝ} {x : ℝ} {a : ℝ} (hx : x ∈ s)
     (hax : a < f x) (hsc : IsClosed s) (hfc : LowerSemicontinuousOn f s) (hf : ConvexOn ℝ s f) :
     ∃ (c c' : ℝ), (∀ y ∈ s, c * y + c' ≤ f y) ∧ c * x + c' = a := by
diff --git a/mathlib4/Mathlib/Analysis/Convex/EGauge.lean b/mathlib4/Mathlib/Analysis/Convex/EGauge.lean
index 3117d7b35..92f81aab4 100644
--- a/mathlib4/Mathlib/Analysis/Convex/EGauge.lean
+++ b/mathlib4/Mathlib/Analysis/Convex/EGauge.lean
@@ -225,7 +225,6 @@ theorem egauge_prod_mk {F : Type*} [AddCommGroup F] [Module 𝕜 F] {U : Set E}
   | inl hle => exact ⟨y, ⟨hU.smul_mono hle hx, hy⟩, hyr⟩
   | inr hle => exact ⟨x, ⟨hx, hV.smul_mono hle hy⟩, hxr⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem egauge_add_add_le {U V : Set E} (hU : Balanced 𝕜 U) (hV : Balanced 𝕜 V) (a b : E) :
     egauge 𝕜 (U + V) (a + b) ≤ max (egauge 𝕜 U a) (egauge 𝕜 V b) := by
   rw [← egauge_prod_mk hU hV a b, ← add_image_prod]
diff --git a/mathlib4/Mathlib/Analysis/Convex/Side.lean b/mathlib4/Mathlib/Analysis/Convex/Side.lean
index 6d10df313..46445050b 100644
--- a/mathlib4/Mathlib/Analysis/Convex/Side.lean
+++ b/mathlib4/Mathlib/Analysis/Convex/Side.lean
@@ -916,7 +916,6 @@ open AffineSubspace
 variable [Field R] [LinearOrder R] [IsStrictOrderedRing R] [AddCommGroup V] [Module R V]
 variable [AddTorsor V P] {n : ℕ} [NeZero n] (s : Simplex R P n)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma sSameSide_affineSpan_faceOpposite_of_sign_eq {w₁ w₂ : Fin (n + 1) → R} (hw₁ : ∑ j, w₁ j = 1)
     (hw₂ : ∑ j, w₂ j = 1) {i : Fin (n + 1)} (hs : SignType.sign (w₁ i) = SignType.sign (w₂ i))
diff --git a/mathlib4/Mathlib/Analysis/Distribution/ContDiffMapSupportedIn.lean b/mathlib4/Mathlib/Analysis/Distribution/ContDiffMapSupportedIn.lean
index 58bba13d7..e033d86ed 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/ContDiffMapSupportedIn.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/ContDiffMapSupportedIn.lean
@@ -313,7 +313,6 @@ lemma toBoundedContinuousFunctionLM_eq_of_scalars (𝕜' : Type*) [NontriviallyN
     (toBoundedContinuousFunctionLM 𝕜 : 𝓓^{n}_{K}(E, F) → _) = toBoundedContinuousFunctionLM 𝕜' :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable {𝕜} in
 -- Note: generalizing this to a semilinear setting would require a semilinear version of
 -- `CompatibleSMul`.
@@ -541,7 +540,6 @@ instance isUniformAddGroup : IsUniformAddGroup 𝓓^{n}_{K}(E, F) := by
   rw [ContDiffMapSupportedIn.uniformSpace_eq_iInf]
   exact isUniformAddGroup_iInf fun _ ↦ IsUniformAddGroup.comap _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance continuousSMul : ContinuousSMul 𝕜 𝓓^{n}_{K}(E, F) :=
   continuousSMul_iInf fun i ↦ continuousSMul_induced (structureMapLM 𝕜 n i)
 
@@ -954,7 +952,6 @@ protected theorem integrable_bilin (B : F₁ →L[𝕜] F₂ →L[𝕜] F₃) {
 
 variable [SMulCommClass ℝ 𝕜 F₁] [NormedSpace ℝ F₃] [SMulCommClass ℝ 𝕜 F₃]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 -- TODO: semilinearize
 /-- Given a continuous `𝕜`-bilinear map `B : F₁ →L[𝕜] F₂ →L[𝕜] F₃`, a measure `μ` on `E`,
 and a function `φ : E → F₂` which is `μ`-integrable on `K`, this is the `𝕜`-linear map
diff --git a/mathlib4/Mathlib/Analysis/Distribution/Distribution.lean b/mathlib4/Mathlib/Analysis/Distribution/Distribution.lean
index 3b3bb6d47..141a771d7 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/Distribution.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/Distribution.lean
@@ -240,7 +240,6 @@ lemma lineDerivCLM_add {v₁ v₂ : E} :
   ext T f
   simp [lineDerivCLM_apply, TestFunction.lineDerivCLM_add, neg_add, -neg_add_rev]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma lineDerivCLM_smul {c : ℝ} {v : E} :
     (lineDerivCLM (c • v) : 𝓓'^{k}(Ω, F) →L[ℝ] 𝓓'^{n}(Ω, F)) =
       c • lineDerivCLM v := by
@@ -269,7 +268,6 @@ noncomputable instance : LineDerivAdd E 𝓓'(Ω, F) 𝓓'(Ω, F) where
   lineDerivOp_add v := map_add (lineDerivCLM v)
   lineDerivOp_left_add _ _ T := congr($lineDerivCLM_add T)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance : LineDerivSMul ℝ E 𝓓'(Ω, F) 𝓓'(Ω, F) where
   lineDerivOp_smul v := map_smul (lineDerivCLM v)
 
diff --git a/mathlib4/Mathlib/Analysis/Distribution/FourierMultiplier.lean b/mathlib4/Mathlib/Analysis/Distribution/FourierMultiplier.lean
index 8d4979d04..3ea062996 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/FourierMultiplier.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/FourierMultiplier.lean
@@ -104,7 +104,6 @@ theorem lineDeriv_eq_fourierMultiplierCLM (m : E) (f : 𝓢(E, F)) :
 
 open Laplacian
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem laplacian_eq_fourierMultiplierCLM (f : 𝓢(E, F)) :
     Δ f = -(2 * π) ^ 2 • fourierMultiplierCLM F (‖·‖ ^ 2) f := by
   let ι := Fin (Module.finrank ℝ E)
@@ -153,7 +152,6 @@ theorem fourierMultiplierCLM_apply_apply (g : E → ℂ) (f : 𝓢'(E, F)) (u :
     fourierMultiplierCLM F g f u = f (𝓕 (SchwartzMap.smulLeftCLM ℂ g (𝓕⁻ u))) := by
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem fourierMultiplierCLM_const (c : ℂ) :
     fourierMultiplierCLM F (fun (_ : E) ↦ c) = c • ContinuousLinearMap.id _ _ := by
@@ -207,7 +205,6 @@ theorem lineDeriv_eq_fourierMultiplierCLM (m : E) (f : 𝓢'(E, F)) :
 
 open Laplacian
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem laplacian_eq_fourierMultiplierCLM (f : 𝓢'(E, F)) :
     Δ f = -(2 * π) ^ 2 • fourierMultiplierCLM F (fun x ↦ Complex.ofReal (‖x‖ ^ 2)) f := by
   let ι := Fin (Module.finrank ℝ E)
diff --git a/mathlib4/Mathlib/Analysis/Distribution/TemperedDistribution.lean b/mathlib4/Mathlib/Analysis/Distribution/TemperedDistribution.lean
index 5836b0478..3bbfd1242 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/TemperedDistribution.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/TemperedDistribution.lean
@@ -253,7 +253,6 @@ theorem smulLeftCLM_apply_apply (g : E → ℂ) (f : 𝓢'(E, F)) (f' : 𝓢(E,
     smulLeftCLM F g f f' = f (SchwartzMap.smulLeftCLM ℂ g f') := by
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem smulLeftCLM_const (c : ℂ) (f : 𝓢'(E, F)) : smulLeftCLM F (fun _ : E ↦ c) f = c • f := by
   ext1; simp
@@ -270,7 +269,6 @@ theorem smulLeftCLM_compL_smulLeftCLM {g₁ g₂ : E → ℂ} (hg₁ : g₁.HasT
   ext1 f
   simp [hg₁, hg₂]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem smulLeftCLM_smul {g : E → ℂ} (hg : g.HasTemperateGrowth) (c : ℂ) :
     smulLeftCLM F (c • g) = c • smulLeftCLM F g := by
   ext f u
@@ -557,7 +555,6 @@ open LineDeriv Real
 
 variable [NormedAddCommGroup F] [NormedSpace ℂ F]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The line derivative in direction `m` of the Fourier transform is given by the Fourier transform
 of the multiplication with `-(2 * π * Complex.I) • (inner ℝ · m)`. -/
 theorem lineDerivOp_fourier_eq (f : 𝓢'(E, F)) (m : E) :
@@ -566,7 +563,6 @@ theorem lineDerivOp_fourier_eq (f : 𝓢'(E, F)) (m : E) :
   have : (inner ℝ · m).HasTemperateGrowth := by fun_prop
   simp [SchwartzMap.fourier_lineDerivOp_eq, ← smulLeftCLM_ofReal ℂ this]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The Fourier transform of line derivative in direction `m` is given by multiplication of
 `(2 * π * Complex.I) • (inner ℝ · m)` with the Fourier transform. -/
 theorem fourier_lineDerivOp_eq (f : 𝓢'(E, F)) (m : E) :
@@ -575,7 +571,6 @@ theorem fourier_lineDerivOp_eq (f : 𝓢'(E, F)) (m : E) :
   have : (inner ℝ · m).HasTemperateGrowth := by fun_prop
   simp [SchwartzMap.lineDerivOp_fourier_eq, ← smulLeftCLM_ofReal ℂ this]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The line derivative in direction `m` of the inverse Fourier transform is given by the inverse
 Fourier transform of the multiplication with `(2 * π * Complex.I) • (inner ℝ · m)`. -/
 theorem lineDerivOp_fourierInv_eq (f : 𝓢'(E, F)) (m : E) :
@@ -584,7 +579,6 @@ theorem lineDerivOp_fourierInv_eq (f : 𝓢'(E, F)) (m : E) :
   have : (inner ℝ · m).HasTemperateGrowth := by fun_prop
   simp [SchwartzMap.fourierInv_lineDerivOp_eq, ← smulLeftCLM_ofReal ℂ this]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The inverse Fourier transform of line derivative in direction `m` is given by multiplication of
 `-(2 * π * Complex.I) • (inner ℝ · m)` with the inverse Fourier transform. -/
 theorem fourierInv_lineDerivOp_eq (f : 𝓢'(E, F)) (m : E) :
diff --git a/mathlib4/Mathlib/Analysis/Distribution/TestFunction.lean b/mathlib4/Mathlib/Analysis/Distribution/TestFunction.lean
index 226ca7081..93e58459d 100644
--- a/mathlib4/Mathlib/Analysis/Distribution/TestFunction.lean
+++ b/mathlib4/Mathlib/Analysis/Distribution/TestFunction.lean
@@ -328,7 +328,6 @@ noncomputable def ofSupportedInCLM [SMulCommClass ℝ 𝕜 F] {K : Compacts E}
     (ofSupportedInCLM 𝕜 K_sub_Ω : 𝓓^{n}_{K}(E, F) → 𝓓^{n}(Ω, F)) = ofSupportedIn K_sub_Ω :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The **universal property** of the topology on `𝓓^{n}(Ω, F)`: a **linear** map from
 `𝓓^{n}(Ω, F)` to a locally convex topological vector space is continuous if and only if its
 precomposition with the inclusion `ofSupportedIn K_sub_Ω : 𝓓^{n}_{K}(E, F) → 𝓓^{n}(Ω, F)` is
@@ -628,7 +627,6 @@ noncomputable instance : LineDerivAdd E 𝓓(Ω, F) 𝓓(Ω, F) where
   lineDerivOp_add v := map_add (lineDerivCLM ℝ v)
   lineDerivOp_left_add _ _ f := congr($lineDerivCLM_add f)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance : LineDerivSMul 𝕜 E 𝓓(Ω, F) 𝓓(Ω, F) where
   lineDerivOp_smul v := map_smul (lineDerivCLM 𝕜 v)
 
diff --git a/mathlib4/Mathlib/Analysis/Fourier/BoundedContinuousFunctionChar.lean b/mathlib4/Mathlib/Analysis/Fourier/BoundedContinuousFunctionChar.lean
index 407a0c1b4..508771150 100644
--- a/mathlib4/Mathlib/Analysis/Fourier/BoundedContinuousFunctionChar.lean
+++ b/mathlib4/Mathlib/Analysis/Fourier/BoundedContinuousFunctionChar.lean
@@ -77,7 +77,6 @@ lemma char_add_eq_mul (x y : W) :
 lemma char_neg (w : W) :
     char he hL (-w) = star (char he hL w) := by ext; simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `e` and `L` are non-trivial, then `char he hL w, w : W` separates points in `V`. -/
 theorem ext_of_char_eq (he : Continuous e) (he' : e ≠ 1)
diff --git a/mathlib4/Mathlib/Analysis/Fourier/FiniteAbelian/PontryaginDuality.lean b/mathlib4/Mathlib/Analysis/Fourier/FiniteAbelian/PontryaginDuality.lean
index a19b94fa7..06f1e15d1 100644
--- a/mathlib4/Mathlib/Analysis/Fourier/FiniteAbelian/PontryaginDuality.lean
+++ b/mathlib4/Mathlib/Analysis/Fourier/FiniteAbelian/PontryaginDuality.lean
@@ -152,7 +152,6 @@ lemma forall_apply_eq_zero : (∀ ψ : AddChar α ℂ, ψ a = 1) ↔ a = 0 := by
   simpa using exists_apply_ne_zero.not
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma doubleDualEmb_injective : Injective (doubleDualEmb : α → AddChar (AddChar α ℂ) ℂ) :=
   doubleDualEmb.ker_eq_bot_iff.1 <| eq_bot_iff.2 fun a ha ↦
     forall_apply_eq_zero.1 fun ψ ↦ by simpa using! DFunLike.congr_fun ha (Additive.ofMul ψ)
diff --git a/mathlib4/Mathlib/Analysis/Fourier/FourierTransformDeriv.lean b/mathlib4/Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
index 38d7bfe74..0a07d0093 100644
--- a/mathlib4/Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
+++ b/mathlib4/Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
@@ -760,7 +760,6 @@ lemma pow_mul_norm_iteratedFDeriv_fourier_le
   gcongr
   exact norm_innerSL_le _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma hasDerivAt_fourier
     {f : ℝ → E} (hf : Integrable f) (hf' : Integrable (fun x : ℝ ↦ x • f x)) (w : ℝ) :
     HasDerivAt (𝓕 f) (𝓕 (fun x : ℝ ↦ (-2 * π * I * x) • f x) w) w := by
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
index e25b8ee03..377bc37f5 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Adjoint.lean
@@ -267,7 +267,6 @@ instance : StarRing (E →L[𝕜] E) :=
   ⟨map_add adjoint⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : StarModule 𝕜 (E →L[𝕜] E) :=
   ⟨map_smulₛₗ adjoint⟩
 
@@ -715,7 +714,6 @@ instance : StarRing (E →ₗ[𝕜] E) :=
   ⟨map_add adjoint⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : StarModule 𝕜 (E →ₗ[𝕜] E) :=
   ⟨map_smulₛₗ adjoint⟩
 
@@ -923,7 +921,6 @@ theorem conjStarAlgEquiv_trans {G : Type*} [NormedAddCommGroup G] [InnerProductS
     [CompleteSpace G] (e : H ≃ₗᵢ[𝕜] K) (f : K ≃ₗᵢ[𝕜] G) :
     (e.trans f).conjStarAlgEquiv = e.conjStarAlgEquiv.trans f.conjStarAlgEquiv := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open ContinuousLinearEquiv ContinuousLinearMap in
 theorem conjStarAlgEquiv_ext_iff (f g : H ≃ₗᵢ[𝕜] K) :
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Basic.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Basic.lean
index d2bd50b21..df294ad3a 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Basic.lean
@@ -874,7 +874,6 @@ section Induced
 variable {G : Type*} [SeminormedAddCommGroup E] [InnerProductSpace 𝕜 E] [AddCommGroup G]
     [Module 𝕜 G]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear map from a `Module` to an `InnerProductSpace` induces an `InnerProductSpace`
 structure on the domain using the `SeminormedAddCommGroup.induced` norm.
 
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Coalgebra.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Coalgebra.lean
index eff1a9519..a4e67bc0f 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Coalgebra.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Coalgebra.lean
@@ -138,7 +138,6 @@ noncomputable abbrev ringOfCoalgebra :
       adjoint_toLinearMap_eq_symm]
     exact one_smul _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] InnerProductSpace.ringOfCoalgebra in
 /-- A finite-dimensional inner product space with a coalgebra structure induces an algebra
 structure, where `x * y = (adjoint comul) (x ⊗ₜ y)`, `1 = (adjoint counit) 1` and
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Dual.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Dual.lean
index 03ee4e4f0..03916c4cf 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Dual.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Dual.lean
@@ -129,7 +129,6 @@ theorem ext_inner_right_basis {ι : Type*} {x y : E} (b : Basis ι 𝕜 E)
 variable (𝕜) (E)
 variable [CompleteSpace E]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- **Fréchet-Riesz representation**: any `ℓ` in the dual of a Hilbert space `E` is of the form
 `fun u => ⟪y, u⟫` for some `y : E`, i.e. `toDualMap` is surjective.
 -/
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearMap.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearMap.lean
index 8e676b6a0..16e5a58b1 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearMap.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearMap.lean
@@ -49,7 +49,6 @@ section Complex_Seminormed
 
 variable {V : Type*} [SeminormedAddCommGroup V] [InnerProductSpace ℂ V]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A complex polarization identity, with a linear map. -/
 theorem inner_map_polarization (T : V →ₗ[ℂ] V) (x y : V) :
@@ -63,7 +62,6 @@ theorem inner_map_polarization (T : V →ₗ[ℂ] V) (x y : V) :
     mul_add, ← mul_assoc, mul_neg, neg_neg, one_mul, neg_one_mul, mul_sub, sub_sub]
   ring
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem inner_map_polarization' (T : V →ₗ[ℂ] V) (x y : V) :
     ⟪T x, y⟫_ℂ =
@@ -111,7 +109,6 @@ variable {ι : Type*} {ι' : Type*} {ι'' : Type*}
 variable {E' : Type*} [SeminormedAddCommGroup E'] [InnerProductSpace 𝕜 E']
 variable {E'' : Type*} [SeminormedAddCommGroup E''] [InnerProductSpace 𝕜 E'']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A linear isometry preserves the inner product. -/
 @[simp]
@@ -284,7 +281,6 @@ theorem ContinuousLinearMap.reApplyInnerSelf_continuous (T : E →L[𝕜] E) :
     Continuous T.reApplyInnerSelf :=
   reCLM.continuous.comp <| T.continuous.inner continuous_id
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem ContinuousLinearMap.reApplyInnerSelf_smul (T : E →L[𝕜] E) (x : E) {c : 𝕜} :
     T.reApplyInnerSelf (c • x) = ‖c‖ ^ 2 * T.reApplyInnerSelf x := by
@@ -364,7 +360,6 @@ variable {F H : Type*} [NormedAddCommGroup F] [InnerProductSpace 𝕜 F]
 lemma rankOne_ne_zero {x : E} {y : F} (hx : x ≠ 0) (hy : y ≠ 0) : rankOne 𝕜 x y ≠ 0 := by
   grind [rankOne_eq_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem isIdempotentElem_rankOne_self_iff {x : F} (hx : x ≠ 0) :
     IsIdempotentElem (rankOne 𝕜 x x) ↔ ‖x‖ = 1 := by
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearPMap.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
index 5e303b9d6..02fc27ba5 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
@@ -235,7 +235,6 @@ variable {A : E →ₗ.[𝕜] E}
 theorem isSelfAdjoint_def : IsSelfAdjoint A ↔ A† = A := Iff.rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Every self-adjoint `LinearPMap` has dense domain.
 
 This is not true by definition since we define the adjoint without the assumption that the
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/NormDet.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/NormDet.lean
index 3ee5f9199..4647f2e64 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/NormDet.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/NormDet.lean
@@ -238,7 +238,6 @@ theorem normDet_zero : (0 : U →ₗ[𝕜] V).normDet = 0 ^ finrank 𝕜 U := by
   nontriviality U
   simp [zero_pow finrank_pos.ne.symm, normDet_eq_zero_iff_ker_ne_bot]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem normDet_smul (f : U →ₗ[𝕜] V) (c : 𝕜) :
     (c • f).normDet = ‖c‖ ^ finrank 𝕜 U * f.normDet := by
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/OfNorm.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/OfNorm.lean
index 81a290d1c..b68ffaac4 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/OfNorm.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/OfNorm.lean
@@ -159,7 +159,6 @@ theorem add_left (x y z : E) : inner_ 𝕜 (x + y) z = inner_ 𝕜 x z + inner_
   abel_nf at * -- TODO this should be `module_nf` (then the `smul_add` above can go)
   linear_combination (- h1 + h2 + h3 - h4 + I * (- h5 + h6 + h7 - h8)) / 8
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
   intro x y
   let hom : 𝕜 →ₗ[ℚ] 𝕜 := AddMonoidHom.toRatLinearMap <|
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/PiL2.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/PiL2.lean
index 36800d9bf..c5ee7fd29 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/PiL2.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/PiL2.lean
@@ -403,7 +403,6 @@ theorem repr_injective :
   cases g
   congr
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `b i` is the `i`th basis vector. -/
 instance instFunLike : FunLike (OrthonormalBasis ι 𝕜 E) ι E where
@@ -422,7 +421,6 @@ instance instFunLike : FunLike (OrthonormalBasis ι 𝕜 E) ι E where
           LinearIsometryEquiv.coe_symm_toLinearEquiv] at h ⊢
         rw [h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_ofRepr [DecidableEq ι] (e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι) :
     ⇑(OrthonormalBasis.ofRepr e) = fun i => e.symm (EuclideanSpace.single i (1 : 𝕜)) := by
@@ -430,27 +428,23 @@ theorem coe_ofRepr [DecidableEq ι] (e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 
   funext
   congr!
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem repr_symm_single [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     b.repr.symm (EuclideanSpace.single i (1 : 𝕜)) = b i := by
   dsimp only [DFunLike.coe]
   congr!
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem repr_self [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     b.repr (b i) = EuclideanSpace.single i (1 : 𝕜) := by
   rw [← b.repr_symm_single i, LinearIsometryEquiv.apply_symm_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem repr_apply_apply (b : OrthonormalBasis ι 𝕜 E) (v : E) (i : ι) :
     b.repr v i = ⟪b i, v⟫ := by
   classical
     rw [← b.repr.inner_map_map (b i) v, b.repr_self i, EuclideanSpace.inner_single_left]
     simp only [one_mul, map_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem orthonormal (b : OrthonormalBasis ι 𝕜 E) : Orthonormal 𝕜 b := by
   classical
@@ -459,31 +453,25 @@ protected theorem orthonormal (b : OrthonormalBasis ι 𝕜 E) : Orthonormal 
     rw [← b.repr.inner_map_map (b i) (b j), b.repr_self i, b.repr_self j,
       EuclideanSpace.inner_single_left, PiLp.single_apply, map_one, one_mul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma norm_eq_one (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     ‖b i‖ = 1 := b.orthonormal.norm_eq_one i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma nnnorm_eq_one (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     ‖b i‖₊ = 1 := b.orthonormal.nnnorm_eq_one i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma enorm_eq_one (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
     ‖b i‖ₑ = 1 := b.orthonormal.enorm_eq_one i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma inner_eq_zero (b : OrthonormalBasis ι 𝕜 E) {i j : ι} (hij : i ≠ j) :
     ⟪b i, b j⟫ = 0 := b.orthonormal.inner_eq_zero hij
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma inner_eq_one (b : OrthonormalBasis ι 𝕜 E) (i : ι) : ⟪b i, b i⟫ = 1 := by
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma inner_eq_ite [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i j : ι) :
     ⟪b i, b j⟫ = if i = j then 1 else 0 := by
   by_cases h : i = j <;> simp [h]
@@ -492,7 +480,6 @@ lemma inner_eq_ite [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i j : ι)
 protected def toBasis (b : OrthonormalBasis ι 𝕜 E) : Basis ι 𝕜 E :=
   Basis.ofEquivFun (b.repr.toLinearEquiv.trans (WithLp.linearEquiv 2 𝕜 (ι → 𝕜)))
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem coe_toBasis (b : OrthonormalBasis ι 𝕜 E) : (⇑b.toBasis : ι → E) = ⇑b := rfl
 
@@ -506,22 +493,18 @@ protected theorem coe_toBasis_repr_apply (b : OrthonormalBasis ι 𝕜 E) (x : E
     b.toBasis.repr x i = b.repr x i := by
   simp [← Basis.equivFun_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem sum_repr (b : OrthonormalBasis ι 𝕜 E) (x : E) : ∑ i, b.repr x i • b i = x := by
   simp_rw [← b.coe_toBasis_repr_apply, ← b.coe_toBasis]
   exact b.toBasis.sum_repr x
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped InnerProductSpace in
 protected theorem sum_repr' (b : OrthonormalBasis ι 𝕜 E) (x : E) : ∑ i, ⟪b i, x⟫_𝕜 • b i = x := by
   nth_rw 2 [← (b.sum_repr x)]
   simp_rw [b.repr_apply_apply x]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem sum_repr_symm (b : OrthonormalBasis ι 𝕜 E) (v : EuclideanSpace 𝕜 ι) :
     ∑ i, v i • b i = b.repr.symm v := by simpa using (b.toBasis.equivFun_symm_apply v).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem sum_inner_mul_inner (b : OrthonormalBasis ι 𝕜 E) (x y : E) :
     ∑ i, ⟪x, b i⟫ * ⟪b i, y⟫ = ⟪x, y⟫ := by
   have := congr_arg (innerSL 𝕜 x) (b.sum_repr y)
@@ -530,7 +513,6 @@ protected theorem sum_inner_mul_inner (b : OrthonormalBasis ι 𝕜 E) (x y : E)
   rw [map_smul, b.repr_apply_apply, mul_comm]
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma sum_sq_norm_inner_right (b : OrthonormalBasis ι 𝕜 E) (x : E) :
     ∑ i, ‖⟪b i, x⟫‖ ^ 2 = ‖x‖ ^ 2 := by
   rw [@norm_eq_sqrt_re_inner 𝕜, ← OrthonormalBasis.sum_inner_mul_inner b x x, map_sum]
@@ -539,13 +521,11 @@ lemma sum_sq_norm_inner_right (b : OrthonormalBasis ι 𝕜 E) (x : E) :
   rw [Real.sq_sqrt]
   exact Fintype.sum_nonneg fun _ ↦ by positivity
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma sum_sq_norm_inner_left (b : OrthonormalBasis ι 𝕜 E) (x : E) :
     ∑ i, ‖⟪x, b i⟫‖ ^ 2 = ‖x‖ ^ 2 := by
   convert! sum_sq_norm_inner_right b x using 2 with i -
   rw [← inner_conj_symm, RCLike.norm_conj]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped RealInnerProductSpace in
 theorem sum_sq_inner_right {E : Type*} [NormedAddCommGroup E]
     [InnerProductSpace ℝ E] (b : OrthonormalBasis ι ℝ E) (x : E) :
@@ -553,14 +533,12 @@ theorem sum_sq_inner_right {E : Type*} [NormedAddCommGroup E]
   rw [← b.sum_sq_norm_inner_right]
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped RealInnerProductSpace in
 theorem sum_sq_inner_left {ι E : Type*} [NormedAddCommGroup E]
     [InnerProductSpace ℝ E] [Fintype ι] (b : OrthonormalBasis ι ℝ E) (x : E) :
     ∑ i : ι, ⟪x, b i⟫ ^ 2 = ‖x‖ ^ 2 := by
   simp_rw [← b.sum_sq_inner_right, real_inner_comm]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma norm_le_card_mul_iSup_norm_inner (b : OrthonormalBasis ι 𝕜 E) (x : E) :
     ‖x‖ ≤ √(Fintype.card ι) * ⨆ i, ‖⟪b i, x⟫‖ := by
   calc ‖x‖
@@ -576,14 +554,12 @@ lemma norm_le_card_mul_iSup_norm_inner (b : OrthonormalBasis ι 𝕜 E) (x : E)
     · simp
     · exact le_ciSup_of_le (by simp) (Nonempty.some inferInstance) (by positivity)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem orthogonalProjectionOnto_apply_eq_sum {U : Submodule 𝕜 E}
     [U.HasOrthogonalProjection] (b : OrthonormalBasis ι 𝕜 U) (x : E) :
     U.orthogonalProjectionOnto x = ∑ i, ⟪(b i : E), x⟫ • b i := by
   simpa only [b.repr_apply_apply, inner_orthogonalProjectionOnto_eq_of_mem_left] using
     (b.sum_repr (U.orthogonalProjectionOnto x)).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[deprecated (since := "2026-05-05")] alias orthogonalProjection_apply_eq_sum :=
   OrthonormalBasis.orthogonalProjectionOnto_apply_eq_sum
 
@@ -593,7 +569,6 @@ protected theorem orthogonalProjectionOnto_eq_sum_rankOne {U : Submodule 𝕜 E}
     U.orthogonalProjectionOnto = ∑ i, InnerProductSpace.rankOne 𝕜 (b i) (b i : E) := by
   ext; simp [b.orthogonalProjectionOnto_apply_eq_sum]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[deprecated (since := "2026-05-05")] alias orthogonalProjection_eq_sum_rankOne :=
   OrthonormalBasis.orthogonalProjectionOnto_eq_sum_rankOne
 
@@ -603,7 +578,6 @@ protected theorem starProjection_eq_sum_rankOne {U : Submodule 𝕜 E} [U.HasOrt
     U.starProjection = ∑ i, InnerProductSpace.rankOne 𝕜 (b i : E) (b i : E) := by
   ext; simp [starProjection, b.orthogonalProjectionOnto_eq_sum_rankOne]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma sum_rankOne_eq_id (b : OrthonormalBasis ι 𝕜 E) :
     ∑ i, InnerProductSpace.rankOne 𝕜 (b i) (b i) = .id 𝕜 E := by ext; simp [b.sum_repr']
 
@@ -612,13 +586,11 @@ protected def map {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
     (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) : OrthonormalBasis ι 𝕜 G where
   repr := L.symm.trans b.repr
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem map_apply {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
     (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) (i : ι) : b.map L i = L (b i) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma coe_map {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
     (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) : ⇑(b.map L) = L ∘ b := rfl
 
@@ -663,7 +635,6 @@ theorem _root_.Module.Basis.toBasis_toOrthonormalBasis (v : Basis ι 𝕜 E) (hv
     LinearEquiv.isometryOfInner_toLinearEquiv]
   exact v.ofEquivFun_equivFun
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem _root_.Module.Basis.coe_toOrthonormalBasis (v : Basis ι 𝕜 E) (hv : Orthonormal 𝕜 v) :
     (v.toOrthonormalBasis hv : ι → E) = (v : ι → E) :=
@@ -681,7 +652,6 @@ variable (ι 𝕜) in
 protected noncomputable def singleton : OrthonormalBasis ι 𝕜 𝕜 :=
   (Basis.singleton ι 𝕜).toOrthonormalBasis (by simp)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem singleton_apply (i) : OrthonormalBasis.singleton ι 𝕜 i = 1 := Basis.singleton_apply _ _ _
 
@@ -689,7 +659,6 @@ theorem singleton_apply (i) : OrthonormalBasis.singleton ι 𝕜 i = 1 := Basis.
 theorem singleton_repr (x i) : (OrthonormalBasis.singleton ι 𝕜).repr x i = x :=
   Basis.singleton_repr _ _ _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_singleton : ⇑(OrthonormalBasis.singleton ι 𝕜) = 1 := by
   ext; simp
@@ -716,7 +685,6 @@ theorem _root_.Pi.orthonormalBasis.toBasis {η : Type*} [Fintype η] {ι : η 
     (Pi.orthonormalBasis B).toBasis =
       ((Pi.basis fun i : η ↦ (B i).toBasis).map (WithLp.linearEquiv 2 _ _).symm) := by ext; rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem _root_.Pi.orthonormalBasis_apply {η : Type*} [Fintype η] [DecidableEq η] {ι : η → Type*}
     [∀ i, Fintype (ι i)] {𝕜 : Type*} [RCLike 𝕜] {E : η → Type*} [∀ i, NormedAddCommGroup (E i)]
@@ -749,7 +717,6 @@ protected def mk (hon : Orthonormal 𝕜 v) (hsp : ⊤ ≤ Submodule.span 𝕜 (
     OrthonormalBasis ι 𝕜 E :=
   (Basis.mk (Orthonormal.linearIndependent hon) hsp).toOrthonormalBasis (by rwa [Basis.coe_mk])
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem coe_mk (hon : Orthonormal 𝕜 v) (hsp : ⊤ ≤ Submodule.span 𝕜 (Set.range v)) :
     ⇑(OrthonormalBasis.mk hon hsp) = v := by
@@ -773,7 +740,6 @@ protected def span [DecidableEq E] {v' : ι' → E} (h : Orthonormal 𝕜 v') (s
         rfl)
   e₀.map φ.symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem span_apply [DecidableEq E] {v' : ι' → E} (h : Orthonormal 𝕜 v') (s : Finset ι')
     (i : s) : (OrthonormalBasis.span h s i : E) = v' i := by
@@ -795,7 +761,6 @@ protected def mkOfOrthogonalEqBot (hon : Orthonormal 𝕜 v) (hsp : (span 𝕜 (
       have : CompleteSpace (span 𝕜 (range v)) := FiniteDimensional.complete 𝕜 _
       rwa [orthogonal_eq_bot_iff] at hsp)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem coe_of_orthogonal_eq_bot_mk (hon : Orthonormal 𝕜 v)
     (hsp : (span 𝕜 (Set.range v))ᗮ = ⊥) : ⇑(OrthonormalBasis.mkOfOrthogonalEqBot hon hsp) = v :=
@@ -807,7 +772,6 @@ variable [Fintype ι']
 def reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') : OrthonormalBasis ι' 𝕜 E :=
   OrthonormalBasis.ofRepr (b.repr.trans (LinearIsometryEquiv.piLpCongrLeft 2 𝕜 𝕜 e))
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem reindex_apply (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') (i' : ι') :
     (b.reindex e) i' = b (e.symm i') := by
   classical
@@ -821,13 +785,11 @@ protected theorem reindex_apply (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι'
 theorem reindex_toBasis (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') :
     (b.reindex e).toBasis = b.toBasis.reindex e := Basis.eq_ofRepr_eq_repr fun _ ↦ congr_fun rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem coe_reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') :
     ⇑(b.reindex e) = b ∘ e.symm :=
   funext (b.reindex_apply e)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 protected theorem repr_reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') (x : E) (i' : ι') :
     (b.reindex e).repr x i' = b.repr x (e.symm i') := by
@@ -844,7 +806,6 @@ variable (𝕜 ι)
 noncomputable def basisFun : OrthonormalBasis ι 𝕜 (EuclideanSpace 𝕜 ι) :=
   ⟨LinearIsometryEquiv.refl _ _⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem basisFun_apply [DecidableEq ι] (i : ι) : basisFun ι 𝕜 i = EuclideanSpace.single i 1 :=
   PiLp.basisFun_apply _ _ _ _
@@ -852,12 +813,10 @@ theorem basisFun_apply [DecidableEq ι] (i : ι) : basisFun ι 𝕜 i = Euclidea
 @[simp]
 theorem basisFun_repr (x : EuclideanSpace 𝕜 ι) (i : ι) : (basisFun ι 𝕜).repr x i = x i := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem basisFun_inner (x : EuclideanSpace 𝕜 ι) (i : ι) : ⟪basisFun ι 𝕜 i, x⟫ = x i := by
   simp [← OrthonormalBasis.repr_apply_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem inner_basisFun_real (x : EuclideanSpace ℝ ι) (i : ι) :
     inner ℝ x (basisFun ι ℝ i) = x i := by
@@ -885,7 +844,6 @@ lemma equiv_symm : (b.equiv b' e).symm = b'.equiv b e.symm := by
   apply b'.toBasis.ext_linearIsometryEquiv
   simp [OrthonormalBasis.equiv]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma equiv_apply_basis (i : ι) : b.equiv b' e (b i) = b' (e i) := by
   classical
@@ -894,24 +852,20 @@ lemma equiv_apply_basis (i : ι) : b.equiv b' e (b i) = b' (e i) := by
   ext j
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma equiv_self_rfl : b.equiv b (.refl ι) = .refl 𝕜 E := by
   apply b.toBasis.ext_linearIsometryEquiv
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma equiv_apply (x : E) : b.equiv b' e x = ∑ i, b.repr x i • b' (e i) := by
   nth_rw 1 [← b.sum_repr x, map_sum]
   simp_rw [map_smul, equiv_apply_basis]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma equiv_apply_euclideanSpace (x : EuclideanSpace 𝕜 ι) :
     (EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι) x = ∑ i, x i • b i := by
   simp_rw [equiv_apply, EuclideanSpace.basisFun_repr, Equiv.refl_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma coe_equiv_euclideanSpace :
     ⇑((EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι)) = fun x ↦ ∑ i, x i • b i := by
   simp_rw [← equiv_apply_euclideanSpace]
@@ -942,7 +896,6 @@ theorem Complex.toBasis_orthonormalBasisOneI :
     Complex.orthonormalBasisOneI.toBasis = Complex.basisOneI :=
   Basis.toBasis_toOrthonormalBasis _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem Complex.coe_orthonormalBasisOneI :
     (Complex.orthonormalBasisOneI : Fin 2 → ℂ) = ![1, I] := by
@@ -965,7 +918,6 @@ theorem Complex.isometryOfOrthonormal_symm_apply (v : OrthonormalBasis (Fin 2) 
       (v.toBasis.coord 0 f : ℂ) + (v.toBasis.coord 1 f : ℂ) * I := by
   simp [Complex.isometryOfOrthonormal]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Complex.isometryOfOrthonormal_apply (v : OrthonormalBasis (Fin 2) ℝ F) (z : ℂ) :
     Complex.isometryOfOrthonormal v z = z.re • v 0 + z.im • v 1 := by
   simp [Complex.isometryOfOrthonormal, ← v.sum_repr_symm]
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Positive.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Positive.lean
index f216d8bb3..578903d59 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Positive.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Positive.lean
@@ -539,7 +539,6 @@ theorem LinearMap.IsPositive.toLinearMap_symm {T : E ≃ₗ[𝕜] E} (hT : T.IsP
     inner_smul_left, RCLike.conj_mul, ← RCLike.ofReal_pow, RCLike.ofReal_nonneg]
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- In finite-dimensional spaces, a continuous linear map is positive iff it is equal to the sum
 of rank-one positive operators. -/
 theorem ContinuousLinearMap.isPositive_iff_eq_sum_rankOne [FiniteDimensional 𝕜 E] {T : E →L[𝕜] E} :
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/ProdL2.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/ProdL2.lean
index 61317299f..8bbdea5db 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/ProdL2.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/ProdL2.lean
@@ -140,7 +140,6 @@ theorem sndL_comp_coe_orthogonalDecomposition :
   ext; simp
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a subspace `K` of an inner product space `E` admits an orthogonal projection, then the
 quotient `E ⧸ K` is isometrically isomorphic to the orthogonal complement `Kᗮ` of `K`. -/
 def quotientEquivOrthogonal : (E ⧸ K) ≃ₗᵢ[𝕜] ↥Kᗮ where
@@ -157,40 +156,34 @@ def quotientEquivOrthogonal : (E ⧸ K) ≃ₗᵢ[𝕜] ↥Kᗮ where
       simp
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_quotientEquivOrthogonal :
     ⇑K.quotientEquivOrthogonal = K.quotientEquivOfIsCompl Kᗮ K.isCompl_orthogonal :=
   rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_quotientEquivOrthogonal_symm :
     ⇑K.quotientEquivOrthogonal.symm = (K.quotientEquivOfIsCompl Kᗮ K.isCompl_orthogonal).symm :=
   rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma toLinearEquiv_quotientEquivOrthogonal :
     (quotientEquivOrthogonal K).toLinearEquiv = K.quotientEquivOfIsCompl _ K.isCompl_orthogonal :=
   rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem quotientEquivOrthogonal_mk (x : E) (hx : x ∈ Kᗮ) :
     K.quotientEquivOrthogonal (Quotient.mk x) = ⟨x, hx⟩ := by
   simp [← K.quotientEquivOfIsCompl_apply_mk_right K.isCompl_orthogonal ⟨x, hx⟩]
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem quotientEquivOrthogonal_symm_eq_mk (x : E) (hx : x ∈ Kᗮ) :
     K.quotientEquivOrthogonal.symm ⟨x, hx⟩ = Quotient.mk x := by
   simp
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance instQuotientInnerProductSpace :
     InnerProductSpace 𝕜 (E ⧸ K) where
   inner x y := ⟪K.quotientEquivOrthogonal x, K.quotientEquivOrthogonal y⟫_𝕜
@@ -200,14 +193,12 @@ noncomputable instance instQuotientInnerProductSpace :
   norm_sq_eq_re_inner y := by rw [inner_self_eq_norm_sq, LinearIsometryEquiv.norm_map]
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem inner_quotient_eq (x y : E ⧸ K) :
     ⟪x, y⟫_𝕜 = ⟪K.quotientEquivOrthogonal x, K.quotientEquivOrthogonal y⟫_𝕜 :=
   rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Quotient.inner_mk_mk (x y : E) (hx : x ∈ Kᗮ) (hy : y ∈ Kᗮ) :
     ⟪Quotient.mk (p := K) x, Quotient.mk y⟫_𝕜 = ⟪x, y⟫_𝕜 := by
   simp [K.quotientEquivOrthogonal_mk x hx, K.quotientEquivOrthogonal_mk y hy]
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Reproducing.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Reproducing.lean
index f57eb9995..ae5f04b69 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Reproducing.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Reproducing.lean
@@ -312,7 +312,6 @@ private abbrev kerFun (x : X) :
     _ ≤ ‖K x x‖ * ‖v‖ * ‖v‖ := by simp [mul_le_mul_of_nonneg_right, le_opNorm]
     _ ≤ _ := by simp [mul_pow, mul_assoc, ← sq]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[no_expose]
 instance instRKHS : RKHS 𝕜 (OfKernel K) X V where
   coeCLM := .pi fun x ↦ (OfKernel.kerFun K x).adjoint
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Spectrum.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Spectrum.lean
index 61fe9c691..b6eaae80d 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Spectrum.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Spectrum.lean
@@ -326,7 +326,6 @@ theorem apply_eigenvectorBasis (hT : T.IsSymmetric) (hn : Module.finrank 𝕜 E
     T (hT.eigenvectorBasis hn i) = (hT.eigenvalues hn i : 𝕜) • hT.eigenvectorBasis hn i :=
   mem_eigenspace_iff.mp (hT.hasEigenvector_eigenvectorBasis hn i).1
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- *Diagonalization theorem*, *spectral theorem*; version 2: A self-adjoint operator `T` on a
 finite-dimensional inner product space `E` acts diagonally on the identification of `E` with
 Euclidean space induced by an orthonormal basis of eigenvectors of `T`. -/
@@ -347,7 +346,6 @@ theorem eigenvectorBasis_apply_self_apply (hT : T.IsSymmetric) (hn : Module.finr
   intro a
   rw [smul_smul, mul_comm, ofLp_toLp]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toMatrix_eigenvectorBasis (hT : T.IsSymmetric) (hn : Module.finrank 𝕜 E = n) :
     letI b := (hT.eigenvectorBasis hn).toBasis
     T.toMatrix b b = Matrix.diagonal (RCLike.ofReal ∘ hT.eigenvalues hn) := by
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/Symmetric.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/Symmetric.lean
index b81061c85..b24cdba21 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/Symmetric.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/Symmetric.lean
@@ -195,7 +195,6 @@ theorem isSymmetric_iff_inner_map_self_real (T : V →ₗ[ℂ] V) :
 
 end Complex
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Polarization identity for symmetric linear maps.
 See `inner_map_polarization` for the complex version without the symmetric assumption. -/
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/TwoDim.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/TwoDim.lean
index 9b781ee3a..9e6e5d472 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/TwoDim.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@@ -376,7 +376,6 @@ theorem inner_mul_areaForm_sub' (a x : E) : ⟪a, x⟫ • ω a - ω a x • inn
 theorem inner_mul_areaForm_sub (a x y : E) : ⟪a, x⟫ * ω a y - ω a x * ⟪a, y⟫ = ‖a‖ ^ 2 * ω x y :=
   congr_arg (fun f : E →ₗ[ℝ] ℝ => f y) (o.inner_mul_areaForm_sub' a x)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem nonneg_inner_and_areaForm_eq_zero_iff_sameRay (x y : E) :
     0 ≤ ⟪x, y⟫ ∧ ω x y = 0 ↔ SameRay ℝ x y := by
   by_cases hx : x = 0
diff --git a/mathlib4/Mathlib/Analysis/InnerProductSpace/l2Space.lean b/mathlib4/Mathlib/Analysis/InnerProductSpace/l2Space.lean
index c84ea88e0..e2bc31114 100644
--- a/mathlib4/Mathlib/Analysis/InnerProductSpace/l2Space.lean
+++ b/mathlib4/Mathlib/Analysis/InnerProductSpace/l2Space.lean
@@ -426,7 +426,6 @@ protected theorem orthonormal (b : HilbertBasis ι 𝕜 E) : Orthonormal 𝕜 b
     lp.single_apply, Pi.single_apply]
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem hasSum_repr_symm (b : HilbertBasis ι 𝕜 E) (f : ℓ²(ι, 𝕜)) :
     HasSum (fun i => f i • b i) (b.repr.symm f) := by
   classical
diff --git a/mathlib4/Mathlib/Analysis/LocallyConvex/WeakDual.lean b/mathlib4/Mathlib/Analysis/LocallyConvex/WeakDual.lean
index c66cf0749..881346ba1 100644
--- a/mathlib4/Mathlib/Analysis/LocallyConvex/WeakDual.lean
+++ b/mathlib4/Mathlib/Analysis/LocallyConvex/WeakDual.lean
@@ -130,7 +130,6 @@ section NontriviallyNormedField
 
 variable [NontriviallyNormedField 𝕜] [AddCommGroup E] [Module 𝕜 E]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear functional `φ` is in the span of a collection of linear functionals if and only if `φ`
 is continuous with respect to the topology induced by the collection of linear functionals. See
 `LinearMap.mem_span_iff_continuous_of_finite` for a result about finite collections of linear
diff --git a/mathlib4/Mathlib/Analysis/Matrix/HermitianFunctionalCalculus.lean b/mathlib4/Mathlib/Analysis/Matrix/HermitianFunctionalCalculus.lean
index 7321b6bd9..04202f5a0 100644
--- a/mathlib4/Mathlib/Analysis/Matrix/HermitianFunctionalCalculus.lean
+++ b/mathlib4/Mathlib/Analysis/Matrix/HermitianFunctionalCalculus.lean
@@ -134,7 +134,6 @@ protected noncomputable def cfc (f : ℝ → ℝ) : Matrix n n 𝕜 :=
 
 -- Abuses the `defeq` that `IsSelfAdjoint` and `IsHermitian` coincide.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cfcHom_eq_cfcAux : cfcHom hA.isSelfAdjoint = hA.cfcAux :=
   cfcHom_eq_of_continuous_of_map_id hA hA.cfcAux
     hA.isClosedEmbedding_cfcAux.continuous hA.cfcAux_id
diff --git a/mathlib4/Mathlib/Analysis/Normed/Algebra/Unitization.lean b/mathlib4/Mathlib/Analysis/Normed/Algebra/Unitization.lean
index e10f2ca4f..904ae7859 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Algebra/Unitization.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Algebra/Unitization.lean
@@ -238,7 +238,6 @@ noncomputable instance instNormedRing : NormedRing (Unitization 𝕜 A) where
   norm_mul_le := normedRingAux.norm_mul_le
   norm := normedRingAux.norm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Pull back the normed algebra structure from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A` using the
 algebra homomorphism `Unitization.splitMul 𝕜 A`. -/
 instance instNormedAlgebra : NormedAlgebra 𝕜 (Unitization 𝕜 A) where
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/Bases.lean b/mathlib4/Mathlib/Analysis/Normed/Module/Bases.lean
index 9f5bdbf1b..7beeedeb5 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/Bases.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/Bases.lean
@@ -181,7 +181,6 @@ theorem range_proj_eq_span (A : Finset β) :
     use b i
     rw [ContinuousLinearMap.coe_coe, proj_apply_basis_mem, ite_eq_left (Finset.mem_coe.mp hi)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open scoped Classical in
 /-- Composition of projections: `proj A (proj B x) = proj (A ∩ B) x`. -/
@@ -476,7 +475,6 @@ lemma basisCoeff_spec (n : ℕ) (x : X) :
     basisCoeff D n x • D.e n = (succSub D.P n) x :=
   Classical.choose_spec (exists_coeff D n x)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Constructs a Schauder basis from rank one decomposition. -/
 def basis : SchauderBasis 𝕜 X :=
   let coeff := basisCoeff D
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/Basic.lean b/mathlib4/Mathlib/Analysis/Normed/Module/Basic.lean
index 1c01999f9..0511218ab 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/Basic.lean
@@ -179,7 +179,6 @@ instance (priority := 75) SubmoduleClass.toNormedSpace : NormedSpace 𝕜 s wher
 
 end SeminormedAddCommGroup
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear map from a `Module` to a `NormedSpace` induces a `NormedSpace` structure on the
 domain, using the `SeminormedAddCommGroup.induced` norm.
 
@@ -384,7 +383,6 @@ instance MulOpposite.instNormedAlgebra {E : Type*} [SeminormedRing E] [NormedAlg
 
 end NormedAlgebra
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A non-unital algebra homomorphism from an `Algebra` to a `NormedAlgebra` induces a
 `NormedAlgebra` structure on the domain, using the `SeminormedRing.induced` norm.
 
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/FiniteDimension.lean b/mathlib4/Mathlib/Analysis/Normed/Module/FiniteDimension.lean
index 695101b57..ac6832a0b 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/FiniteDimension.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/FiniteDimension.lean
@@ -363,7 +363,6 @@ alias isOpen_setOf_affineIndependent := isOpen_setOfPred_affineIndependent
 
 namespace Module.Basis
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem opNNNorm_le {ι : Type*} [Fintype ι] (v : Basis ι 𝕜 E) {u : E →L[𝕜] F} (M : ℝ≥0)
     (hu : ∀ i, ‖u (v i)‖₊ ≤ M) : ‖u‖₊ ≤ Fintype.card ι • ‖v.equivFunL.toContinuousLinearMap‖₊ * M :=
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean b/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean
index 6e4e7e6d2..c0e45f198 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean
@@ -101,7 +101,6 @@ theorem injectiveSeminorm_apply (x : ⨂[𝕜] i, E i) :
   simpa only [injectiveSeminorm, Set.coe_ofPred, Set.mem_ofPred_eq]
     using Seminorm.sSup_apply dualSeminorms_bounded
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 attribute [-instance] instSeminormedAddCommGroup in
 @[deprecated
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/ProjectiveSeminorm.lean b/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/ProjectiveSeminorm.lean
index b09dd22dd..4e81a007e 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/ProjectiveSeminorm.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/PiTensorProduct/ProjectiveSeminorm.lean
@@ -160,7 +160,6 @@ variable {F : Type*} [SeminormedAddCommGroup F] [NormedSpace 𝕜 F]
 
 variable (𝕜 E F)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The linear equivalence between `ContinuousMultilinearMap 𝕜 E F` and `(⨂[𝕜] i, Eᵢ) →L[𝕜] F`
 induced by `PiTensorProduct.lift`, for every normed space `F`.
 -/
diff --git a/mathlib4/Mathlib/Analysis/Normed/Module/RCLike/Basic.lean b/mathlib4/Mathlib/Analysis/Normed/Module/RCLike/Basic.lean
index 489633581..795450081 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Module/RCLike/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Module/RCLike/Basic.lean
@@ -59,7 +59,6 @@ theorem ContinuousLinearEquiv.coord_norm' {x : E} (h : x ≠ 0) :
 
 @[deprecated (since := "2026-02-01")] alias coord_norm' := ContinuousLinearEquiv.coord_norm'
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem LinearMap.bound_of_sphere_bound {r : ℝ} (r_pos : 0 < r) (c : ℝ) (f : E →ₗ[𝕜] 𝕜)
     (h : ∀ z ∈ sphere (0 : E) r, ‖f z‖ ≤ c) (z : E) : ‖f z‖ ≤ c / r * ‖z‖ := by
   by_cases z_zero : z = 0
diff --git a/mathlib4/Mathlib/Analysis/Normed/Operator/Compact/FredholmAlternative.lean b/mathlib4/Mathlib/Analysis/Normed/Operator/Compact/FredholmAlternative.lean
index 7f18b3f4f..690de19e3 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Operator/Compact/FredholmAlternative.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Operator/Compact/FredholmAlternative.lean
@@ -45,7 +45,6 @@ variable {T : X →L[𝕜] X} {μ : 𝕜}
 
 open Module End
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open Filter Topology in
 /-- If `T : X →L[𝕜] X` is a compact operator on a Banach space `X`, and `μ ≠ 0` is not an
 eigenvalue of `T`, then `T - μ • 1` is antilipschitz with positive constant.
diff --git a/mathlib4/Mathlib/Analysis/Normed/Operator/Extend.lean b/mathlib4/Mathlib/Analysis/Normed/Operator/Extend.lean
index 7d9f8ba3e..993ea9b00 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Operator/Extend.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Operator/Extend.lean
@@ -52,7 +52,6 @@ variable [AddCommGroup E] [UniformSpace E] [IsUniformAddGroup E]
   [ContinuousConstSMul 𝕜 Eₗ] [ContinuousConstSMul 𝕜₂ F]
   {σ₁₂ : 𝕜 →+* 𝕜₂} (f g : E →SL[σ₁₂] F) [CompleteSpace F] (e : E →L[𝕜] Eₗ)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped Classical in
 /-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
 complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Eₗ`. -/
diff --git a/mathlib4/Mathlib/Analysis/Normed/Unbundled/FiniteExtension.lean b/mathlib4/Mathlib/Analysis/Normed/Unbundled/FiniteExtension.lean
index 565c0ec6a..34ff6715a 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Unbundled/FiniteExtension.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Unbundled/FiniteExtension.lean
@@ -97,7 +97,6 @@ theorem norm_isNonarchimedean (hna : IsNonarchimedean (Norm.norm : K → ℝ)) :
   · exact le_max_of_le_left (le_trans hx (norm_repr_le_norm B ixy))
   · exact le_max_of_le_right (le_trans hy (norm_repr_le_norm B ixy))
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- For any `K`-basis of `L`, `B.norm` is bounded with respect to multiplication. That is,
   `∃ (c : ℝ), c > 0` such that ` ∀ (x y : L), B.norm (x * y) ≤ c * B.norm x * B.norm y`. -/
diff --git a/mathlib4/Mathlib/Analysis/Normed/Unbundled/InvariantExtension.lean b/mathlib4/Mathlib/Analysis/Normed/Unbundled/InvariantExtension.lean
index 51b9b47b6..5913651c6 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Unbundled/InvariantExtension.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Unbundled/InvariantExtension.lean
@@ -52,7 +52,6 @@ namespace IsUltrametricDist
 section algNormOfAlgEquiv
 
 set_option linter.style.whitespace false in -- manual alignment is not recognised
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a normed field `K`, a finite algebraic extension `L/K` and `σ : L ≃ₐ[K] L`, the function
 `L → ℝ` sending `x : L` to `‖ σ x ‖`, where `‖ ⬝ ‖` is any power-multiplicative algebra norm on `L`
 extending the norm on `K`, is an algebra norm on `K`. -/
@@ -67,13 +66,11 @@ def algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
   smul' x y   := by simp [map_smul σ, map_smul_eq_mul]
   eq_zero_of_map_eq_zero' x hx := EmbeddingLike.map_eq_zero_iff.mp (eq_zero_of_map_eq_zero _ hx)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem algNormOfAlgEquiv_apply (σ : L ≃ₐ[K] L) (x : L) :
     algNormOfAlgEquiv σ x =
       Classical.choose (exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional h_fin
         hu.isNonarchimedean_norm) (σ x) := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The algebra norm `algNormOfAlgEquiv` is power-multiplicative. -/
 theorem isPowMul_algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
     IsPowMul (algNormOfAlgEquiv σ) := by
@@ -82,7 +79,6 @@ theorem isPowMul_algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
   exact (Classical.choose_spec (exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional
     h_fin hu.isNonarchimedean_norm)).1 _ hn
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The algebra norm `algNormOfAlgEquiv` is nonarchimedean. -/
 theorem isNonarchimedean_algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
     IsNonarchimedean (algNormOfAlgEquiv σ) := by
@@ -91,7 +87,6 @@ theorem isNonarchimedean_algNormOfAlgEquiv (σ : L ≃ₐ[K] L) :
   exact (Classical.choose_spec (exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional
     h_fin hu.isNonarchimedean_norm)).2.2 _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The algebra norm `algNormOfAlgEquiv` extends the norm on `K`. -/
 theorem algNormOfAlgEquiv_extends (σ : L ≃ₐ[K] L) (x : K) :
     (algNormOfAlgEquiv σ) ((algebraMap K L) x) = ‖x‖ := by
diff --git a/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean b/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
index 214b4416c..bbe74f3ee 100644
--- a/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
+++ b/mathlib4/Mathlib/Analysis/Normed/Unbundled/SpectralNorm.lean
@@ -696,7 +696,6 @@ variable {K : Type u} [NontriviallyNormedField K] {L : Type v} [Field L] [Algebr
 private def myId {α : Sort u} (a : α) : α :=
   a
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `K` is a field complete with respect to a nontrivial nonarchimedean multiplicative norm and
   `L/K` is an algebraic extension, then any power-multiplicative `K`-algebra norm on `L` coincides
   with the spectral norm. -/
diff --git a/mathlib4/Mathlib/Analysis/RCLike/Basic.lean b/mathlib4/Mathlib/Analysis/RCLike/Basic.lean
index b1124a64b..6dfc89e90 100644
--- a/mathlib4/Mathlib/Analysis/RCLike/Basic.lean
+++ b/mathlib4/Mathlib/Analysis/RCLike/Basic.lean
@@ -1378,7 +1378,6 @@ theorem symm_smul_apply (e : V ≃ₗᵢ[𝕜] W) (α : unitary 𝕜) (x : W) :
 @[simp] theorem toContinuousLinearEquiv_smul (e : G ≃ₗᵢ[𝕜] W) (α : unitary 𝕜) :
     (α • e).toContinuousLinearEquiv = Unitary.toUnits α • e.toContinuousLinearEquiv := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem smul_trans (α : unitary 𝕜) (e : V ≃ₗᵢ[𝕜] G) (f : G ≃ₗᵢ[𝕜] W) :
     (α • e).trans f = α • (e.trans f) := by ext; simp
diff --git a/mathlib4/Mathlib/Analysis/RCLike/Extend.lean b/mathlib4/Mathlib/Analysis/RCLike/Extend.lean
index f48b7ef8e..f1edf6850 100644
--- a/mathlib4/Mathlib/Analysis/RCLike/Extend.lean
+++ b/mathlib4/Mathlib/Analysis/RCLike/Extend.lean
@@ -77,7 +77,6 @@ lemma im_extendRCLike_apply (g : Dual ℝ F) (x : F) :
   obtain (h | h) := RCLike.I_eq_zero_or_im_I_eq_one (K := 𝕜)
   all_goals simp [h, extendRCLike_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem norm_extendRCLike_apply_sq (fr : Dual ℝ F) (x : F) :
     ‖(fr.extendRCLike x : 𝕜)‖ ^ 2 = fr (conj (fr.extendRCLike x : 𝕜) • x) := calc
   ‖(fr.extendRCLike x : 𝕜)‖ ^ 2 = re (conj (fr.extendRCLike x) * fr.extendRCLike x : 𝕜) := by
diff --git a/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean b/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean
index d33f8a3a1..f3c9133ea 100644
--- a/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean
@@ -205,7 +205,6 @@ lemma top_mem_range (A₀ : Subobject X) {J : Type w} [LinearOrder J] [OrderBot
 
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma exists_ordinal (A₀ : Subobject X) :
     ∃ (o : Ordinal.{w}) (j : o.ToType), transfiniteIterate (largerSubobject hG) j A₀ = ⊤ := by
   let κ := Order.succ (Cardinal.mk (Shrink.{w} (Subobject X)))
diff --git a/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/GabrielPopescu.lean b/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/GabrielPopescu.lean
index f66dc3eab..d9634c52c 100644
--- a/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/GabrielPopescu.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/GabrielPopescu.lean
@@ -73,7 +73,6 @@ theorem ι_d {G A : C} {M : ModuleCat (End G)ᵐᵒᵖ} (g : M ⟶ ModuleCat.of
     Sigma.ι _ m ≫ d g = g.hom m := by
   simp [d]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
 attribute [local instance] IsFiltered.isConnected in
diff --git a/mathlib4/Mathlib/CategoryTheory/Abelian/Pseudoelements.lean b/mathlib4/Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
index b9bd2f04d..716f26610 100644
--- a/mathlib4/Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
@@ -205,7 +205,6 @@ section
 
 attribute [local instance] HasBinaryBiproducts.of_hasBinaryProducts
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The arrows pseudo-equal to a zero morphism are precisely the zero morphisms. -/
 theorem pseudoZero_aux {P : C} (Q : C) (f : Over P) : f ≈ (0 : Q ⟶ P) ↔ f.hom = 0 :=
diff --git a/mathlib4/Mathlib/CategoryTheory/Action/Continuous.lean b/mathlib4/Mathlib/CategoryTheory/Action/Continuous.lean
index 941de082e..cf638edfc 100644
--- a/mathlib4/Mathlib/CategoryTheory/Action/Continuous.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Action/Continuous.lean
@@ -151,7 +151,6 @@ namespace DiscreteContAction
 
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : HasForget₂ (DiscreteContAction V G) (ContAction V G) :=
   inferInstanceAs <| HasForget₂ (ObjectProperty.FullSubcategory _) _
 
diff --git a/mathlib4/Mathlib/CategoryTheory/Category/TwoP.lean b/mathlib4/Mathlib/CategoryTheory/Category/TwoP.lean
index 1b328369f..4dafafe70 100644
--- a/mathlib4/Mathlib/CategoryTheory/Category/TwoP.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Category/TwoP.lean
@@ -66,7 +66,6 @@ noncomputable instance largeCategory : LargeCategory TwoP :=
   inferInstanceAs <| Category (InducedCategory _ toBipointed)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance concreteCategory : ConcreteCategory TwoP
     (fun X Y => Bipointed.HomSubtype X.toBipointed Y.toBipointed) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toBipointed) _
diff --git a/mathlib4/Mathlib/CategoryTheory/Extensive.lean b/mathlib4/Mathlib/CategoryTheory/Extensive.lean
index 83eea95d4..06c6e3d08 100644
--- a/mathlib4/Mathlib/CategoryTheory/Extensive.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Extensive.lean
@@ -404,7 +404,6 @@ instance {C} [Category* C] {D} [Category* D] (F : C ⥤ D)
   preservesPullback_symmetry _ _ _
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem finitaryExtensive_of_preserves_and_reflects (F : C ⥤ D) [FinitaryExtensive D]
     [HasFiniteCoproducts C] [HasPullbacksOfInclusions C]
     [PreservesPullbacksOfInclusions F]
diff --git a/mathlib4/Mathlib/CategoryTheory/Functor/TypeValuedFlat.lean b/mathlib4/Mathlib/CategoryTheory/Functor/TypeValuedFlat.lean
index 6c92dcf20..a73c3dc02 100644
--- a/mathlib4/Mathlib/CategoryTheory/Functor/TypeValuedFlat.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Functor/TypeValuedFlat.lean
@@ -75,7 +75,6 @@ def fromOverSubfunctor : Subfunctor (Over.forget X ⋙ F) where
 
 -- Would need `(Over.forget X ⋙ F).obj U = F.obj U.left` at `instances` transparency.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_fromOverSubfunctor_iff {U : Over X} (u : F.obj U.left) :
     u ∈ (fromOverSubfunctor F x).obj U ↔ F.map U.hom u = x := Iff.rfl
diff --git a/mathlib4/Mathlib/CategoryTheory/GradedObject/Monoidal.lean b/mathlib4/Mathlib/CategoryTheory/GradedObject/Monoidal.lean
index 33186089d..f7ccb1af7 100644
--- a/mathlib4/Mathlib/CategoryTheory/GradedObject/Monoidal.lean
+++ b/mathlib4/Mathlib/CategoryTheory/GradedObject/Monoidal.lean
@@ -559,7 +559,6 @@ variable [DecidableEq I] [HasInitial C]
   [HasGoodTensor₁₂Tensor X₁ tensorUnit X₃] [HasGoodTensorTensor₂₃ X₁ tensorUnit X₃]
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 lemma triangle :
     (associator X₁ tensorUnit X₃).hom ≫ tensorHom (𝟙 X₁) (leftUnitor X₃).hom =
diff --git a/mathlib4/Mathlib/CategoryTheory/Limits/ConcreteCategory/WithAlgebraicStructures.lean b/mathlib4/Mathlib/CategoryTheory/Limits/ConcreteCategory/WithAlgebraicStructures.lean
index 45f8e347f..44836198e 100644
--- a/mathlib4/Mathlib/CategoryTheory/Limits/ConcreteCategory/WithAlgebraicStructures.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Limits/ConcreteCategory/WithAlgebraicStructures.lean
@@ -57,7 +57,6 @@ end zero
 
 section module
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 If `r` has no zero smul divisors for all small-enough sections, then `r` has no zero smul divisors
 in the colimit.
diff --git a/mathlib4/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean b/mathlib4/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean
index 598e49b26..b59fcf287 100644
--- a/mathlib4/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Limits/Types/Coproducts.lean
@@ -274,7 +274,6 @@ open Function (Injective)
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem binaryCofan_isColimit_iff {X Y : Type u} (c : BinaryCofan X Y) :
     Nonempty (IsColimit c) ↔
       Injective c.inl ∧ Injective c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr) := by
diff --git a/mathlib4/Mathlib/CategoryTheory/Monoidal/Bimod.lean b/mathlib4/Mathlib/CategoryTheory/Monoidal/Bimod.lean
index a07d98aba..13256fddc 100644
--- a/mathlib4/Mathlib/CategoryTheory/Monoidal/Bimod.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Monoidal/Bimod.lean
@@ -623,7 +623,6 @@ noncomputable def hom : TensorBimod.X (regular R) P ⟶ P.X :=
   coequalizer.desc P.actLeft (by dsimp; rw [Category.assoc, left_assoc])
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The underlying morphism of the inverse component of the left unitor isomorphism. -/
 noncomputable def inv : P.X ⟶ TensorBimod.X (regular R) P :=
   (λ_ P.X).inv ≫ (η[R.X] ▷ _) ≫ coequalizer.π _ _
@@ -688,7 +687,6 @@ noncomputable def hom : TensorBimod.X P (regular S) ⟶ P.X :=
   coequalizer.desc P.actRight (by dsimp; rw [Category.assoc, right_assoc, Iso.hom_inv_id_assoc])
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The underlying morphism of the inverse component of the right unitor isomorphism. -/
 noncomputable def inv : P.X ⟶ TensorBimod.X P (regular S) :=
   (ρ_ P.X).inv ≫ (_ ◁ η[S.X]) ≫ coequalizer.π _ _
diff --git a/mathlib4/Mathlib/CategoryTheory/Presentable/Type.lean b/mathlib4/Mathlib/CategoryTheory/Presentable/Type.lean
index 42cf93e8b..ed0a4b7f7 100644
--- a/mathlib4/Mathlib/CategoryTheory/Presentable/Type.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Presentable/Type.lean
@@ -99,7 +99,6 @@ def cocone : Cocone (Set.functor X κ) where
   ι.app _ := ↾(Subtype.val)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 /-- Any type `X` is the (filtered) colimit of its subsets of cardinality `< κ`
 when `κ` is an infinite cardinal. (This colimit is `κ`-filtered when `κ` is
diff --git a/mathlib4/Mathlib/CategoryTheory/Subobject/Lattice.lean b/mathlib4/Mathlib/CategoryTheory/Subobject/Lattice.lean
index fa8cda914..b3362517b 100644
--- a/mathlib4/Mathlib/CategoryTheory/Subobject/Lattice.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Subobject/Lattice.lean
@@ -67,7 +67,6 @@ def pullbackTop (f : X ⟶ Y) : (pullback f).obj ⊤ ≅ ⊤ :=
     (homMk (pullback.lift f (𝟙 _) (by simp)) (pullback.lift_snd _ _ _))
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- There is a morphism from `⊤ : MonoOver A` to the pullback of a monomorphism along itself;
 as the category is thin this is an isomorphism. -/
 def topLEPullbackSelf {A B : C} (f : A ⟶ B) [Mono f] :
diff --git a/mathlib4/Mathlib/CategoryTheory/Yoneda.lean b/mathlib4/Mathlib/CategoryTheory/Yoneda.lean
index 283a9bc33..0f43ae85c 100644
--- a/mathlib4/Mathlib/CategoryTheory/Yoneda.lean
+++ b/mathlib4/Mathlib/CategoryTheory/Yoneda.lean
@@ -1194,7 +1194,6 @@ lemma uliftCoyonedaEquiv_symm_map {X Y : C} (f : X ⟶ Y) {F : C ⥤ Type (max w
   simp
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma uliftCoyonedaEquiv_uliftCoyoneda_map {X Y : Cᵒᵖ} (f : X ⟶ Y) :
     DFunLike.coe (β := fun _ ↦ ULift.{w} (Y.unop ⟶ X.unop))
diff --git a/mathlib4/Mathlib/Combinatorics/Enumerative/Partition/GenFun.lean b/mathlib4/Mathlib/Combinatorics/Enumerative/Partition/GenFun.lean
index 291a9de94..1e6c4ad84 100644
--- a/mathlib4/Mathlib/Combinatorics/Enumerative/Partition/GenFun.lean
+++ b/mathlib4/Mathlib/Combinatorics/Enumerative/Partition/GenFun.lean
@@ -90,7 +90,6 @@ theorem summable_genFun_term' (f : ℕ → ℕ → R) {i : ℕ} (hi : i ≠ 0) :
 
 variable [T2Space R]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private theorem aux_dvd_of_coeff_ne_zero {f : ℕ → ℕ → R} {d : ℕ} {s : Finset ℕ} (hs0 : 0 ∉ s)
     {g : ℕ →₀ ℕ} (hg : g ∈ s.finsuppAntidiag d)
     (hprod : ∀ i ∈ s, (coeff (g i)) (1 + ∑' j, f i (j + 1) • X ^ (i * (j + 1))) ≠ (0 : R)) (x : ℕ) :
diff --git a/mathlib4/Mathlib/Combinatorics/SimpleGraph/Coloring/Vertex.lean b/mathlib4/Mathlib/Combinatorics/SimpleGraph/Coloring/Vertex.lean
index d41a51701..e7f9563f2 100644
--- a/mathlib4/Mathlib/Combinatorics/SimpleGraph/Coloring/Vertex.lean
+++ b/mathlib4/Mathlib/Combinatorics/SimpleGraph/Coloring/Vertex.lean
@@ -113,7 +113,6 @@ theorem Coloring.colorClasses_finite [Finite α] : C.colorClasses.Finite :=
   Setoid.finite_classes_ker _
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Coloring.card_colorClasses_le [Fintype α] [Fintype C.colorClasses] :
     Fintype.card C.colorClasses ≤ Fintype.card α := by
   simp only [colorClasses]
diff --git a/mathlib4/Mathlib/Condensed/Light/Functors.lean b/mathlib4/Mathlib/Condensed/Light/Functors.lean
index d281d6e8f..33e8b2d44 100644
--- a/mathlib4/Mathlib/Condensed/Light/Functors.lean
+++ b/mathlib4/Mathlib/Condensed/Light/Functors.lean
@@ -49,7 +49,6 @@ instance : lightProfiniteToLightCondSet.Faithful :=
   inferInstanceAs ((coherentTopology LightProfinite).yoneda).Faithful
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 The functor from `LightProfinite` to `LightCondSet` factors through `TopCat`.
 -/
diff --git a/mathlib4/Mathlib/Condensed/Light/Sequence.lean b/mathlib4/Mathlib/Condensed/Light/Sequence.lean
index 32530e96b..e375ac820 100644
--- a/mathlib4/Mathlib/Condensed/Light/Sequence.lean
+++ b/mathlib4/Mathlib/Condensed/Light/Sequence.lean
@@ -53,7 +53,6 @@ lemma mem_fibres_iff (π : T → S × Option X) (σ : Option X → S → T) (t :
   simp [fibres]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma fibres_compl_eq_iUnion (π : T → S × Option X) (σ : Option X → S → T)
     (hσ' : ∀ (x : Option X) (s : S), (π (σ x s)).2 = x) :
     (fibres π σ)ᶜ =
@@ -245,7 +244,6 @@ noncomputable def cocone {X : LightCondMod R} {S T : LightProfinite} (π : T ⟶
     simp [pullback.condition]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a surjective map of light profinite spaces `T ⟶ S ⊗ ℕ∪{∞}`,
 construct a (non-cartesian) commutative square
 ```
diff --git a/mathlib4/Mathlib/Data/DFinsupp/Lex.lean b/mathlib4/Mathlib/Data/DFinsupp/Lex.lean
index b25ca1ab9..3f40309df 100644
--- a/mathlib4/Mathlib/Data/DFinsupp/Lex.lean
+++ b/mathlib4/Mathlib/Data/DFinsupp/Lex.lean
@@ -96,7 +96,6 @@ instance Lex.isStrictOrder [∀ i, PartialOrder (α i)] :
   trans _ _ _ := lt_trans (α := Lex (∀ i, α i))
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.isStrictOrder [∀ i, PartialOrder (α i)] :
     IsStrictOrder (Colex (Π₀ i, α i)) (· < ·) :=
   Lex.isStrictOrder (ι := ιᵒᵈ)
@@ -123,7 +122,6 @@ theorem Lex.le_iff_of_unique [Unique ι] [∀ i, PartialOrder (α i)] {x y : Lex
   Pi.lex_le_iff_of_unique
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Colex.le_iff_of_unique [Unique ι] [∀ i, PartialOrder (α i)] {x y : Colex (Π₀ i, α i)} :
     x ≤ y ↔ x default ≤ y default :=
   Lex.le_iff_of_unique (ι := ιᵒᵈ)
@@ -151,7 +149,6 @@ instance Lex.total_le : @Std.Total (Lex (Π₀ i, α i)) (· ≤ ·) where
   total := lt_trichotomy_rec (fun h ↦ Or.inl h.le) (fun h ↦ Or.inl h.le) fun h ↦ Or.inr h.le
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.total_le : @Std.Total (Colex (Π₀ i, α i)) (· ≤ ·) :=
   Lex.total_le (ι := ιᵒᵈ)
 
@@ -164,7 +161,6 @@ instance Lex.decidableLE : DecidableLE (Lex (Π₀ i, α i)) :=
     fun h ↦ isFalse fun h' ↦ lt_irrefl _ (h.trans_le h')
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The less-or-equal relation for the colexicographic ordering is decidable. -/
 instance Colex.decidableLE : DecidableLE (Colex (Π₀ i, α i)) :=
   Lex.decidableLE (ι := ιᵒᵈ)
@@ -176,7 +172,6 @@ instance Lex.decidableLT : DecidableLT (Lex (Π₀ i, α i)) :=
   lt_trichotomy_rec (fun h ↦ isTrue h) (fun h ↦ isFalse h.not_lt) fun h ↦ isFalse h.asymm
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The less-than relation for the colexicographic ordering is decidable. -/
 instance Colex.decidableLT : DecidableLT (Colex (Π₀ i, α i)) :=
   Lex.decidableLT (ι := ιᵒᵈ)
@@ -206,7 +201,6 @@ theorem toLex_monotone : Monotone (@toLex (Π₀ i, α i)) := by
     (h _).lt_of_ne (mem_neLocus.1 <| Finset.min'_mem _ _)⟩
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toColex_monotone : Monotone (@toColex (Π₀ i, α i)) :=
   toLex_monotone (ι := ιᵒᵈ)
 
@@ -230,7 +224,6 @@ instance Lex.addLeftStrictMono : AddLeftStrictMono (Lex (Π₀ i, α i)) :=
   ⟨fun _ _ _ ⟨a, lta, ha⟩ ↦ ⟨a, fun j ja ↦ congr_arg _ (lta j ja), by dsimp; gcongr⟩⟩
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.addLeftStrictMono : AddLeftStrictMono (Colex (Π₀ i, α i)) :=
   Lex.addLeftStrictMono (ι := ιᵒᵈ)
 
@@ -239,7 +232,6 @@ instance Lex.addLeftMono : AddLeftMono (Lex (Π₀ i, α i)) :=
   addLeftMono_of_addLeftStrictMono _
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.addLeftMono : AddLeftMono (Colex (Π₀ i, α i)) :=
   Lex.addLeftMono (ι := ιᵒᵈ)
 
@@ -255,17 +247,14 @@ instance Lex.addRightStrictMono : AddRightStrictMono (Lex (Π₀ i, α i)) :=
     ⟨a, fun j ja ↦ congr_arg (· + ofLex f j) (lta j ja), by dsimp; gcongr⟩⟩
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.addRightStrictMono : AddRightStrictMono (Colex (Π₀ i, α i)) :=
   Lex.addRightStrictMono (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Lex.addRightMono : AddRightMono (Lex (Π₀ i, α i)) :=
   addRightMono_of_addRightStrictMono _
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.addRightMono : AddRightMono (Colex (Π₀ i, α i)) :=
   Lex.addRightMono (ι := ιᵒᵈ)
 
@@ -306,7 +295,6 @@ instance Lex.isOrderedCancelAddMonoid [∀ i, AddCommMonoid (α i)] [∀ i, Part
   le_of_add_le_add_left _ _ _ := le_of_add_le_add_left (α := Lex (∀ i, α i))
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.isOrderedCancelAddMonoid [∀ i, AddCommMonoid (α i)] [∀ i, PartialOrder (α i)]
     [∀ i, IsOrderedCancelAddMonoid (α i)] :
     IsOrderedCancelAddMonoid (Colex (Π₀ i, α i)) :=
@@ -318,7 +306,6 @@ instance Lex.isOrderedAddMonoid [∀ i, AddCommGroup (α i)] [∀ i, PartialOrde
   add_le_add_left _ _ := add_le_add_left
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.isOrderedAddMonoid [∀ i, AddCommGroup (α i)] [∀ i, PartialOrder (α i)]
     [∀ i, IsOrderedAddMonoid (α i)] :
     IsOrderedAddMonoid (Colex (Π₀ i, α i)) :=
diff --git a/mathlib4/Mathlib/Data/DFinsupp/WellFounded.lean b/mathlib4/Mathlib/Data/DFinsupp/WellFounded.lean
index 943ac9cb0..bee9a9871 100644
--- a/mathlib4/Mathlib/Data/DFinsupp/WellFounded.lean
+++ b/mathlib4/Mathlib/Data/DFinsupp/WellFounded.lean
@@ -175,7 +175,6 @@ instance Lex.wellFoundedLT [LT ι] [@Std.Trichotomous ι (· < ·)] [hι : WellF
   ⟨Lex.wellFounded' (fun _ _ => not_lt_zero) (fun i => (hα i).wf) hι.wf⟩
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.wellFoundedLT [LT ι] [@Std.Trichotomous ι (· < ·)] [WellFoundedLT ι]
     [∀ i, AddMonoid (α i)] [∀ i, PartialOrder (α i)] [∀ i, IsBotZeroClass (α i)]
     [∀ i, WellFoundedLT (α i)] :
@@ -202,7 +201,6 @@ instance Pi.Lex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
   ⟨Pi.Lex.wellFounded (· < ·) fun i => (hwf i).1⟩
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Pi.Colex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Colex (∀ i, α i)) :=
   Pi.Lex.wellFoundedLT (ι := ιᵒᵈ)
@@ -221,7 +219,6 @@ instance DFinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀
   ⟨DFinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance DFinsupp.Colex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
     [∀ i, LT (α i)] [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Colex (Π₀ i, α i)) :=
   DFinsupp.Lex.wellFoundedLT_of_finite (ι := ιᵒᵈ)
diff --git a/mathlib4/Mathlib/Data/Finset/Defs.lean b/mathlib4/Mathlib/Data/Finset/Defs.lean
index f8b08ffd5..e231d7f8b 100644
--- a/mathlib4/Mathlib/Data/Finset/Defs.lean
+++ b/mathlib4/Mathlib/Data/Finset/Defs.lean
@@ -318,7 +318,6 @@ section DecidablePiExists
 variable {s : Finset α}
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance decidableDforallFinset {p : ∀ a ∈ s, Prop} [_hp : ∀ (a) (h : a ∈ s), Decidable (p a h)] :
     Decidable (∀ (a) (h : a ∈ s), p a h) :=
   Multiset.decidableDforallMultiset
@@ -336,7 +335,6 @@ instance instDecidableLT [DecidableEq α] : DecidableLT (Finset α) :=
   instDecidableRelSSubset
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance decidableDExistsFinset {p : ∀ a ∈ s, Prop} [_hp : ∀ (a) (h : a ∈ s), Decidable (p a h)] :
     Decidable (∃ (a : _) (h : a ∈ s), p a h) :=
   Multiset.decidableDexistsMultiset
diff --git a/mathlib4/Mathlib/Data/Finset/Image.lean b/mathlib4/Mathlib/Data/Finset/Image.lean
index b8beabb28..1d13014ff 100644
--- a/mathlib4/Mathlib/Data/Finset/Image.lean
+++ b/mathlib4/Mathlib/Data/Finset/Image.lean
@@ -179,7 +179,6 @@ lemma map_filter' (p : α → Prop) [DecidablePred p] (f : α ↪ β) (s : Finse
   simp [filter_map]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma filter_attach' [DecidableEq α] (s : Finset α) (p : s → Prop) [DecidablePred p] :
     s.attach.filter p =
       (s.filter fun x => ∃ h, p ⟨x, h⟩).attach.map
diff --git a/mathlib4/Mathlib/FieldTheory/Fixed.lean b/mathlib4/Mathlib/FieldTheory/Fixed.lean
index 175dc3b51..34cbc7826 100644
--- a/mathlib4/Mathlib/FieldTheory/Fixed.lean
+++ b/mathlib4/Mathlib/FieldTheory/Fixed.lean
@@ -207,7 +207,6 @@ theorem ne_one : minpoly G F x ≠ (1 : Polynomial (FixedPoints.subfield G F)) :
   have := eval₂ G F x
   (one_ne_zero : (1 : F) ≠ 0) <| by rwa [H, Polynomial.eval₂_one] at this
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 theorem of_eval₂ (f : Polynomial (FixedPoints.subfield G F))
     (hf : Polynomial.eval₂ (Subfield.subtype <| FixedPoints.subfield G F) x f = 0) :
diff --git a/mathlib4/Mathlib/FieldTheory/KummerExtension.lean b/mathlib4/Mathlib/FieldTheory/KummerExtension.lean
index ee68b53e3..d4dad3dc7 100644
--- a/mathlib4/Mathlib/FieldTheory/KummerExtension.lean
+++ b/mathlib4/Mathlib/FieldTheory/KummerExtension.lean
@@ -195,7 +195,6 @@ theorem Polynomial.separable_X_pow_sub_C_of_irreducible : (X ^ n - C a).Separabl
 
 variable (n)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The natural embedding of the roots of unity of `K` into `Gal(K[ⁿ√a]/K)`, by sending
 `η ↦ (ⁿ√a ↦ η • ⁿ√a)`. Also see `autAdjoinRootXPowSubC` for the `AlgEquiv` version. -/
 noncomputable
@@ -393,7 +392,6 @@ def autEquivRootsOfUnity [NeZero n] :
   (AlgEquiv.autCongr (adjoinRootXPowSubCEquiv hζ H (rootOfSplitsXPowSubC_pow a L)).symm).trans
     (autAdjoinRootXPowSubCEquiv hζ H).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma autEquivRootsOfUnity_apply_rootOfSplit [NeZero n] (σ : Gal(L/K)) :
     σ (rootOfSplitsXPowSubC (NeZero.pos n) a L) =
       autEquivRootsOfUnity hζ H L σ • (rootOfSplitsXPowSubC (NeZero.pos n) a L) := by
@@ -405,7 +403,6 @@ lemma autEquivRootsOfUnity_apply_rootOfSplit [NeZero n] (σ : Gal(L/K)) :
     adjoinRootXPowSubCEquiv_root]
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hα in
 lemma autEquivRootsOfUnity_smul [NeZero n] (σ : Gal(L/K)) :
     autEquivRootsOfUnity hζ H L σ • α = σ α := by
diff --git a/mathlib4/Mathlib/FieldTheory/NormalizedTrace.lean b/mathlib4/Mathlib/FieldTheory/NormalizedTrace.lean
index f540ecaff..9947816d3 100644
--- a/mathlib4/Mathlib/FieldTheory/NormalizedTrace.lean
+++ b/mathlib4/Mathlib/FieldTheory/NormalizedTrace.lean
@@ -75,7 +75,6 @@ private theorem normalizedTraceAux_eq_of_finiteDimensional [FiniteDimensional F
 
 variable [Algebra.IsIntegral F K]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.privateInPublic true in
 set_option backward.privateInPublic.warn false in
 /-- The normalized trace map from an algebraic extension `K` to the base field `F`. -/
@@ -181,7 +180,6 @@ theorem normalizedTrace_algebraMap_of_lifts [CharZero E] [Algebra.IsIntegral E K
   simp [normalizedTrace_minpoly F a, normalizedTrace_minpoly E a, ← minpoly.map_algebraMap ha h,
     (minpoly F a).nextCoeff_map_eq, map_mul, map_neg]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /- An auxiliary result to prove `normalizedTrace_trans_apply`. It differs from
 `normalizedTrace_trans_apply` only by the extra assumption about finiteness of `E` over `F`. -/
diff --git a/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean b/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
index 2b3644ec4..756178282 100644
--- a/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
+++ b/mathlib4/Mathlib/FieldTheory/SeparablyGenerated.lean
@@ -63,7 +63,6 @@ theorem aeval_toPolynomialAdjoinImageCompl_eq_zero
   simp_rw [toPolynomialAdjoinImageCompl, ← AlgEquiv.coe_toAlgHom, ← AlgHom.comp_apply]
   congr; ext; aesop (add simp optionEquivLeft_X_some) (add simp optionEquivLeft_X_none)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem irreducible_toPolynomialAdjoinImageCompl {F : MvPolynomial ι k} (hF : Irreducible F) (i : ι)
     (H : AlgebraicIndependent k fun x : {j | j ≠ i} ↦ a x) :
     Irreducible (toPolynomialAdjoinImageCompl F a i) := by
@@ -135,7 +134,6 @@ theorem isAlgebraic_of_mem_vars_of_forall_totalDegree_le (hFa : F.aeval a = 0) (
       (Finsupp.mem_support_iff.mp hσi) ?_, aeval_toPolynomialAdjoinImageCompl_eq_zero hFa ..⟩
   rw [h, Polynomial.coeff_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 include hp H in
diff --git a/mathlib4/Mathlib/Geometry/Convex/Cone/Dual.lean b/mathlib4/Mathlib/Geometry/Convex/Cone/Dual.lean
index 8180a305e..c1597d600 100644
--- a/mathlib4/Mathlib/Geometry/Convex/Cone/Dual.lean
+++ b/mathlib4/Mathlib/Geometry/Convex/Cone/Dual.lean
@@ -44,7 +44,6 @@ variable {p : M →ₗ[R] N →ₗ[R] R} {s t : Set M} {y : N}
 
 local notation3 "R≥0" => {c : R // 0 ≤ c}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (p) in
 /-- The dual cone of a set `s` with respect to a bilinear pairing `p` is the cone consisting of all
 points `y` such that for all points `x ∈ s` we have `0 ≤ p x y`. -/
diff --git a/mathlib4/Mathlib/Geometry/Convex/Cone/Face/Basic.lean b/mathlib4/Mathlib/Geometry/Convex/Cone/Face/Basic.lean
index 3a6fb06bb..922db36ac 100644
--- a/mathlib4/Mathlib/Geometry/Convex/Cone/Face/Basic.lean
+++ b/mathlib4/Mathlib/Geometry/Convex/Cone/Face/Basic.lean
@@ -150,7 +150,6 @@ section Map
 
 variable [AddCommGroup N] [Module R N]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The image of a face of a cone under an injective linear map is a face of the
 image of the cone. -/
 protected theorem map (f : M →ₗ[R] N) (hf : Function.Injective f) (hF : F.IsFaceOf C) :
@@ -177,7 +176,6 @@ theorem of_map_injective {f : M →ₗ[R] N} (hf : Function.Injective f)
     convert hx'
     exact hf hhx'.symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The comap of a face of a cone under a linear map is a face of the comap of the cone. -/
 protected theorem comap (f : N →ₗ[R] M) (hF : F.IsFaceOf C) : (F.comap f).IsFaceOf (C.comap f) := by
   refine ⟨comap_mono hF.le, ?_⟩
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
index 1f18edf3d..08b8c02e2 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
@@ -467,7 +467,6 @@ theorem oangle_add_right_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ
       LinearIsometryEquiv.norm_map, mul_div_assoc, div_self (norm_ne_zero_iff.2 h), mul_one,
       Real.norm_eq_abs, abs_of_pos hr]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An angle in a right-angled triangle expressed using `arctan`, where one side is a multiple
 of a rotation of another by `π / 2`. -/
 theorem oangle_add_left_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ) :
@@ -494,7 +493,6 @@ theorem tan_oangle_add_left_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r :
       r⁻¹ := by
   rw [o.oangle_add_left_smul_rotation_pi_div_two h, Real.Angle.tan_coe, Real.tan_arctan]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An angle in a right-angled triangle expressed using `arctan`, where one side is a multiple
 of a rotation of another by `π / 2`, version subtracting vectors. -/
 theorem oangle_sub_right_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ) :
@@ -506,7 +504,6 @@ theorem oangle_sub_right_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ
   rw [sub_eq_add_neg, hx, o.oangle_add_right_smul_rotation_pi_div_two]
   simpa [hr] using h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An angle in a right-angled triangle expressed using `arctan`, where one side is a multiple
 of a rotation of another by `π / 2`, version subtracting vectors. -/
 theorem oangle_sub_left_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ) :
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
index 7b31e3d1e..495f17778 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
@@ -58,7 +58,6 @@ theorem rotationAux_apply (θ : Real.Angle) (x : V) :
     o.rotationAux θ x = Real.Angle.cos θ • x + Real.Angle.sin θ • J x :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A rotation by the oriented angle `θ`. -/
 def rotation (θ : Real.Angle) : V ≃ₗᵢ[ℝ] V :=
   LinearIsometryEquiv.ofLinearIsometry (o.rotationAux θ)
@@ -141,7 +140,6 @@ theorem rotation_pi_div_two : o.rotation (π / 2 : ℝ) = J := by
   ext x
   simp [rotation]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Rotating twice is equivalent to rotating by the sum of the angles. -/
 @[simp]
 theorem rotation_rotation (θ₁ θ₂ : Real.Angle) (x : V) :
@@ -277,7 +275,6 @@ theorem rotation_oangle_eq_iff_norm_eq (x y : V) : o.rotation (o.oangle x y) x =
   · intro h
     rw [o.eq_iff_oangle_eq_zero_of_norm_eq] <;> simp [h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The angle between two nonzero vectors is `θ` if and only if the second vector is the first
 rotated by `θ` and scaled by the ratio of the norms. -/
 theorem oangle_eq_iff_eq_norm_div_norm_smul_rotation_of_ne_zero {x y : V} (hx : x ≠ 0) (hy : y ≠ 0)
@@ -347,7 +344,6 @@ theorem exists_linearIsometryEquiv_eq_of_det_pos {f : V ≃ₗᵢ[ℝ] V}
       o.kahler_comp_rightAngleRotation]
   simp [← this]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem rotation_map (θ : Real.Angle) (f : V ≃ₗᵢ[ℝ] V') (x : V') :
     (Orientation.map (Fin 2) f.toLinearEquiv o).rotation θ x = f (o.rotation θ (f.symm x)) := by
   simp [rotation_apply, o.rightAngleRotation_map]
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Sphere.lean b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Sphere.lean
index 7858310cf..82667ad14 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/Angle/Sphere.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/Angle/Sphere.lean
@@ -259,7 +259,6 @@ theorem abs_oangle_center_right_toReal_lt_pi_div_two {s : Sphere P} {p₁ p₂ :
   abs_oangle_left_toReal_lt_pi_div_two_of_dist_eq
     (dist_center_eq_dist_center_of_mem_sphere' hp₂ hp₁)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given two points on a circle, the center of that circle may be expressed explicitly as a
 multiple (by half the tangent of the angle between the chord and the radius at one of those
 points) of a `π / 2` rotation of the vector between those points, plus the midpoint of those
@@ -289,7 +288,6 @@ theorem inv_tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_center {s : Sp
   rw [add_comm,
     two_zsmul_oangle_center_add_two_zsmul_oangle_eq_pi hp₁ hp₂ hp₃ hp₁p₂.symm hp₂p₃ hp₁p₃]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given two points on a circle, the radius of that circle may be expressed explicitly as half
 the distance between those two points divided by the cosine of the angle between the chord and
 the radius at one of those points. -/
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/MongePoint.lean b/mathlib4/Mathlib/Geometry/Euclidean/MongePoint.lean
index 8205e4126..623a8dfd6 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/MongePoint.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/MongePoint.lean
@@ -93,7 +93,6 @@ theorem mongePoint_eq_smul_vsub_vadd_circumcenter {n : ℕ} (s : Simplex ℝ P n
   congr 3
   convert! Finset.univ.affineCombination_map e.toEmbedding _ _ <;> simp [Function.comp_assoc]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem mongePoint_map {V₂ P₂ : Type*} [NormedAddCommGroup V₂] [InnerProductSpace ℝ V₂]
@@ -155,7 +154,6 @@ theorem sum_mongePointWeightsWithCircumcenter (n : ℕ) :
   simp [field]
   ring
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The Monge point of an (n+2)-simplex, in terms of
 `pointsWithCircumcenter`. -/
 theorem mongePoint_eq_affineCombination_of_pointsWithCircumcenter {n : ℕ}
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/NinePointCircle.lean b/mathlib4/Mathlib/Geometry/Euclidean/NinePointCircle.lean
index 4280effab..f8647f77a 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/NinePointCircle.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/NinePointCircle.lean
@@ -74,7 +74,6 @@ theorem ninePointCircle_reindex {m n : ℕ} (s : Simplex ℝ P n) (e : Fin (n +
   · simp [ninePointCircle_center, centroid_reindex, h]
   · simp [ninePointCircle_radius, h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem ninePointCircle_map {V₂ P₂ : Type*} [NormedAddCommGroup V₂] [InnerProductSpace ℝ V₂]
     [MetricSpace P₂] [NormedAddTorsor V₂ P₂]
     {n : ℕ} (s : Simplex ℝ P n) (f : P →ᵃⁱ[ℝ] P₂) :
@@ -128,7 +127,6 @@ theorem eulerPoint_reindex {m n : ℕ} (s : Simplex ℝ P n) (e : Fin (n + 1) 
   ext i
   simp [eulerPoint, h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem eulerPoint_map {V₂ P₂ : Type*} [NormedAddCommGroup V₂] [InnerProductSpace ℝ V₂]
     [MetricSpace P₂] [NormedAddTorsor V₂ P₂]
diff --git a/mathlib4/Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean b/mathlib4/Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
index ee45e5624..f9a599cc8 100644
--- a/mathlib4/Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
+++ b/mathlib4/Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
@@ -43,7 +43,6 @@ the second intersection with the sphere through `p` and with center `s.center`.
 def Sphere.secondInter (s : Sphere P) (p : P) (v : V) : P :=
   (-2 * ⟪v, p -ᵥ s.center⟫ / ⟪v, v⟫) • v +ᵥ p
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma Sphere.secondInter_map (s : Sphere P) (p : P) (v : V) (f : P →ᵃⁱ[ℝ] P₂) :
     Sphere.secondInter ⟨f s.center, s.radius⟩ (f p) (f.linearIsometry v) =
diff --git a/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean b/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
index eae002637..70875a1a4 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@@ -66,7 +66,6 @@ instance : FunLike (LeftInvariantDerivation I G) C^∞⟮I, G; 𝕜⟯ C^∞⟮I
   coe f := f.toDerivation
   coe_injective _ _ h := toDerivation_injective <| DFunLike.ext' h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : LinearMapClass (LeftInvariantDerivation I G) 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯ where
   map_add f := map_add f.1
   map_smulₛₗ f := map_smul f.1.1
@@ -102,7 +101,6 @@ protected theorem map_neg : X (-f) = -X f := by simp
 
 protected theorem map_sub : X (f - f') = X f - X f' := by simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 protected theorem map_smul : X (r • f) = r • X f := by simp
 
@@ -256,7 +254,6 @@ instance : LieRing (LeftInvariantDerivation I G) where
     simp only [commutator_apply, coe_add, map_sub, Pi.add_apply]
     ring
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance : LieAlgebra 𝕜 (LeftInvariantDerivation I G) where
   lie_smul r Y Z := by
diff --git a/mathlib4/Mathlib/Geometry/Manifold/Instances/Sphere.lean b/mathlib4/Mathlib/Geometry/Manifold/Instances/Sphere.lean
index 549323104..7c5f1327d 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/Instances/Sphere.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/Instances/Sphere.lean
@@ -232,7 +232,6 @@ theorem stereo_left_inv (hv : ‖v‖ = 1) {x : sphere (0 : E) 1} (hx : (x : E)
   · field_simp
     linear_combination 4 * (a - 1) * pythag
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem stereo_right_inv (hv : ‖v‖ = 1) (w : (ℝ ∙ v)ᗮ) : stereoToFun v (stereoInvFun hv w) = w := by
   simp only [stereoToFun, stereoInvFun, stereoInvFunAux, smul_add, map_add, map_smul,
     innerSL_apply_apply, Submodule.orthogonalProjectionOnto_mem_subspace_eq_self]
diff --git a/mathlib4/Mathlib/Geometry/Manifold/IntegralCurve/Basic.lean b/mathlib4/Mathlib/Geometry/Manifold/IntegralCurve/Basic.lean
index 7c85771bd..be0efc65d 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/IntegralCurve/Basic.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/IntegralCurve/Basic.lean
@@ -164,7 +164,6 @@ lemma IsMIntegralCurve.continuous (hγ : IsMIntegralCurve γ v) : Continuous γ
 
 variable [IsManifold I 1 M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `γ` is an integral curve of a vector field `v`, then `γ t` is tangent to `v (γ t)` when
 expressed in the local chart around the initial point `γ t₀`. -/
@@ -185,7 +184,6 @@ lemma IsMIntegralCurveOn.hasDerivWithinAt (hγ : IsMIntegralCurveOn γ v s) {t :
     mfderiv_chartAt_eq_tangentCoordChange hsrc]
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma IsMIntegralCurveAt.eventually_hasDerivAt (hγ : IsMIntegralCurveAt γ v t₀) :
     ∀ᶠ t in 𝓝 t₀, HasDerivAt ((extChartAt I (γ t₀)) ∘ γ)
diff --git a/mathlib4/Mathlib/Geometry/Manifold/IsManifold/Basic.lean b/mathlib4/Mathlib/Geometry/Manifold/IsManifold/Basic.lean
index 0a80f1440..6c6863348 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/IsManifold/Basic.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/IsManifold/Basic.lean
@@ -739,7 +739,6 @@ theorem symm_trans_mem_contDiffGroupoid (e : OpenPartialHomeomorph M H) :
 variable {E' H' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E'] [TopologicalSpace H']
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The product of two `C^n` open partial homeomorphisms is `C^n`. -/
 theorem contDiffGroupoid_prod {I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'}
     {e : OpenPartialHomeomorph H H} {e' : OpenPartialHomeomorph H' H'}
@@ -942,7 +941,6 @@ variable {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E'] {H' : Type*}
   [TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {n : ℕ∞ω}
   {M' : Type*} [TopologicalSpace M'] [ChartedSpace H' M']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma mem_maximalAtlas_prod [IsManifold I n M] [IsManifold I' n M']
     {e : OpenPartialHomeomorph M H} (he : e ∈ maximalAtlas I n M)
     {e' : OpenPartialHomeomorph M' H'} (he' : e' ∈ maximalAtlas I' n M') :
diff --git a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
index a15599f80..96573a838 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
@@ -481,7 +481,6 @@ theorem MDifferentiable.prodMap (hf : MDiff f) (hg : MDiff g) : MDiff (Prod.map
   (hf p.1).prodMap' (hg p.2)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma HasMFDerivWithinAt.prodMap {s : Set <| M × M'} {p : M × M'} {f : M → N} {g : M' → N'}
     {df : TangentSpace% p.1 →L[𝕜] TangentSpace% (f p.1)}
     (hf : HasMFDerivAt[Prod.fst '' s] f p.1 df)
diff --git a/mathlib4/Mathlib/Geometry/Manifold/Riemannian/PathELength.lean b/mathlib4/Mathlib/Geometry/Manifold/Riemannian/PathELength.lean
index 7a81fd909..f41e39caa 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/Riemannian/PathELength.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/Riemannian/PathELength.lean
@@ -133,7 +133,6 @@ open MeasureTheory
 
 variable [∀ (x : M), ENormSMulClass ℝ (TangentSpace% x)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The length of a path in a manifold is invariant under a monotone reparametrization. -/
 lemma pathELength_comp_of_monotoneOn {f : ℝ → ℝ} (h : a ≤ b) (hf : MonotoneOn f (Icc a b))
@@ -166,7 +165,6 @@ lemma pathELength_comp_of_monotoneOn {f : ℝ → ℝ} (h : a ≤ b) (hf : Monot
   have : 0 ≤ derivWithin f (Icc a b) t := hf.derivWithin_nonneg
   simp only [map_smul, enorm_smul, ← Real.enorm_of_nonneg this, f_im]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The length of a path in a manifold is invariant under an antitone reparametrization. -/
 lemma pathELength_comp_of_antitoneOn {f : ℝ → ℝ} (h : a ≤ b) (hf : AntitoneOn f (Icc a b))
diff --git a/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean b/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
index bb6c17cf7..9c437a587 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/LocalFrame.lean
@@ -460,7 +460,6 @@ variable [VectorBundle 𝕜 F V] [ContMDiffVectorBundle 1 F V I]
   {ι : Type*} (b : Basis ι 𝕜 F) {s : Π x : M, V x} {t : Set M} {k : ℕ∞ω} {x x' : M}
   [FiniteDimensional 𝕜 F] [CompleteSpace 𝕜] [ContMDiffVectorBundle k F V I]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `s` is `C^k` at `x`, so is its coefficient `b.localFrameCoeff e i` in the local frame
 near `x` induced by `e` and `b` -/
@@ -546,7 +545,6 @@ alias contMDiffOn_baseSet_iff_localFrame_coeff := contMDiffOn_baseSet_iff_localF
 -- Differentiability of a section can be checked in terms of its local frame coefficients
 section MDifferentiable
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `s` is differentiable at `x`, so is its coefficient `b.localFrameCoeff e i` in the local
 frame near `x` induced by `e` and `b` -/
diff --git a/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean b/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
index 569932730..1d2881f43 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
@@ -240,7 +240,6 @@ theorem mem_chart_source_iff (p q : TM) :
   simp only [FiberBundle.chartedSpace_chartAt, mfld_simps]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp, mfld_simps]
 theorem mem_chart_target_iff (p : H × E) (q : TM) :
     p ∈ (chartAt (ModelProd H E) q).target ↔ p.1 ∈ (chartAt H q.1).target := by
diff --git a/mathlib4/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean b/mathlib4/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
index 14c60df12..e937c878f 100644
--- a/mathlib4/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
+++ b/mathlib4/Mathlib/Geometry/Manifold/VectorField/LieBracket.lean
@@ -420,7 +420,6 @@ Instance search follows this path:
             └ @Module.toMulActionWithZero
 ```
 -/
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Pulling back through `extChartAt` the scalar multiplication of a vector field by
diff --git a/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean b/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
index 220472da0..eccc2d643 100644
--- a/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
+++ b/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@@ -441,7 +441,6 @@ lemma stalkMap_inv_hom_apply (e : X ≅ Y) (x : X) (y) :
   DFunLike.congr_fun (CommRingCat.hom_ext_iff.mp (stalkMap_inv_hom e x)) y
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp)]
 lemma stalkMap_germ (U : Opens Y) (x : X) (hx : f.base x ∈ U) :
     Y.presheaf.germ U (f.base x) hx ≫ f.stalkMap x =
@@ -449,7 +448,6 @@ lemma stalkMap_germ (U : Opens Y) (x : X) (hx : f.base x ∈ U) :
   PresheafedSpace.stalkMap_germ f.toHom U x hx
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma stalkMap_germ_apply (U : Opens Y) (x : X) (hx : f.base x ∈ U) (y) :
     f.stalkMap x (Y.presheaf.germ U (f.base x) hx y) =
       X.presheaf.germ ((Opens.map f.base).obj U) x hx (f.c.app (op U) y) :=
diff --git a/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean b/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
index aecece40c..e018dcdd2 100644
--- a/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
+++ b/mathlib4/Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
@@ -73,7 +73,6 @@ def Γevaluation (x : X) : X.presheaf.obj (op ⊤) ⟶ X.residueField x :=
   X.evaluation ⟨x, show x ∈ ⊤ from trivial⟩
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma evaluation_eq_zero_iff_notMem_basicOpen (x : U) (f : X.presheaf.obj (op U)) :
     X.evaluation x f = 0 ↔ x.val ∉ X.toRingedSpace.basicOpen f := by
@@ -81,7 +80,6 @@ lemma evaluation_eq_zero_iff_notMem_basicOpen (x : U) (f : X.presheaf.obj (op U)
   exact (IsLocalRing.residue_ne_zero_iff_isUnit _)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma evaluation_ne_zero_iff_mem_basicOpen (x : U) (f : X.presheaf.obj (op U)) :
     X.evaluation x f ≠ 0 ↔ x.val ∈ X.toRingedSpace.basicOpen f := by
   simp
@@ -93,14 +91,12 @@ lemma basicOpen_eq_bot_iff_forall_evaluation_eq_zero (f : X.presheaf.obj (op U))
     fun h ↦ eq_bot_iff.mpr <| fun a ha ↦ h a (X.toRingedSpace.basicOpen_le f ha) ha⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma Γevaluation_eq_zero_iff_notMem_basicOpen (x : X) (f : X.presheaf.obj (op ⊤)) :
     X.Γevaluation x f = 0 ↔ x ∉ X.toRingedSpace.basicOpen f :=
   evaluation_eq_zero_iff_notMem_basicOpen X ⟨x, show x ∈ ⊤ by trivial⟩ f
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Γevaluation_ne_zero_iff_mem_basicOpen (x : X) (f : X.presheaf.obj (op ⊤)) :
     X.Γevaluation x f ≠ 0 ↔ x ∈ X.toRingedSpace.basicOpen f :=
   evaluation_ne_zero_iff_mem_basicOpen X ⟨x, show x ∈ ⊤ by trivial⟩ f
diff --git a/mathlib4/Mathlib/GroupTheory/SpecificGroups/ZGroup.lean b/mathlib4/Mathlib/GroupTheory/SpecificGroups/ZGroup.lean
index d8be11bc7..207a503b3 100644
--- a/mathlib4/Mathlib/GroupTheory/SpecificGroups/ZGroup.lean
+++ b/mathlib4/Mathlib/GroupTheory/SpecificGroups/ZGroup.lean
@@ -74,7 +74,6 @@ instance [IsZGroup G] (H : Subgroup G) : IsZGroup H := of_injective H.subtype_in
 
 -- Needs to unfold `Sylow.mapSurjective`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem of_surjective [Finite G] [hG : IsZGroup G] (hf : Function.Surjective f) : IsZGroup G' := by
   rw [isZGroup_iff] at hG ⊢
   intro p hp P
@@ -250,7 +249,6 @@ theorem le_center_or_le_commutator [P.Normal] : P ≤ Subgroup.center G ∨ P 
     exact Subgroup.commutator_mono le_top le_top
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A cyclic Sylow subgroup is either central in its normalizer or contained in the commutator
   subgroup. -/
 theorem normalizer_le_centralizer_or_le_commutator :
diff --git a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
index 7dc4f5425..ecfbea3c3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@@ -655,7 +655,6 @@ section arrowCongrₗ
 
 variable (e₁ : P₁ ≃ᵃ[R] P₂) (e₂ : V₃ ≃ₗ[R] V₄)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- An affine isomorphism between the domains and a linear isomorphism between the codomains of two
 spaces of affine maps give a linear isomorphism between the two function spaces.
diff --git a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean
index 6054fedb0..199ab8efa 100644
--- a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean
@@ -531,7 +531,6 @@ alias AffineMap.vectorSpan_image_eq_submodule_map := AffineMap.map_vectorSpan
 
 namespace AffineSubspace
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The image of an affine subspace under an affine map as an affine subspace. -/
 def map (s : AffineSubspace k P₁) : AffineSubspace k P₂ where
   carrier := f '' s
@@ -725,7 +724,6 @@ end
 
 namespace AffineSubspace
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The preimage of an affine subspace under an affine map as an affine subspace. -/
 def comap (f : P₁ →ᵃ[k] P₂) (s : AffineSubspace k P₂) : AffineSubspace k P₁ where
   carrier := f ⁻¹' s
diff --git a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Shift.lean b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Shift.lean
index 6c8017e08..e7ad342de 100644
--- a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Shift.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Shift.lean
@@ -98,7 +98,6 @@ theorem shift_one (s : AffineSubspace k P) (c : P) : s.shift c 1 = s := by
   have h : Nonempty s := by simpa using! h
   simp [shift, h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Consider a point `A` with barycentric coordinates associated to a collection of points `P`.
 If the coordinate associated to one of the points `Pᵢ` is `r`, then the point `A` is on the span
 of `P \ {Pᵢ}` shifted towards `Pᵢ` with parameter `1 - r`. -/
@@ -121,7 +120,6 @@ theorem affineCombination_mem_shift {ι : Type*} [Fintype ι] [Nontrivial ι]
   refine affineCombination_mem_affineSpan_image ?_ (fun i' _ hi ↦ by aesop) _
   simp [sum_add_distrib, ← mul_sum, hw]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The iff version of `affineCombination_mem_shift` for affine independent points. -/
 theorem _root_.AffineIndependent.affineCombination_mem_shift_iff
     {ι : Type*} [Fintype ι] [Nontrivial ι] {p : ι → P}
diff --git a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/Combination.lean b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/Combination.lean
index b60d92da3..c35688997 100644
--- a/mathlib4/Mathlib/LinearAlgebra/AffineSpace/Combination.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/AffineSpace/Combination.lean
@@ -594,7 +594,6 @@ lemma affineCombination_apply_eq_lineMap_sum [DecidableEq ι] (w : ι → k) (p
     simp [hp₁ i hi]
   · exact (hp₂ i hi).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Applying `AffineMap.lineMap` on two `Finset.affineCombination` over the same set of points
 is equivalent to applying `AffineMap.lineMap` to the weights. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Basic.lean
index 47e05541e..146f6352a 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Basic.lean
@@ -289,7 +289,6 @@ section Module.IsTorsionFree
 
 set_option backward.isDefEq.respectTransparency false in
 -- Can't be an instance because the basis can't be inferred.
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected lemma isTorsionFree (b : Basis ι R M) :
     Module.IsTorsionFree R M := b.repr.injective.moduleIsTorsionFree _ (by simp)
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Bilinear.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Bilinear.lean
index 2772e7b94..7ef6b390d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Bilinear.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Bilinear.lean
@@ -57,7 +57,6 @@ theorem sum_repr_mul_repr_mulₛₗ {B : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁
   conv_rhs => rw [← b₁.linearCombination_repr x, ← b₂.linearCombination_repr y]
   simp_rw [Finsupp.linearCombination_apply, Finsupp.sum, map_sum₂, map_sum, map_smulₛₗ₂, map_smulₛₗ]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Write out `B x y` as a sum over `B (b i) (b j)` if `b` is a basis.
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Cardinality.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Cardinality.lean
index b9edc21bd..2e312c374 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Cardinality.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Cardinality.lean
@@ -65,7 +65,6 @@ variable [Semiring R] [AddCommMonoid M] [Nontrivial R] [Module R M]
 
 set_option backward.isDefEq.respectTransparency false in
 -- From [Les familles libres maximales d'un module ont-elles le meme cardinal?][lazarus1973]
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Over any ring `R`, if `b` is a basis for a module `M`,
 and `s` is a maximal linearly independent set,
 then the union of the supports of `x ∈ s` (when written out in the basis `b`) is all of `b`.
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Defs.lean
index 036c191c2..4428deb1f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Defs.lean
@@ -122,7 +122,6 @@ protected theorem injective [Nontrivial R] : Injective b :=
 theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c • b i :=
   calc
     b.repr.symm (Finsupp.single i c) = b.repr.symm (c • Finsupp.single i (1 : R)) := by
@@ -435,7 +434,6 @@ theorem reindexRange_apply (x : range b) : b.reindexRange x = x := by
   rcases x with ⟨bi, ⟨i, rfl⟩⟩
   exact b.reindexRange_self i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem reindexRange_repr' (x : M) {bi : M} {i : ι} (h : b i = bi) :
     b.reindexRange.repr x ⟨bi, ⟨i, h⟩⟩ = b.repr x i := by
@@ -646,7 +644,6 @@ theorem equiv'_symm_apply (f : M → M') (g : M' → M) (hf hg hgf hfg) (i : ι'
     (b.equiv' b' f g hf hg hgf hfg).symm (b' i) = g (b' i) :=
   b'.constr_basis R _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem sum_repr_mul_repr {ι'} [Fintype ι'] (b' : Basis ι' R M) (x : M) (i : ι) :
     (∑ j : ι', b.repr (b' j) i * b'.repr x j) = b.repr x i := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/Exact.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/Exact.lean
index a33cc3dca..53968a3f0 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/Exact.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/Exact.lean
@@ -52,7 +52,6 @@ lemma LinearIndependent.linearIndependent_of_exact_of_retraction
   simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.id_coe, id_eq] at hs
   rw [← hs, hz, map_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 private lemma top_le_span_of_aux (v : κ ⊕ σ → M)
     (hg : Function.Surjective g) (hslzero : ∀ i, s (v (.inl i)) = 0)
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/SMul.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/SMul.lean
index 84fa928eb..d48b6c6be 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/SMul.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/SMul.lean
@@ -110,7 +110,6 @@ theorem unitsSMul_apply {v : Basis ι R M} {w : ι → Rˣ} (i : ι) : unitsSMul
 
 variable [CommSemiring R₂] [Module R₂ M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem coord_unitsSMul (e : Basis ι R₂ M) (w : ι → R₂ˣ) (i : ι) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Basis/VectorSpace.lean b/mathlib4/Mathlib/LinearAlgebra/Basis/VectorSpace.lean
index 75ad17bb1..da1e7bed2 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Basis/VectorSpace.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Basis/VectorSpace.lean
@@ -342,7 +342,6 @@ variable {K : Type*} {V : Type*} [Field K] [AddCommGroup V] [Module K V]
 
 variable {f : V →ₗ[K] K} {v : V}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- In a vector space, given a nonzero linear form `f`,
 a nonzero vector `v` such that `f v ≠ 0`,
diff --git a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Basic.lean
index f19129678..1aa63f56c 100644
--- a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Basic.lean
@@ -68,7 +68,6 @@ theorem smul_left (a : R) (x y : M) : B (a • x) y = a * B x y := map_smul₂ _
 
 theorem add_right (x y z : M) : B x (y + z) = B x y + B x z := map_add _ _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem smul_right (a : R) (x y : M) : B x (a • y) = a * B x y := map_smul _ _ _
 
 theorem zero_left (x : M) : B 0 x = 0 := map_zero₂ _ _
diff --git a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
index 259e92a02..efc81f12a 100644
--- a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
@@ -89,7 +89,6 @@ lemma dualSubmoduleToDual_injective [IsDomain R] (hB : B.Nondegenerate) [IsTorsi
   intro z hz
   simpa using congr_arg (algebraMap R S) (LinearMap.congr_fun e ⟨z, hz⟩)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma dualSubmodule_span_of_basis {ι} [Finite ι] [DecidableEq ι]
     (hB : B.Nondegenerate) (b : Basis ι S M) :
     B.dualSubmodule (Submodule.span R (Set.range b)) =
diff --git a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
index fbb038f50..f513825c0 100644
--- a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
@@ -101,7 +101,6 @@ section
 variable {R₄ M₄ : Type*} [CommRing R₄] [IsDomain R₄]
 variable [AddCommGroup M₄] [Module R₄ M₄] {G : BilinForm R₄ M₄}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[deprecated "`BilinMap.IsOrtho` has been deprecated" (since := "2026-03-30")]
 theorem isOrtho_smul_left {x y : M₄} {a : R₄} (ha : a ≠ 0) :
     IsOrtho G (a • x) y ↔ IsOrtho G x y := by
@@ -110,7 +109,6 @@ theorem isOrtho_smul_left {x y : M₄} {a : R₄} (ha : a ≠ 0) :
   simp only [LinearMap.smul_apply, smul_eq_mul, mul_eq_zero, or_iff_right_iff_imp]
   exact fun a ↦ (ha a).elim
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[deprecated "`BilinMap.IsOrtho` has been deprecated" (since := "2026-03-30")]
 theorem isOrtho_smul_right {x y : M₄} {a : R₄} (ha : a ≠ 0) :
     IsOrtho G x (a • y) ↔ IsOrtho G x y := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Properties.lean b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Properties.lean
index 7819af7b7..fa737f807 100644
--- a/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Properties.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@@ -157,7 +157,6 @@ lemma ext_iff_of_isSymm (hB : IsSymm B) (hC : IsSymm C) :
 
 end polarization
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isSymm_iff_basis {ι : Type*} (b : Basis ι R M) :
     IsSymm B ↔ ∀ i j, B (b i) (b j) = B (b j) (b i) where
diff --git a/mathlib4/Mathlib/LinearAlgebra/Center.lean b/mathlib4/Mathlib/LinearAlgebra/Center.lean
index ee51b56e8..8e8d25428 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Center.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Center.lean
@@ -95,7 +95,6 @@ theorem commute_transvections_iff_of_basis
   intro j _
   simp [Subring.smul_def, h_allEq i j, hcomm j]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Over a domain, an endomorphism `f` of a free module `V`
 of rank ≠ 1 such that `f v` and `v` are collinear, for all `v : V`,
 consists of homotheties with central ratio.
diff --git a/mathlib4/Mathlib/LinearAlgebra/Charpoly/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Charpoly/Basic.lean
index f22fcee53..bd9cfef21 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Charpoly/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Charpoly/Basic.lean
@@ -61,7 +61,6 @@ theorem charpoly_one [StrongRankCondition R] :
     (1 : M →ₗ[R] M).charpoly = (X - 1) ^ Module.finrank R M := by
   simp [charpoly, Module.finrank_eq_card_chooseBasisIndex, Matrix.charpoly_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem charpoly_sub_smul (f : Module.End R M) (μ : R) :
     (f - μ • 1).charpoly = f.charpoly.comp (X + C μ) := by
   simpa [LinearMap.charpoly, smul_eq_mul_diagonal] using Matrix.charpoly_sub_scalar ..
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
index e6446e09b..49a9a2c7b 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
@@ -67,7 +67,6 @@ def ofBaseChange (Q : QuadraticForm R V) :
   Algebra.TensorProduct.lift (Algebra.ofId _ _) (ofBaseChangeAux A Q)
     fun _a _x => Algebra.commutes _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] theorem ofBaseChange_tmul_ι (Q : QuadraticForm R V) (z : A) (v : V) :
     ofBaseChange A Q (z ⊗ₜ ι Q v) = ι (Q.baseChange A) (z ⊗ₜ v) := by
   change algebraMap _ _ z * ofBaseChangeAux A Q (ι Q v) = ι (Q.baseChange A) (z ⊗ₜ[R] v)
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
index 25056008f..ba26f5739 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
@@ -306,7 +306,6 @@ theorem mul_ι_mul_ι_mul_comm_of_isOrtho
 
 end isOrtho
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- $aba$ is a vector. -/
 theorem ι_mul_ι_mul_ι (a b : M) :
     ι Q a * ι Q b * ι Q a = ι Q (QuadraticMap.polar Q a b • a - Q a • b) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
index 363df7e9d..1cf62573a 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
@@ -128,14 +128,12 @@ theorem contractLeft_ι_mul (a : M) (b : CliffordAlgebra Q) :
   refine foldr'_ι_mul _ _ ?_ _ _ _
   exact fun m x fx ↦ contractLeftAux_contractLeftAux Q d m x fx
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- This is [grinberg_clifford_2016] Theorem 12 -/
 theorem contractRight_mul_ι (a : M) (b : CliffordAlgebra Q) :
     b * ι Q a⌊d = d a • b - b⌊d * ι Q a := by
   rw [contractRight_eq, reverse.map_mul, reverse_ι, contractLeft_ι_mul, map_sub, map_smul,
     reverse_reverse, reverse.map_mul, reverse_ι, contractRight_eq]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem contractLeft_algebraMap_mul (r : R) (b : CliffordAlgebra Q) :
     d⌋(algebraMap _ _ r * b) = algebraMap _ _ r * (d⌋b) := by
   rw [← Algebra.smul_def, map_smul, Algebra.smul_def]
@@ -186,7 +184,6 @@ theorem contractRight_one : (1 : CliffordAlgebra Q)⌊d = 0 := by
 
 variable {Q}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- This is [grinberg_clifford_2016] Theorem 7 -/
 theorem contractLeft_contractLeft (x : CliffordAlgebra Q) : d⌋(d⌋x) = 0 := by
   induction x using CliffordAlgebra.left_induction with
@@ -199,7 +196,6 @@ theorem contractLeft_contractLeft (x : CliffordAlgebra Q) : d⌋(d⌋x) = 0 := b
 theorem contractRight_contractRight (x : CliffordAlgebra Q) : x⌊d⌊d = 0 := by
   rw [contractRight_eq, contractRight_eq, reverse_reverse, contractLeft_contractLeft, map_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- This is [grinberg_clifford_2016] Theorem 8 -/
 theorem contractLeft_comm (x : CliffordAlgebra Q) : d⌋(d'⌋x) = -(d'⌋(d⌋x)) := by
   induction x using CliffordAlgebra.left_induction with
@@ -290,7 +286,6 @@ theorem changeForm_ι_mul_ι (m₁ m₂ : M) :
     changeForm h (ι Q m₁ * ι Q m₂) = ι Q' m₁ * ι Q' m₂ - algebraMap _ _ (B m₁ m₂) := by
   rw [changeForm_ι_mul, changeForm_ι, contractLeft_ι]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Theorem 23 of [grinberg_clifford_2016] -/
 theorem changeForm_contractLeft (d : Module.Dual R M) (x : CliffordAlgebra Q) :
     changeForm h (d⌋x) = d⌋(changeForm h x) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
index b568ae87e..69383a1c5 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@@ -339,7 +339,6 @@ open DualNumber TrivSqZeroExt
 
 variable {R : Type*} [CommRing R]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem ι_mul_ι (r₁ r₂) : ι (0 : QuadraticForm R R) r₁ * ι (0 : QuadraticForm R R) r₂ = 0 := by
   rw [← mul_one r₁, ← mul_one r₂, ← smul_eq_mul r₁, ← smul_eq_mul r₂, map_smul, map_smul,
     smul_mul_smul_comm, ι_sq_scalar, zero_apply, map_zero, smul_zero]
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
index 343751420..eb3939dd0 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
@@ -70,7 +70,6 @@ structure EvenHom where
 
 variable {A Q}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Compose an `EvenHom` with an `AlgHom` on the output. -/
 @[simps]
 def EvenHom.compr₂ (g : EvenHom Q A) (f : A →ₐ[R] B) : EvenHom Q B where
@@ -81,7 +80,6 @@ def EvenHom.compr₂ (g : EvenHom Q A) (f : A →ₐ[R] B) : EvenHom Q B where
 
 variable (Q)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The embedding of pairs of vectors into the even subalgebra, as a bilinear map. -/
 nonrec def even.ι : EvenHom Q (even Q) where
   bilin :=
@@ -103,7 +101,6 @@ instance : Inhabited (EvenHom Q (even Q)) :=
 
 variable (f : EvenHom Q A)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Two algebra morphisms from the even subalgebra are equal if they agree on pairs of generators.
 
 See note [partially-applied ext lemmas]. -/
@@ -133,7 +130,6 @@ private def S : Submodule R (M →ₗ[R] A) :=
   Submodule.span R
     {f' | ∃ x m₂, f' = LinearMap.lcomp R _ (f.bilin.flip m₂) (LinearMap.mulRight R x)}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.privateInPublic true in
 /-- An auxiliary bilinear map that is later passed into `CliffordAlgebra.foldr`. Our desired result
 is stored in the `A` part of the accumulator, while auxiliary recursion state is stored in the `S f`
@@ -206,7 +202,6 @@ def aux (f : EvenHom Q A) : CliffordAlgebra.even Q →ₗ[R] A := by
 theorem aux_one : aux f 1 = 1 :=
   congr_arg Prod.fst (foldr_one _ _ _ _)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem aux_ι (m₁ m₂ : M) : aux f ((even.ι Q).bilin m₁ m₂) = f.bilin m₁ m₂ := by
   rw [CliffordAlgebra.even.lift.aux_apply]
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
index e65e8b2ed..5dbfba999 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
@@ -61,7 +61,6 @@ def e0 : CliffordAlgebra (Q' Q) :=
 def v : M →ₗ[R] CliffordAlgebra (Q' Q) :=
   ι (Q' Q) ∘ₗ LinearMap.inl _ _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem ι_eq_v_add_smul_e0 (m : M) (r : R) : ι (Q' Q) (m, r) = v Q m + r • e0 Q := by
   rw [e0, v, LinearMap.comp_apply, LinearMap.inl_apply, ← map_smul, Prod.smul_mk,
     smul_zero, smul_eq_mul, mul_one, ← map_add, Prod.mk_add_mk, zero_add, add_zero]
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
index a73952ed2..9b54663a4 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
@@ -22,7 +22,6 @@ namespace CliffordAlgebra
 
 variable (Q)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If the quadratic form of a vector is invertible, then so is that vector. -/
 @[instance_reducible]
 def invertibleιOfInvertible (m : M) [Invertible (Q m)] : Invertible (ι Q m) where
@@ -43,14 +42,12 @@ theorem isUnit_ι_of_isUnit {m : M} (h : IsUnit (Q m)) : IsUnit (ι Q m) := by
   let := invertibleιOfInvertible Q m
   exact isUnit_of_invertible (ι Q m)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- $aba^{-1}$ is a vector. -/
 theorem ι_mul_ι_mul_invOf_ι (a b : M) [Invertible (ι Q a)] [Invertible (Q a)] :
     ι Q a * ι Q b * ⅟(ι Q a) = ι Q ((⅟(Q a) * QuadraticMap.polar Q a b) • a - b) := by
   rw [invOf_ι, map_smul, mul_smul_comm, ι_mul_ι_mul_ι, ← map_smul, smul_sub, smul_smul, smul_smul,
     invOf_mul_self, one_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- $a^{-1}ba$ is a vector. -/
 theorem invOf_ι_mul_ι_mul_ι (a b : M) [Invertible (ι Q a)] [Invertible (Q a)] :
     ⅟(ι Q a) * ι Q b * ι Q a = ι Q ((⅟(Q a) * QuadraticMap.polar Q a b) • a - b) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
index 349e9dc3d..ddb5782d8 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
@@ -49,7 +49,6 @@ theorem star_def' (x : CliffordAlgebra Q) : star x = involute (reverse x) :=
 @[simp]
 theorem star_ι (m : M) : star (ι Q m) = -ι Q m := by rw [star_def, involute_ι, map_neg, reverse_ι]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Note that this not match the `star_smul` implied by `StarModule`; it certainly could if we
 also conjugated all the scalars, but there appears to be nothing in the literature that advocates
 doing this. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Complex/Module.lean b/mathlib4/Mathlib/LinearAlgebra/Complex/Module.lean
index 5b0d962a8..ce14d98da 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Complex/Module.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Complex/Module.lean
@@ -497,11 +497,9 @@ section StarHomClass
 variable {B F : Type*} [AddCommGroup B] [Module ℂ B] [StarAddMonoid B] [StarModule ℂ B]
     [FunLike F A B] [StarHomClass F A B] [LinearMapClass F ℂ A B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma map_realPart (f : F) (x : A) : f (ℜ x) = ℜ (f x) := by
   simp [realPart_apply_coe, ← Complex.coe_smul, map_star]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma map_imaginaryPart (f : F) (x : A) : f (ℑ x) = ℑ (f x) := by
   simp [imaginaryPart_apply_coe, ← Complex.coe_smul, map_star]
 
@@ -655,7 +653,6 @@ lemma mem_unitary_iff_isStarNormal_and_realPart_sq_add_imaginaryPart_sq_eq_one [
     exact ⟨this, by simp [sq, ← star_mul_self_eq_realPart_sq_add_imaginaryPart_sq x, h]⟩
   · simp [← hx.star_comm_self.eq, star_mul_self_eq_realPart_sq_add_imaginaryPart_sq, ← sq, h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance {F E A : Type*} [AddCommGroup E] [PartialOrder E]
     [StarAddMonoid E] [SelfAdjointDecompose E] [Module ℂ E] [StarModule ℂ E]
     [NonUnitalRing A] [PartialOrder A] [StarRing A]
diff --git a/mathlib4/Mathlib/LinearAlgebra/Contraction.lean b/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
index 2b4a1dacd..5d357a932 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Contraction.lean
@@ -112,7 +112,6 @@ theorem map_dualTensorHom (f : Module.Dual R M) (p : P) (g : Module.Dual R N) (q
   simp only [compr₂ₛₗ_apply, mk_apply, map_tmul, dualTensorHom_apply, dualDistrib_apply,
     ← smul_tmul_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem comp_dualTensorHom (f : Module.Dual R M) (n : N) (g : Module.Dual R N) (p : P) :
@@ -122,7 +121,6 @@ theorem comp_dualTensorHom (f : Module.Dual R M) (n : N) (g : Module.Dual R N) (
   simp only [coe_comp, Function.comp_apply, dualTensorHom_apply, map_smul, LinearMap.smul_apply]
   rw [smul_comm]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- As a matrix, `dualTensorHom` evaluated on a basis element of `M* ⊗ N` is a matrix with a
 single one and zeros elsewhere -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/CrossProduct.lean b/mathlib4/Mathlib/LinearAlgebra/CrossProduct.lean
index 1602b7c69..c66be92db 100644
--- a/mathlib4/Mathlib/LinearAlgebra/CrossProduct.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/CrossProduct.lean
@@ -150,7 +150,6 @@ end LeibnizProperties
 
 -- this can also be proved via `dotProduct_eq_zero_iff` and `triple_product_eq_det`, but
 -- that would require much heavier imports.
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma crossProduct_ne_zero_iff_linearIndependent {F : Type*} [Field F] {v w : Fin 3 → F} :
     crossProduct v w ≠ 0 ↔ LinearIndependent F ![v, w] := by
   rw [not_iff_comm]
diff --git a/mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean b/mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean
index ca722c2be..1f226ab34 100644
--- a/mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/DFinsupp.lean
@@ -147,7 +147,6 @@ def linearEquivFunOnFintype [Fintype ι] : (Π₀ i, M i) ≃ₗ[R] (Π i, M i)
   map_add' _ _ := by ext; rfl
   map_smul' _ _ := by ext; rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The `DFinsupp` version of `Finsupp.lsum`.
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/Determinant.lean b/mathlib4/Mathlib/LinearAlgebra/Determinant.lean
index ac44a4ae8..c7a9c3852 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Determinant.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Determinant.lean
@@ -250,7 +250,6 @@ theorem det_comp (f g : M →ₗ[A] M) :
 theorem det_id : LinearMap.det (LinearMap.id : M →ₗ[A] M) = 1 :=
   LinearMap.det.map_one
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Multiplying a map by a scalar `c` multiplies its determinant by `c ^ dim M`. -/
 @[simp]
@@ -344,7 +343,6 @@ theorem finite_of_det_ne_one {f : M →ₗ[R] M} (hf : f.det ≠ 1) : Module.Fin
     exact Module.Finite.of_basis hs
   · classical simp [LinearMap.coe_det, H] at hf
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If the determinant of a map vanishes, then the map is not injective. -/
 theorem bot_lt_ker_of_det_eq_zero [IsDomain R] [Free R M] {f : M →ₗ[R] M} (hf : f.det = 0) :
@@ -595,7 +593,6 @@ theorem LinearMap.associated_det_comp_equiv {N : Type*} [AddCommGroup N] [Module
 
 namespace Module.Basis
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- The determinant of a family of vectors with respect to some basis, as an alternating
@@ -616,30 +613,24 @@ nonrec def det : M [⋀^ι]→ₗ[R] R where
     apply det_zero_of_row_eq hij
     rw [updateRow_ne hij.symm, updateRow_self]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_apply (v : ι → M) : e.det v = Matrix.det (e.toMatrix v) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_self : e.det e = 1 := by simp [e.det_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_isEmpty [IsEmpty ι] : e.det = AlternatingMap.constOfIsEmpty R M ι 1 := by
   ext v
   exact Matrix.det_isEmpty
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `Basis.det` is not the zero map. -/
 theorem det_ne_zero [Nontrivial R] : e.det ≠ 0 := fun h => by simpa [h] using e.det_self
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem smul_det {G} [Group G] [DistribMulAction G M] [SMulCommClass G R M]
     (g : G) (v : ι → M) :
     (g • e).det v = e.det (g⁻¹ • v) := by
   simp_rw [det_apply, toMatrix_smul_left]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem is_basis_iff_det {v : ι → M} :
     LinearIndependent R v ∧ span R (Set.range v) = ⊤ ↔ IsUnit (e.det v) := by
   constructor
@@ -658,13 +649,11 @@ theorem is_basis_iff_det {v : ι → M} :
     rw [← this]
     exact ⟨v'.linearIndependent, v'.span_eq⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isUnit_det (e' : Basis ι R M) : IsUnit (e.det e') :=
   (is_basis_iff_det e).mp ⟨e'.linearIndependent, e'.span_eq⟩
 
 end Module.Basis
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Any alternating map to `R` where `ι` has the cardinality of a basis equals the determinant
 map with respect to that basis, multiplied by the value of that alternating map on that basis. -/
 theorem AlternatingMap.eq_smul_basis_det (f : M [⋀^ι]→ₗ[R] R) : f = f e • e.det := by
@@ -690,7 +679,6 @@ variable {A : Type*} [CommRing A] [Module A M]
 
 namespace Module.Basis
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_comp (e : Basis ι A M) (f : M →ₗ[A] M) (v : ι → M) :
     e.det (f ∘ v) = (LinearMap.det f) * e.det v := by
@@ -698,7 +686,6 @@ theorem det_comp (e : Basis ι A M) (f : M →ₗ[A] M) (v : ι → M) :
     e.toMatrix_eq_toMatrix_constr (f ∘ v), e.toMatrix_eq_toMatrix_constr v, ← toMatrix_comp,
     e.constr_comp]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_comp_basis [Module A M'] (b : Basis ι A M) (b' : Basis ι A M') (f : M →ₗ[A] M') :
     b'.det (f ∘ b) = LinearMap.det (f ∘ₗ (b'.equiv b (Equiv.refl ι) : M' →ₗ[A] M)) := by
@@ -707,13 +694,11 @@ theorem det_comp_basis [Module A M'] (b : Basis ι A M) (b' : Basis ι A M') (f
   congr 1; ext i j
   rw [toMatrix_apply, LinearMap.toMatrix_apply, Function.comp_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_basis (b : Basis ι A M) (b' : Basis ι A M) :
     LinearMap.det (b'.equiv b (Equiv.refl ι)).toLinearMap = b'.det b :=
   (b.det_comp_basis b' (LinearMap.id)).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_mul_det (b b' b'' : Basis ι A M) :
     b.det b' * b'.det b'' = b.det b'' := by
   have : b'' = (b'.equiv b'' (Equiv.refl ι)).toLinearMap ∘ b' := by
@@ -721,48 +706,40 @@ theorem det_mul_det (b b' b'' : Basis ι A M) :
   conv_rhs =>
     rw [this, Basis.det_comp, det_basis, mul_comm]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_inv (b : Basis ι A M) (b' : Basis ι A M) :
     (b.isUnit_det b').unit⁻¹ = b'.det b := by
   rw [← Units.mul_eq_one_iff_inv_eq, IsUnit.unit_spec, ← det_basis, ← det_basis]
   exact LinearEquiv.det_mul_det_symm _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_reindex {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M) (v : ι' → M)
     (e : ι ≃ ι') : (b.reindex e).det v = b.det (v ∘ e) := by
   rw [det_apply, toMatrix_reindex', det_reindexAlgEquiv, det_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_reindex' {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M)
     (e : ι ≃ ι') : (b.reindex e).det = b.det.domDomCongr e :=
   AlternatingMap.ext fun _ => det_reindex _ _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_reindex_symm {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M)
     (v : ι → M) (e : ι' ≃ ι) : (b.reindex e.symm).det (v ∘ e) = b.det v := by
   rw [det_reindex, Function.comp_assoc, e.self_comp_symm, Function.comp_id]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem det_map (b : Basis ι R M) (f : M ≃ₗ[R] M') (v : ι → M') :
     (b.map f).det v = b.det (f.symm ∘ v) := by
   rw [det_apply, toMatrix_map, det_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem det_map' (b : Basis ι R M) (f : M ≃ₗ[R] M') :
     (b.map f).det = b.det.compLinearMap f.symm :=
   AlternatingMap.ext <| b.det_map f
 
 end Module.Basis
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem Pi.basisFun_det : (Pi.basisFun R ι).det = Matrix.detRowAlternating := by
   ext M
   rw [Basis.det_apply, Basis.coePiBasisFun.toMatrix_eq_transpose, det_transpose, det]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Pi.basisFun_det_apply (v : ι → ι → R) :
     (Pi.basisFun R ι).det v = (Matrix.of v).det := by
   rw [Pi.basisFun_det]
@@ -770,7 +747,6 @@ theorem Pi.basisFun_det_apply (v : ι → ι → R) :
 
 namespace Module.Basis
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If we fix a background basis `e`, then for any other basis `v`, we can characterise the
 coordinates provided by `v` in terms of determinants relative to `e`. -/
 theorem det_smul_mk_coord_eq_det_update {v : ι → M} (hli : LinearIndependent R v)
@@ -786,7 +762,6 @@ theorem det_smul_mk_coord_eq_det_update {v : ι → M} (hli : LinearIndependent
   · rw [mk_coord_apply_ne hik, mul_zero, eq_comm]
     exact e.det.map_eq_zero_of_eq _ (by simp [hik]) hik
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a basis is multiplied columnwise by scalars `w : ι → Rˣ`, then the determinant with respect
 to this basis is multiplied by the product of the inverse of these scalars. -/
 theorem det_unitsSMul (e : Basis ι R M) (w : ι → Rˣ) :
@@ -799,13 +774,11 @@ theorem det_unitsSMul (e : Basis ι R M) (w : ι → Rˣ) :
   convert! Matrix.det_mul_column (fun i => (↑(w i)⁻¹ : R)) fun i j => e.repr (f j) i
   simp [← Finset.prod_inv_distrib]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The determinant of a basis constructed by `unitsSMul` is the product of the given units. -/
 @[simp]
 theorem det_unitsSMul_self (w : ι → Rˣ) : e.det (e.unitsSMul w) = ∏ i, (w i : R) := by
   simp [det_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The determinant of a basis constructed by `isUnitSMul` is the product of the given units. -/
 @[simp]
 theorem det_isUnitSMul {w : ι → R} (hw : ∀ i, IsUnit (w i)) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Basic.lean
index f078a60e2..f6e875d4f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Basic.lean
@@ -176,7 +176,6 @@ theorem Module.one_le_rank_iff : 1 ≤ Module.rank R M ↔ ∃ f : R →ₗ[R] M
   · exact ⟨f ∘ₗ _, by apply hf.comp (LinearEquiv.piUnique R ..).symm.injective⟩
   · exact ⟨f ∘ₗ _, hf.comp (LinearEquiv.piUnique R ..).injective⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Module.rank_eq_zero_of_not_faithfulSMul (h : ¬ FaithfulSMul R M) : Module.rank R M = 0 := by
   contrapose! h
   obtain ⟨f, hf⟩ := by rwa [← Cardinal.one_le_iff_ne_zero, one_le_rank_iff] at h
@@ -250,7 +249,6 @@ theorem rank_eq_of_equiv_equiv (i : R → R') (j : M ≃+ M₁)
 end
 end Semiring
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- TODO: prove that nontrivial commutative semirings satisfy the strong rank condition,
 following *Free sets and free subsemimodules in a semimodule* by Yi-Jia Tan, Theorem 3.2.
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Constructions.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Constructions.lean
index c7db4e09e..b3f30440e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Constructions.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Constructions.lean
@@ -48,7 +48,6 @@ section Quotient
 variable [Ring R] [CommRing S] [AddCommGroup M] [AddCommGroup M'] [AddCommGroup M₁]
 variable [Module R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem LinearIndependent.sumElim_of_quotient
     {M' : Submodule R M} {ι₁ ι₂} {f : ι₁ → M'} (hf : LinearIndependent R f) (g : ι₂ → M)
@@ -605,7 +604,6 @@ theorem sumQuot_repr_left (i : m) :
     (sumQuot bW bQ).repr (bW i) = Finsupp.single (Sum.inl i) 1 := by
   rw [← Module.Basis.apply_eq_iff, sumQuot_inl]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem sumQuot_repr_inl (w : W) (i : m) :
     (sumQuot bW bQ).repr w (Sum.inl i) = bW.repr w i := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Free.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Free.lean
index 99a672166..0f0b6dcf8 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Free.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Free.lean
@@ -385,7 +385,6 @@ theorem _root_.OrzechProperty.bijective_of_surjective_of_finrank_le
 variable {R : Type*} [CommSemiring R] [StrongRankCondition R]
     {M : Type*} [AddCommMonoid M] [Module R M] [Module.Free R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem _root_.LinearMap.existsUnique_eq_smul_id_of_finrank_eq_one
     (d1 : Module.finrank R M = 1) (u : M →ₗ[R] M) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/RankNullity.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/RankNullity.lean
index e96c64c24..b3575ffea 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/RankNullity.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/RankNullity.lean
@@ -187,7 +187,6 @@ theorem exists_linearIndependent_pair_of_one_lt_rank [IsDomain R] [StrongRankCon
   rw [this] at hy
   exact ⟨y, hy⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem Submodule.exists_smul_notMem_of_rank_lt {N : Submodule R M}
     (h : Module.rank R N < Module.rank R M) : ∃ m : M, ∀ r : R, r ≠ 0 → r • m ∉ N := by
@@ -278,7 +277,6 @@ open Submodule Module
 
 variable [StrongRankCondition R] [Module.Finite R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Submodule.exists_of_finrank_lt (N : Submodule R M) (h : finrank R N < finrank R M) :
     ∃ m : M, ∀ r : R, r ≠ 0 → r • m ∉ N := by
   obtain ⟨s, hs, hs'⟩ :=
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Basic.lean
index c85f92225..4cb0e2591 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Basic.lean
@@ -24,7 +24,6 @@ public section
 
 open Submodule
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem rank_quotient_eq_of_le_torsion {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
     {M' : Submodule R M} (hN : M' ≤ torsion R M) : Module.rank R (M ⧸ M') = Module.rank R M :=
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Finite.lean b/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Finite.lean
index cccb40e4c..edeb022d8 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Finite.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dimension/Torsion/Finite.lean
@@ -15,7 +15,6 @@ public import Mathlib.LinearAlgebra.Dimension.Finite
 
 public section
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A torsion module has rank zero. -/
 theorem Module.IsTorsion.rank_eq_zero {R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
     [Nontrivial R] (h : IsTorsion R M) : Module.rank R M = 0 := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/DirectSum/Finsupp.lean b/mathlib4/Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
index 2afe4b844..d20ee7574 100644
--- a/mathlib4/Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
@@ -124,7 +124,6 @@ lemma finsuppRight_symm_apply_single (i : ι) (m : M) (n : N) :
       m ⊗ₜ[R] Finsupp.single i n := by
   simp [LinearEquiv.symm_apply_eq]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma finsuppLeft_smul' (s : S) (t : (ι →₀ M) ⊗[R] N) :
     finsuppLeft R S M N ι (s • t) = s • finsuppLeft R S M N ι t := by
@@ -191,7 +190,6 @@ lemma finsuppScalarRight_symm_apply_single (i : ι) (m : M) :
       m ⊗ₜ[R] (Finsupp.single i 1) := by
   simp [finsuppScalarRight, finsuppRight_symm_apply_single]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem finsuppScalarRight_smul (s : S) (t) :
     finsuppScalarRight R S M ι (s • t) = s • finsuppScalarRight R S M ι t := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dual/Basis.lean b/mathlib4/Mathlib/LinearAlgebra/Dual/Basis.lean
index d4e5deda3..12aa75e01 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dual/Basis.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dual/Basis.lean
@@ -57,7 +57,6 @@ theorem toDual_apply (i j : ι) : b.toDual (b i) (b j) = if i = j then 1 else 0
   rw [toDual, constr_basis b, constr_basis b]
   simp only [eq_comm]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem toDual_linearCombination_left (f : ι →₀ R) (i : ι) :
@@ -66,7 +65,6 @@ theorem toDual_linearCombination_left (f : ι →₀ R) (i : ι) :
   simp_rw [map_smul, LinearMap.smul_apply, toDual_apply, smul_eq_mul, mul_boole,
     Finset.sum_ite_eq', Finsupp.if_mem_support]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem toDual_linearCombination_right (f : ι →₀ R) (i : ι) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean
index a751fe2fa..8ce80686f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Dual/Defs.lean
@@ -178,7 +178,6 @@ theorem Module.Dual.eval_naturality (f : M₁ →ₗ[R] M₂) :
     f.dualMap.dualMap ∘ₗ eval R M₁ = eval R M₂ ∘ₗ f := by
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma Dual.apply_one_mul_eq (f : Dual R R) (r : R) :
     f 1 * r = f r := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Eigenspace/Matrix.lean b/mathlib4/Mathlib/LinearAlgebra/Eigenspace/Matrix.lean
index 31b548fb4..574408a89 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Eigenspace/Matrix.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Eigenspace/Matrix.lean
@@ -96,7 +96,6 @@ lemma iSup_eigenspace_toLin'_diagonal_eq_top :
     ⨆ μ, eigenspace (diagonal d).toLin' μ = ⊤ :=
   iSup_eigenspace_toLin_diagonal_eq_top d <| Pi.basisFun R n
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 lemma maxGenEigenspace_toLin_diagonal_eq_eigenspace [IsDomain R] :
diff --git a/mathlib4/Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean b/mathlib4/Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
index 321794e8b..c615bc9bd 100644
--- a/mathlib4/Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
@@ -40,7 +40,6 @@ namespace ExteriorAlgebra
 
 open CliffordAlgebra hiding ι
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Build a map out of the exterior algebra given a collection of alternating maps acting on each
 exterior power -/
 def liftAlternating : (∀ i, M [⋀^Fin i]→ₗ[R] N) →ₗ[R] ExteriorAlgebra R M →ₗ[R] N := by
@@ -86,7 +85,6 @@ theorem liftAlternating_one (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) :
   dsimp [liftAlternating]
   rw [foldl_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem liftAlternating_algebraMap (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) (r : R) :
     liftAlternating (R := R) (M := M) (N := N) f (algebraMap _ (ExteriorAlgebra R M) r) =
@@ -110,7 +108,6 @@ theorem liftAlternating_comp_ιMulti {n : ℕ} (f : ∀ i, M [⋀^Fin i]→ₗ[R
     (liftAlternating (R := R) (M := M) (N := N) f).compAlternatingMap (ιMulti R n) = f n :=
   AlternatingMap.ext <| liftAlternating_apply_ιMulti f
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem liftAlternating_comp (g : N →ₗ[R] N') (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) :
     (liftAlternating (R := R) (M := M) (N := N') fun i => g.compAlternatingMap (f i)) =
@@ -138,7 +135,6 @@ theorem liftAlternating_ιMulti :
   | ι_mul _ _ hx => simp_rw [liftAlternating_ι_mul, ιMulti_succ_curryLeft, liftAlternating_comp,
       LinearMap.comp_apply, LinearMap.mulLeft_apply, hx]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `ExteriorAlgebra.liftAlternating` is an equivalence. -/
 @[simps apply symm_apply]
 def liftAlternatingEquiv : (∀ i, M [⋀^Fin i]→ₗ[R] N) ≃ₗ[R] ExteriorAlgebra R M →ₗ[R] N where
diff --git a/mathlib4/Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean
index a7047bb64..8a8923035 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean
@@ -124,7 +124,6 @@ theorem exists_relation_sum_zero_pos_coefficient_of_finrank_succ_lt_card [Finite
 
 end
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- In a vector space with dimension 1, each set `{v}` is a basis for `v ≠ 0`. -/
 @[simps repr_apply]
diff --git a/mathlib4/Mathlib/LinearAlgebra/FiniteSpan.lean b/mathlib4/Mathlib/LinearAlgebra/FiniteSpan.lean
index 8358e6c31..bf11e9854 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FiniteSpan.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FiniteSpan.lean
@@ -20,7 +20,6 @@ public section
 open Set Function
 open Submodule (span)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A linear equivalence which preserves a finite spanning set must have finite order. -/
 lemma LinearEquiv.isOfFinOrder_of_finite_of_span_eq_top_of_mapsTo
diff --git a/mathlib4/Mathlib/LinearAlgebra/Finsupp/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/Finsupp/Defs.lean
index 6e9bd8fdc..51d89abaf 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Finsupp/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Finsupp/Defs.lean
@@ -107,7 +107,6 @@ theorem lhom_ext' ⦃φ ψ : (α →₀ M) →ₛₗ[σ₁₂] N⦄ (h : ∀ a,
 def lapply (a : α) : (α →₀ M) →ₗ[R] M :=
   { Finsupp.applyAddHom a with map_smul' := fun _ _ => rfl }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance [Nonempty α] [FaithfulSMul R M] : FaithfulSMul R (α →₀ M) :=
   .of_injective (Finsupp.lsingle <| Classical.arbitrary _) (Finsupp.single_injective _)
 
@@ -328,7 +327,6 @@ namespace Module.End
 
 variable (ι : Type*) {R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `M` is an `R`-module and `ι` is a type, then an additive endomorphism of `M` that
 commutes with all `R`-endomorphisms of `M` gives rise to an additive endomorphism of `ι →₀ M`
 that commutes with all `R`-endomorphisms of `ι →₀ M`. -/
@@ -350,7 +348,6 @@ that commutes with all `R`-endomorphisms of `ι →₀ M`. -/
 
 variable {ι}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `M` is an `R`-module and `ι` is a nonempty type, then every additive endomorphism
 of `ι →₀ M` that commutes with all `R`-endomorphisms of `ι →₀ M` comes from an additive
 endomorphism of `M` that commutes with all `R`-endomorphisms of `M`.
diff --git a/mathlib4/Mathlib/LinearAlgebra/Finsupp/VectorSpace.lean b/mathlib4/Mathlib/LinearAlgebra/Finsupp/VectorSpace.lean
index 92ff4d74e..ad172b4c2 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Finsupp/VectorSpace.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Finsupp/VectorSpace.lean
@@ -206,7 +206,6 @@ section Algebra
 
 variable {R S : Type*} [CommRing R] [Ring S] [Algebra R S] {ι : Type*} (B : Basis ι R S)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- For any `r : R`, `s : S`, we have
   `B.repr ((algebra_map R S r) * s) i = r * (B.repr s i) `. -/
 theorem Module.Basis.repr_smul' (i : ι) (r : R) (s : S) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Basic.lean
index 3535cbe1f..5bfdafe4f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Basic.lean
@@ -110,7 +110,6 @@ instance [Nontrivial M] : Nonempty (Module.Free.ChooseBasisIndex R M) :=
 theorem infinite [Infinite R] [Nontrivial M] : Infinite M :=
   (Equiv.infinite_iff (chooseBasis R M).repr.toEquiv).mpr Finsupp.infinite_of_right
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance [Nontrivial M] : FaithfulSMul R M :=
   .of_injective _ (chooseBasis R M).repr.symm.injective
 
@@ -180,7 +179,6 @@ open Finset
 
 variable {S : Type*} [CommRing R] [Ring S] [Algebra R S]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable {R} in
 /-- If `B` is a basis of the `R`-algebra `S` such that `B i = 1` for some index `i`, then
diff --git a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Finite/CardQuotient.lean b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Finite/CardQuotient.lean
index 50d63e97c..d553504c2 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Finite/CardQuotient.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Finite/CardQuotient.lean
@@ -28,7 +28,6 @@ section Submodule
 
 variable {M : Type*} [AddCommGroup M] [Module.Free ℤ M] [Module.Finite ℤ M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `e : M ≃ N` be an additive isomorphism (therefore a `ℤ`-linear equiv).
 Then an alternative way to compute the cardinality of the quotient `M ⧸ N` is given by taking
 the determinant of `e`.
diff --git a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Int.lean b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Int.lean
index 3ae8a4fd3..4edf34a66 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FreeModule/Int.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FreeModule/Int.lean
@@ -26,7 +26,6 @@ namespace Module.Basis.SmithNormalForm
 
 variable [Fintype ι]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a submodule `N` in Smith normal form of a free `R`-module, its index as an additive
 subgroup is an appropriate power of the cardinality of `R` multiplied by the product of the
diff --git a/mathlib4/Mathlib/LinearAlgebra/FreeModule/PID.lean b/mathlib4/Mathlib/LinearAlgebra/FreeModule/PID.lean
index 459c1090d..b58768eeb 100644
--- a/mathlib4/Mathlib/LinearAlgebra/FreeModule/PID.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/FreeModule/PID.lean
@@ -138,7 +138,6 @@ theorem generator_maximal_submoduleImage_dvd {N O : Submodule R M} (hNO : N ≤
 
 variable [IsDomain R]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The induction hypothesis of `Submodule.basisOfPid` and `Submodule.smithNormalForm`.
 
@@ -423,7 +422,6 @@ namespace Module.Basis.SmithNormalForm
 
 variable {n : ℕ} {N : Submodule R M} (snf : Basis.SmithNormalForm N ι n) (m : N)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma repr_eq_zero_of_notMem_range {i : ι} (hi : i ∉ Set.range snf.f) :
     snf.bM.repr m i = 0 := by
@@ -436,7 +434,6 @@ lemma le_ker_coord_of_notMem_range {i : ι} (hi : i ∉ Set.range snf.f) :
     N ≤ LinearMap.ker (snf.bM.coord i) :=
   fun m hm ↦ snf.repr_eq_zero_of_notMem_range ⟨m, hm⟩ hi
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma repr_apply_embedding_eq_repr_smul {i : Fin n} :
     snf.bM.repr m (snf.f i) = snf.bN.repr (snf.a i • m) i := by
@@ -453,14 +450,12 @@ set_option backward.isDefEq.respectTransparency false in
     Finsupp.mem_support_iff, ite_not, mul_comm, ite_eq_right_iff]
   exact fun a ↦ (mul_eq_zero_of_right _ a).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma repr_comp_embedding_eq_smul :
     snf.bM.repr m ∘ snf.f = snf.a • (snf.bN.repr m : Fin n → R) := by
   ext i
   simp [Pi.smul_apply (snf.a i)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma coord_apply_embedding_eq_smul_coord {i : Fin n} :
     snf.bM.coord (snf.f i) ∘ₗ N.subtype = snf.a i • snf.bN.coord i := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/GeneralLinearGroup/AlgEquiv.lean b/mathlib4/Mathlib/LinearAlgebra/GeneralLinearGroup/AlgEquiv.lean
index 71de53225..27ba036b5 100644
--- a/mathlib4/Mathlib/LinearAlgebra/GeneralLinearGroup/AlgEquiv.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/GeneralLinearGroup/AlgEquiv.lean
@@ -28,7 +28,6 @@ open Module LinearMap LinearEquiv
 variable {K V W : Type*} [Semifield K] [AddCommMonoid V] [Module K V] [Projective K V]
   [AddCommMonoid W] [Module K W] [Projective K W]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given an algebra isomorphism `f : End K V ≃ₐ[K] End K W`, there exists a linear isomorphism `T`
 such that `f` is given by `x ↦ T ∘ₗ x ∘ₗ T.symm`. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/InvariantBasisNumber.lean b/mathlib4/Mathlib/LinearAlgebra/InvariantBasisNumber.lean
index b31b5bc89..61512f8a3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/InvariantBasisNumber.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/InvariantBasisNumber.lean
@@ -279,7 +279,6 @@ private def induced_map (I : Ideal R) (e : (ι → R) →ₗ[R] ι' → R) :
       rw [← map_sub]
       exact Ideal.map_pi _ _ hab e h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An isomorphism of `R`-modules `R^n ≃ R^m` induces an isomorphism of `R/I`-modules
     `R^n/I^n ≃ R^m/I^m`. -/
 private def inducedEquiv [Fintype ι'] (I : Ideal R) (e : (ι → R) ≃ₗ[R] ι' → R) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean b/mathlib4/Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean
index 9f0029f3a..300b8a01f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean
@@ -491,7 +491,6 @@ lemma linearIndependent_algHom_toLinearMap' (K M L) [CommRing K] [IsDomain K]
     LinearIndependent K (AlgHom.toLinearMap : (M →ₐ[K] L) → M →ₗ[K] L) :=
   (linearIndependent_algHom_toLinearMap K M L).restrict_scalars' K
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma LinearMap.injective_of_linearIndependent {N : Type*} [AddCommGroup N] [Module R N]
     {f : M →ₗ[R] N} {ι : Type*} {v : ι → M}
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/Adjugate.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/Adjugate.lean
index cd2bee239..6f4e185c3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/Adjugate.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/Adjugate.lean
@@ -255,7 +255,6 @@ theorem cramer_eq_adjugate_mulVec (A : Matrix n n α) (b : n → α) :
   ext k
   simp [mulVec, dotProduct, mul_comm]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mul_adjugate_apply (A : Matrix n n α) (i j k) :
     A i k * adjugate A k j = cramer Aᵀ (Pi.single k (A i k)) j := by
   rw [← smul_eq_mul, adjugate, of_apply, ← Pi.smul_apply, ← map_smul, ← Pi.single_smul',
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/Basis.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/Basis.lean
index c39d85b4d..b1078913d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/Basis.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/Basis.lean
@@ -83,7 +83,6 @@ theorem toMatrix_update [DecidableEq ι'] (x : M) :
   · rw [h, update_self j x v]
   · rw [update_of_ne h]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The basis constructed by `unitsSMul` has vectors given by a diagonal matrix. -/
 @[simp]
@@ -124,7 +123,6 @@ theorem toLin_toMatrix [Finite ι] [Fintype ι'] [DecidableEq ι'] (v : Basis ι
     Matrix.toLin v e (e.toMatrix v) = LinearMap.id :=
   v.ext fun i => by cases nonempty_fintype ι; rw [toLin_self, id_apply, e.sum_toMatrix_smul_self]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- From a basis `e : ι → M`, build a linear equivalence between families of vectors `v : ι → M`,
 and matrices, making the matrix whose columns are the vectors `v i` written in the basis `e`. -/
 def toMatrixEquiv [Fintype ι] (e : Basis ι R M) : (ι → M) ≃ₗ[R] Matrix ι ι R where
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
index 319acb4a4..d9cb65f1a 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
@@ -123,7 +123,6 @@ theorem Matrix.Represents.zero : (0 : Matrix ι ι R).Represents b 0 := by
   delta Matrix.Represents
   rw [map_zero, map_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Matrix.Represents.smul {A : Matrix ι ι R} {f : Module.End R M} (h : A.Represents b f)
     (r : R) : (r • A).Represents b (r • f) := by
   delta Matrix.Represents at h ⊢
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/Rank.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/Rank.lean
index 11e7ebfa9..49063b03a 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/Rank.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/Rank.lean
@@ -344,7 +344,6 @@ theorem eRank_reindex {m₀ : Type um} {n : Type un} [Semiring R] (A : Matrix m
     (en : n ≃ n₀) : eRank (A.reindex em en) = eRank A :=
   eRank_submatrix ..
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The rank of a matrix equals the dimension of the range of the corresponding linear map,
 and is therefore independent of the choice of bases. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/ToLin.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/ToLin.lean
index af976f5e7..f5cf502db 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/ToLin.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/ToLin.lean
@@ -478,7 +478,6 @@ theorem LinearMap.toMatrix'_mul [Fintype m] [DecidableEq m] (f g : (m → R) →
     LinearMap.toMatrix' (f * g) = LinearMap.toMatrix' f * LinearMap.toMatrix' g :=
   LinearMap.toMatrix'_comp f g
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem LinearMap.toMatrix'_algebraMap (x : R) :
@@ -653,7 +652,6 @@ lemma LinearMap.toMatrix_singleton {ι : Type*} [Unique ι] (f : R →ₗ[R] R)
 theorem Matrix.toLin_one : Matrix.toLin v₁ v₁ 1 = LinearMap.id := by
   rw [← LinearMap.toMatrix_id v₁, Matrix.toLin_toMatrix]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem Matrix.toLin_scalar (r : R) : Matrix.toLin v₁ v₁ (scalar n r) = r • LinearMap.id :=
   (LinearMap.toMatrix v₁ v₁).injective (by simp [toMatrix_id, smul_one_eq_diagonal])
@@ -664,7 +662,6 @@ theorem LinearMap.toMatrix_reindexRange [DecidableEq M₁] (f : M₁ →ₗ[R] M
       LinearMap.toMatrix v₁ v₂ f k i := by
   simp_rw [LinearMap.toMatrix_apply, Basis.reindexRange_self, Basis.reindexRange_repr]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem LinearMap.toMatrix_algebraMap (x : R) :
@@ -719,7 +716,6 @@ variable {l m n : Type*} [Fintype n] [DecidableEq n]
 variable {M₁ M₂ : Type*} [AddCommMonoid M₁] [AddCommMonoid M₂] [Module R M₁] [Module R M₂]
 variable (v₁ : Basis n R M₁) (v₂ : Basis m R M₂)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The matrix of `toSpanSingleton R M₂ x` given by bases `v₁` and `v₂` is equal to
 `vecMulVec (v₂.repr x) v₁`. When `v₁ = Module.Basis.singleton`
@@ -728,7 +724,6 @@ theorem LinearMap.toMatrix_toSpanSingleton [Finite m] (v₁ : Basis n R R) (v₂
     (x : M₂) : (toSpanSingleton R M₂ x).toMatrix v₁ v₂ = vecMulVec (v₂.repr x) v₁ := by
   ext; simp [toMatrix_apply, vecMulVec_apply, mul_comm]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 lemma LinearMap.toMatrix_smulRight [Finite m] (f : M₁ →ₗ[R] R) (x : M₂) :
@@ -916,7 +911,6 @@ theorem Matrix.toLin_finTwoProd (a b c d : R) :
         (c • LinearMap.fst R R R + d • LinearMap.snd R R R) :=
   LinearMap.ext <| Matrix.toLin_finTwoProd_apply _ _ _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toMatrix_distrib_mul_action_toLinearMap (x : R) :
     LinearMap.toMatrix v₁ v₁ (DistribSMul.toLinearMap R M₁ x) =
@@ -1008,7 +1002,6 @@ variable {A M n : Type*} [Fintype n] [DecidableEq n]
   [CommSemiring A] [AddCommMonoid M] [Module R M] [Module A M] [Algebra R A] [IsScalarTower R A M]
   (bA : Basis m R A) (bM : Basis n A M)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma _root_.LinearMap.restrictScalars_toMatrix (f : M →ₗ[A] M) :
     (f.restrictScalars R).toMatrix (bA.smulTower' bM) (bA.smulTower' bM) =
@@ -1025,7 +1018,6 @@ variable [Algebra R S] [Algebra S T] [Algebra R T] [IsScalarTower R S T]
 variable {m n : Type*} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n]
 variable (b : Basis m R S) (c : Basis n S T)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem smulTower_leftMulMatrix (x) (ik jk) :
     leftMulMatrix (b.smulTower c) x ik jk =
diff --git a/mathlib4/Mathlib/LinearAlgebra/Matrix/ZMatrix.lean b/mathlib4/Mathlib/LinearAlgebra/Matrix/ZMatrix.lean
index e0dcac1b6..ce22815bd 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Matrix/ZMatrix.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Matrix/ZMatrix.lean
@@ -36,7 +36,6 @@ public lemma diag_pos_of_mul_diagonal_posDef (i : ι) :
   rw [← mul_pos_iff_of_pos_left (hD i)]
   simpa using hA.2 (x := Finsupp.single i 1) (by simp)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A spectral bound result for Z-matrices satisfying a positive-definiteness condition.
 
 It is important because it applies to Cartan matrices, and shows that all (real) eigenvalues must
diff --git a/mathlib4/Mathlib/LinearAlgebra/Multilinear/DFinsupp.lean b/mathlib4/Mathlib/LinearAlgebra/Multilinear/DFinsupp.lean
index 5afa234bd..18309fef9 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Multilinear/DFinsupp.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Multilinear/DFinsupp.lean
@@ -269,7 +269,6 @@ theorem freeDFinsuppEquiv_def (f : Π₀ (_ : (Π i, κ i) × ι'), R) :
       (DFinsupp.domLCongr (R := R) (Equiv.sigmaEquivProd _ _).symm) f) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /--
 When `freeDFinsuppEquiv` is applied to a map with a single value of one the resulting multilinear
diff --git a/mathlib4/Mathlib/LinearAlgebra/PerfectPairing/Restrict.lean b/mathlib4/Mathlib/LinearAlgebra/PerfectPairing/Restrict.lean
index 471a285f4..ad8616d8d 100644
--- a/mathlib4/Mathlib/LinearAlgebra/PerfectPairing/Restrict.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/PerfectPairing/Restrict.lean
@@ -83,7 +83,6 @@ variable {S M' N' : Type*}
   [AddCommGroup M'] [Module S M'] [AddCommGroup N'] [Module S N']
   (i : M' →ₗ[S] M) (j : N' →ₗ[S] N)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 private lemma restrictScalars_injective_aux
     (hi : Injective i)
diff --git a/mathlib4/Mathlib/LinearAlgebra/Pi.lean b/mathlib4/Mathlib/LinearAlgebra/Pi.lean
index 272b09ad5..e213045ff 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Pi.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Pi.lean
@@ -354,7 +354,6 @@ theorem proj_comp_single (i j : ι) : (proj i).comp (single R φ j) = diag j i :
 
 end
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear map `f` applied to `x : ι → R` can be computed using the image under `f` of elements
 of the canonical basis. -/
 theorem pi_apply_eq_sum_univ [Fintype ι] (f : (ι → R) →ₗ[R] M₂) (x : ι → R) :
@@ -462,7 +461,6 @@ variable [(i : ι) → AddCommMonoid (φ i)] [(i : ι) → Module R (φ i)]
 variable [(i : ι) → AddCommMonoid (ψ i)] [(i : ι) → Module R (ψ i)]
 variable [(i : ι) → AddCommMonoid (χ i)] [(i : ι) → Module R (χ i)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Combine a family of linear equivalences into a linear equivalence of `pi`-types.
 
diff --git a/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Basic.lean
index 1d7021c2a..b6900cd03 100644
--- a/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/PiTensorProduct/Basic.lean
@@ -645,7 +645,6 @@ theorem piTensorHomMapFun₂_add (φ ψ : ⨂[R] i, s i →ₗ[R] t i →ₗ[R]
   dsimp [piTensorHomMapFun₂]; ext; simp only [map_add, LinearMap.compMultilinearMap_apply,
     lift.tprod, add_apply, LinearMap.add_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem piTensorHomMapFun₂_smul (r : R) (φ : ⨂[R] i, s i →ₗ[R] t i →ₗ[R] t' i) :
     piTensorHomMapFun₂ (r • φ) = r • piTensorHomMapFun₂ φ := by
@@ -774,7 +773,6 @@ theorem map_reindex_symm (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) (x : 
 
 variable (ι)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local simp] eq_iff_true_of_subsingleton in
 /-- The tensor product over an empty index type `ι` is isomorphic to the base ring. -/
 @[simps symm_apply]
@@ -842,7 +840,6 @@ section tmulEquivDep
 
 variable (N : ι ⊕ ι₂ → Type*) [∀ i, AddCommMonoid (N i)] [∀ i, Module R (N i)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Equivalence between a `TensorProduct` of `PiTensorProduct`s and a single
 `PiTensorProduct` indexed by a `Sum` type. If `N` is a constant family of
diff --git a/mathlib4/Mathlib/LinearAlgebra/Prod.lean b/mathlib4/Mathlib/LinearAlgebra/Prod.lean
index 97e683d25..181a08d69 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Prod.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Prod.lean
@@ -90,7 +90,6 @@ theorem fst_surjective : Function.Surjective (fst R M M₂) := fun x => ⟨(x, 0
 
 theorem snd_surjective : Function.Surjective (snd R M M₂) := fun x => ⟨(0, x), rfl⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The prod of two linear maps is a linear map. -/
 @[simps]
@@ -882,7 +881,6 @@ section Graph
 variable [Semiring R] [AddCommMonoid M] [AddCommMonoid M₂] [AddCommGroup M₃] [AddCommGroup M₄]
   [Module R M] [Module R M₂] [Module R M₃] [Module R M₄] (f : M →ₗ[R] M₂) (g : M₃ →ₗ[R] M₄)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Graph of a linear map. -/
 def graph : Submodule R (M × M₂) where
   carrier := { p | p.2 = f p.1 }
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
index a2f63cdf3..d88d051e3 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@@ -536,7 +536,6 @@ section Comp
 variable [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N]
 variable [AddCommMonoid P] [Module R P]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Compose the quadratic map with a linear function on the right. -/
 def comp (Q : QuadraticMap R N P) (f : M →ₗ[R] N) : QuadraticMap R M P where
   toFun x := Q (f x)
@@ -545,12 +544,10 @@ def comp (Q : QuadraticMap R N P) (f : M →ₗ[R] N) : QuadraticMap R M P where
     let ⟨B, h⟩ := Q.exists_companion
     ⟨B.compl₁₂ f f, fun x y => by simp_rw [f.map_add]; exact h (f x) (f y)⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem comp_apply (Q : QuadraticMap R N P) (f : M →ₗ[R] N) (x : M) : (Q.comp f) x = Q (f x) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Compose a quadratic map with a linear function on the left. -/
 @[simps +simpRhs]
 def _root_.LinearMap.compQuadraticMap (f : N →ₗ[R] P) (Q : QuadraticMap R M N) :
@@ -623,7 +620,6 @@ theorem linMulLin_add (f g h : M →ₗ[R] A) : linMulLin f (g + h) = linMulLin
 
 variable {N' : Type*} [AddCommMonoid N'] [Module R N']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem linMulLin_comp (f g : M →ₗ[R] A) (h : N' →ₗ[R] M) :
     (linMulLin f g).comp h = linMulLin (f.comp h) (g.comp h) :=
@@ -675,7 +671,6 @@ section Semiring
 variable [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N]
 variable {N' : Type*} [AddCommMonoid N'] [Module R N']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A bilinear map gives a quadratic map by applying the argument twice. -/
 def toQuadraticMap (B : BilinMap R M N) : QuadraticMap R M N where
@@ -683,12 +678,10 @@ def toQuadraticMap (B : BilinMap R M N) : QuadraticMap R M N where
   toFun_smul a x := by simp only [map_smul, LinearMap.smul_apply, smul_smul]
   exists_companion' := ⟨B + LinearMap.flip B, fun x y => by simp [add_add_add_comm, add_comm]⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_apply (B : BilinMap R M N) (x : M) : B.toQuadraticMap x = B x x :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toQuadraticMap_comp_same (B : BilinMap R M N) (f : N' →ₗ[R] M) :
     BilinMap.toQuadraticMap (B.compl₁₂ f f) = B.toQuadraticMap.comp f := rfl
 
@@ -696,20 +689,17 @@ section
 
 variable (R M)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_zero : (0 : BilinMap R M N).toQuadraticMap = 0 :=
   rfl
 
 end
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_add (B₁ B₂ : BilinMap R M N) :
     (B₁ + B₂).toQuadraticMap = B₁.toQuadraticMap + B₂.toQuadraticMap :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_smul [Monoid S] [DistribMulAction S N] [SMulCommClass S R N]
     [SMulCommClass R S N] (a : S)
@@ -720,7 +710,6 @@ section
 
 variable (S R M)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `LinearMap.BilinMap.toQuadraticMap` as an additive homomorphism -/
 @[simps]
 def toQuadraticMapAddMonoidHom : (BilinMap R M N) →+ QuadraticMap R M N where
@@ -728,7 +717,6 @@ def toQuadraticMapAddMonoidHom : (BilinMap R M N) →+ QuadraticMap R M N where
   map_zero' := toQuadraticMap_zero _ _
   map_add' := toQuadraticMap_add
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `LinearMap.BilinMap.toQuadraticMap` as a linear map -/
 @[simps]
 def toQuadraticMapLinearMap [Semiring S] [Module S N] [SMulCommClass S R N] [SMulCommClass R S N] :
@@ -739,7 +727,6 @@ def toQuadraticMapLinearMap [Semiring S] [Module S N] [SMulCommClass S R N] [SMu
 
 end
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_list_sum (B : List (BilinMap R M N)) :
     B.sum.toQuadraticMap = (B.map toQuadraticMap).sum :=
@@ -755,7 +742,6 @@ theorem toQuadraticMap_sum {ι : Type*} (s : Finset ι) (B : ι → (BilinMap R
     (∑ i ∈ s, B i).toQuadraticMap = ∑ i ∈ s, (B i).toQuadraticMap :=
   map_sum (toQuadraticMapAddMonoidHom R M) B s
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_eq_zero {B : BilinMap R M N} :
     B.toQuadraticMap = 0 ↔ B.IsAlt :=
@@ -768,18 +754,15 @@ section Ring
 variable [CommRing R] [AddCommGroup M] [AddCommGroup N] [Module R M] [Module R N]
 variable {B : BilinMap R M N}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_neg (B : BilinMap R M N) : (-B).toQuadraticMap = -B.toQuadraticMap :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toQuadraticMap_sub (B₁ B₂ : BilinMap R M N) :
     (B₁ - B₂).toQuadraticMap = B₁.toQuadraticMap - B₂.toQuadraticMap :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem polar_toQuadraticMap (x y : M) : polar (toQuadraticMap B) x y = B x y + B y x := by
   simp only [polar, toQuadraticMap_apply, map_add, add_apply, add_assoc, add_comm (B y x) _,
     add_sub_cancel_left, sub_eq_add_neg _ (B y y), add_neg_cancel_left]
@@ -787,7 +770,6 @@ theorem polar_toQuadraticMap (x y : M) : polar (toQuadraticMap B) x y = B x y +
 theorem polarBilin_toQuadraticMap : polarBilin (toQuadraticMap B) = B + flip B :=
   LinearMap.ext₂ polar_toQuadraticMap
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] theorem _root_.QuadraticMap.toQuadraticMap_polarBilin (Q : QuadraticMap R M N) :
     toQuadraticMap (polarBilin Q) = 2 • Q :=
   QuadraticMap.ext fun x => (polar_self _ x).trans <| by simp
@@ -804,7 +786,6 @@ section
 
 variable {N' : Type*} [AddCommGroup N'] [Module R N']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.QuadraticMap.polarBilin_comp (Q : QuadraticMap R N' N) (f : M →ₗ[R] N') :
     polarBilin (Q.comp f) = LinearMap.compl₁₂ (polarBilin Q) f f :=
   LinearMap.ext₂ <| fun x y => by simp [polar]
@@ -911,14 +892,12 @@ lemma associated_flip : (associatedHom S Q).flip = associatedHom S Q := by
   simp only [LinearMap.flip_apply, associated_apply, add_comm, sub_eq_add_neg, add_left_comm,
     add_assoc]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem associated_comp {N' : Type*} [AddCommGroup N'] [Module R N'] (f : N' →ₗ[R] M) :
     associatedHom S (Q.comp f) = (associatedHom S Q).compl₁₂ f f := by
   ext
   simp only [associated_apply, comp_apply, map_add, LinearMap.compl₁₂_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem associated_toQuadraticMap (B : BilinMap R M N) (x y : M) :
     associatedHom S B.toQuadraticMap x y = ⅟(2 : Module.End R N) • (B x y + B y x) := by
   simp only [associated_apply, BilinMap.toQuadraticMap_apply, map_add, LinearMap.add_apply,
@@ -941,7 +920,6 @@ theorem associated_eq_self_apply (x : M) : associatedHom S Q x x = Q x := by
     add_smul, one_smul, add_sub_cancel_right, add_sub_cancel_right, two_smul, ← two_smul R,
     invOf_smul_eq_iff, two_smul, two_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toQuadraticMap_associated : (associatedHom S Q).toQuadraticMap = Q :=
   QuadraticMap.ext <| associated_eq_self_apply S Q
 
@@ -1048,7 +1026,6 @@ theorem isOrtho_comm {x y : M} : IsOrtho Q x y ↔ IsOrtho Q y x := by simp_rw [
 
 alias ⟨IsOrtho.symm, _⟩ := isOrtho_comm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.LinearMap.BilinForm.toQuadraticMap_isOrtho [IsCancelAdd R]
     [NoZeroDivisors R] [CharZero R] {B : BilinMap R M R} {x y : M} (h : B.IsSymm) :
     B.toQuadraticMap.IsOrtho x y ↔ B x y = 0 := by
@@ -1184,7 +1161,6 @@ The determinant of the matrix is the discriminant of the quadratic form.
 variable {n : Type w} [Fintype n] [DecidableEq n]
 variable [CommRing R] [AddCommMonoid M] [Module R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `M.toQuadraticForm'` is the map `fun x ↦ row x * M * col x` as a quadratic form on `n → R`. -/
 def Matrix.toQuadraticForm' (M : Matrix n n R) : QuadraticForm R (n → R) :=
   LinearMap.BilinMap.toQuadraticMap (Matrix.toLinearMap₂' R M)
@@ -1203,7 +1179,6 @@ section Rn
 def toMatrix' (Q : QuadraticForm R (n → R)) : Matrix n n R :=
   LinearMap.toMatrix₂' R Q.associated
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toMatrix'_smul (a : R) (Q : QuadraticForm R (n → R)) :
     (a • Q).toMatrix' = a • Q.toMatrix' := by
   simp [toMatrix']
@@ -1249,7 +1224,6 @@ lemma toMatrix_eq_toMatrix' (Q : QuadraticForm R (n → R)) :
   simp only [toMatrix, toMatrix']
   exact LinearEquiv.congr_arg rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toMatrix_smul (a : R) (Q : QuadraticForm R N) :
     (a • Q).toMatrix b = a • (Q.toMatrix b) := by
   simp [toMatrix]
@@ -1339,7 +1313,6 @@ section Semiring
 
 variable [CommSemiring R] [AddCommMonoid M] [Module R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 A bilinear form is separating left if the quadratic form it is associated with is anisotropic.
 -/
@@ -1364,7 +1337,6 @@ open Module
 variable {V : Type u} {K : Type v} [Field K] [AddCommGroup V] [Module K V]
 variable [FiniteDimensional K V]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a symmetric bilinear form `B` on some vector space `V` over a field `K`
 in which `2` is invertible, there exists an orthogonal basis with respect to `B`. -/
 theorem exists_orthogonal_basis [hK : Invertible (2 : K)] {B : LinearMap.BilinForm K V}
@@ -1428,7 +1400,6 @@ noncomputable def basisRepr [Finite ι] (Q : QuadraticMap R M N) (v : Basis ι R
     QuadraticMap R (ι → R) N :=
   Q.comp v.equivFun.symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem basisRepr_apply [Fintype ι] {v : Basis ι R M} (Q : QuadraticMap R M N) (w : ι → R) :
     Q.basisRepr v w = Q (∑ i : ι, w i • v i) := by
@@ -1457,7 +1428,6 @@ theorem weightedSumSquares_apply [Monoid S] [DistribMulAction S R] [SMulCommClas
     weightedSumSquares R w v = ∑ i : ι, w i • (v i * v i) :=
   sum_apply _ _ _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- On an orthogonal basis, the basis representation of `Q` is just a sum of squares. -/
 theorem basisRepr_eq_of_iIsOrtho {R M} [CommRing R] [AddCommGroup M] [Module R M]
     [Invertible (2 : R)] (Q : QuadraticForm R M) (v : Basis ι R M)
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basis.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basis.lean
index 26b2576ff..7e0dbd832 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basis.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Basis.lean
@@ -91,7 +91,6 @@ theorem toBilin_apply (Q : QuadraticMap R M N) (bm : Basis ι R M) (i j : ι) :
       if i = j then Q (bm i) else if i < j then polar Q (bm i) (bm j) else 0 := by
   simp [toBilin]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem toQuadraticMap_toBilin (Q : QuadraticMap R M N) (bm : Basis ι R M) :
     (Q.toBilin bm).toQuadraticMap = Q := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Dual.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Dual.lean
index 3c684214e..0f63ac84e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Dual.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/Dual.lean
@@ -81,7 +81,6 @@ section Semiring
 
 variable [CommSemiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The quadratic form on `Module.Dual R M × M` defined as `Q (f, x) = f x`. -/
 @[simps]
 def dualProd : QuadraticForm R (Module.Dual R M × M) where
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
index 7ac7170b0..b846483cb 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
@@ -135,7 +135,6 @@ open QuadraticForm
 
 variable {X Y Z : QuadraticModuleCat.{v} R}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Build a `QuadraticForm.IsometryEquiv` from an isomorphism in the category
 `QuadraticModuleCat R`. -/
 @[simps]
diff --git a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean
index c3f369c85..9f2013209 100644
--- a/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean
@@ -139,7 +139,6 @@ theorem associated_baseChange [Invertible (2 : A)] (Q : QuadraticForm R M₂) :
   rw [associated_tmul (QuadraticMap.sq (R := A)) Q, associated_sq]
   exact rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem polarBilin_baseChange [Invertible (2 : A)] (Q : QuadraticForm R M₂) :
     polarBilin (Q.baseChange A) = BilinForm.baseChange A (polarBilin Q) := by
   rw [QuadraticForm.baseChange, BilinForm.baseChange, polarBilin_tmul, BilinForm.tmul,
diff --git a/mathlib4/Mathlib/LinearAlgebra/Ray.lean b/mathlib4/Mathlib/LinearAlgebra/Ray.lean
index 7280d6e14..fc8688918 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Ray.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Ray.lean
@@ -176,7 +176,6 @@ theorem map (f : M →ₗ[R] N) (h : SameRay R x y) : SameRay R (f x) (f y) :=
     Or.imp (fun hy => by rw [hy, map_zero]) fun ⟨r₁, r₂, hr₁, hr₂, h⟩ =>
       ⟨r₁, r₂, hr₁, hr₂, by rw [← f.map_smul, ← f.map_smul, h]⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The images of two vectors under an injective linear map are on the same ray if and only if the
 original vectors are on the same ray. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Reflection.lean b/mathlib4/Mathlib/LinearAlgebra/Reflection.lean
index 8fee78b24..87747700e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Reflection.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Reflection.lean
@@ -85,7 +85,6 @@ lemma involutive_preReflection (h : f x = 2) :
     Involutive (preReflection x f) :=
   fun y ↦ by simp [map_sub, h, two_smul, preReflection_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma preReflection_preReflection (g : Dual R M) (h : f x = 2) :
     preReflection (preReflection x f y) (preReflection f (Dual.eval R M x) g) =
@@ -181,7 +180,6 @@ open Int Polynomial.Chebyshev
 
 variable {x y : M} {f g : Dual R M} (hf : f x = 2) (hg : g y = 2)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A formula for $(r_1 r_2)^m z$, where $m$ is a natural number and $z \in M$. -/
 lemma reflection_mul_reflection_pow_apply (m : ℕ) (z : M)
@@ -276,7 +274,6 @@ lemma reflection_mul_reflection_zpow (m : ℤ)
   ext z
   simpa using reflection_mul_reflection_zpow_apply hf hg m z t ht
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A formula for $(r_1 r_2)^m x$, where $m$ is an integer. This is the special case of
 `Module.reflection_mul_reflection_zpow_apply` with $z = x$. -/
@@ -319,7 +316,6 @@ lemma reflection_mul_reflection_pow_apply_self (m : ℕ)
       ((S R m).eval t + (S R (m - 1)).eval t) • x + ((S R (m - 1)).eval t * -g x) • y :=
   mod_cast reflection_mul_reflection_zpow_apply_self hf hg m t ht
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A formula for $r_2 (r_1 r_2)^m x$, where $m$ is an integer. -/
 lemma reflection_mul_reflection_mul_reflection_zpow_apply_self (m : ℤ)
@@ -343,7 +339,6 @@ end
 
 /-! ### Lemmas used to prove uniqueness results for root data -/
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- See also `Module.Dual.eq_of_preReflection_mapsTo'` for a variant of this lemma which
 applies when `Φ` does not span.
@@ -411,7 +406,6 @@ lemma Dual.eq_of_preReflection_mapsTo' [CharZero R] [IsDomain R] [IsTorsionFree
 variable {y}
 variable {g : Dual R M}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Composite of reflections in "parallel" hyperplanes is a shear (special case). -/
 lemma reflection_reflection_iterate
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Base.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Base.lean
index 42bf8f27b..6c7285ca5 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Base.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Base.lean
@@ -149,7 +149,6 @@ lemma span_coroot_support :
     span R (P.coroot '' b.support) = P.corootSpan R :=
   b.flip.span_root_support
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 open Finsupp in
 lemma eq_one_or_neg_one_of_mem_support_of_smul_mem_aux [Finite ι]
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/BaseExists.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/BaseExists.lean
index f0b920886..6e805b6ec 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/BaseExists.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/BaseExists.lean
@@ -196,7 +196,6 @@ lemma eq_baseOf_iff (s : Set ι) (f : M →+ ℚ)
 
 variable [P.IsReduced]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma baseOf_root_eq_baseOf_coroot_aux
     (f : M →+ ℚ) (g : N →+ ℚ) (hf : ∀ i, f (P.root i) ≠ 0)
     (hfg : ∀ i, 0 < f (P.root i) ↔ 0 < g (P.coroot i)) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Basic.lean
index 90e03cde6..86ea43557 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Basic.lean
@@ -127,7 +127,6 @@ protected lemma ext [CharZero R] [IsDomain R] [IsTorsionFree R M]
   · exact hr ▸ he ▸ P₂.coroot_root_two i
   · exact hr ▸ he ▸ P₂.mapsTo_reflection_root i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma coroot_eq_coreflection_of_root_eq' [CharZero R] [IsDomain R] [IsTorsionFree R M]
     (p : M →ₗ[R] N →ₗ[R] R) [p.IsPerfPair]
     (root : ι ↪ M)
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/CartanMatrix.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/CartanMatrix.lean
index 8e626b806..e3e3fa962 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/CartanMatrix.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/CartanMatrix.lean
@@ -331,7 +331,6 @@ variable {ι₂ M₂ N₂ : Type*} [AddCommGroup M₂] [Module R M₂] [AddCommG
   {P₂ : RootPairing ι₂ R M₂ N₂} [P₂.IsCrystallographic] (b₂ : P₂.Base)
   (e : b.support ≃ b₂.support)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma apply_mem_range_root_of_cartanMatrixEq
     (f : M ≃ₗ[R] M₂) (hf : ∀ i : b.support, f (P.root i) = P₂.root (e i))
     (m : M) (hm : m ∈ range P.root)
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Defs.lean
index c09911566..abb003188 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Defs.lean
@@ -209,7 +209,6 @@ lemma pairing_eq_add_of_root_eq_add {i j k l : ι} (h : P.root k = P.root i + P.
     P.pairing k l = P.pairing i l + P.pairing j l := by
   simp only [← root_coroot_eq_pairing, h, map_add, LinearMap.add_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable {P} in
 lemma pairing_eq_add_of_root_eq_smul_add_smul
@@ -400,7 +399,6 @@ lemma pairing_reflectionPerm_self_right (i j : ι) :
   rw [pairing, ← reflectionPerm_coroot, root_coroot_eq_pairing, pairing_same, two_smul,
     sub_add_cancel_left, map_neg, root_coroot_eq_pairing]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The indexing set of a root pairing carries an involutive negation, corresponding to the negation
 of a root / coroot. -/
@@ -413,7 +411,6 @@ of a root / coroot. -/
       sub_neg_eq_add, map_smul, smul_add]
     module
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ne_neg [NeZero (2 : R)] [IsDomain R] :
     letI := P.indexNeg
     i ≠ -i := by
@@ -502,7 +499,6 @@ lemma pairing_smul_coroot_eq (k : ι) (hij : P.reflectionPerm i = P.reflectionPe
     simp only [← coroot_reflectionPerm, hij]
   simpa only [coreflection_apply_coroot, sub_right_inj] using h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma two_nsmul_reflection_eq_of_perm_eq (hij : P.reflectionPerm i = P.reflectionPerm j) :
     2 • ⇑(P.reflection i) = 2 • P.reflection j := by
   ext x
@@ -528,7 +524,6 @@ lemma reflectionPerm_eq_reflectionPerm_iff_of_isSMulRegular (h2 : IsSMulRegular
   replace h2 : IsSMulRegular (M → M) 2 := IsSMulRegular.pi fun _ ↦ h2
   exact h2 <| P.two_nsmul_reflection_eq_of_perm_eq i j h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma reflectionPerm_eq_reflectionPerm_iff_of_span :
     P.reflectionPerm i = P.reflectionPerm j ↔
@@ -573,7 +568,6 @@ def IsOrthogonal : Prop := pairing P i j = 0 ∧ pairing P j i = 0
 lemma isOrthogonal_symm : IsOrthogonal P i j ↔ IsOrthogonal P j i := by
   simp only [IsOrthogonal, and_comm]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isOrthogonal_comm (h : IsOrthogonal P i j) : Commute (P.reflection i) (P.reflection j) := by
   rw [commute_iff_eq]
@@ -605,7 +599,6 @@ lemma IsOrthogonal.coreflection_apply_right (h : IsOrthogonal P j i) :
     P.coreflection j (P.coroot i) = P.coroot i :=
   h.flip.reflection_apply_right
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma isFixedPt_reflection_of_isOrthogonal {s : Set ι} (hj : ∀ i ∈ s, P.IsOrthogonal j i)
     {x : M} (hx : x ∈ span R (P.root '' s)) :
     IsFixedPt (P.reflection j) x := by
@@ -664,7 +657,6 @@ section Map
 
 variable {ι₂ M₂ N₂ : Type*} [AddCommGroup M₂] [Module R M₂] [AddCommGroup N₂] [Module R N₂]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Push forward a root pairing along linear equivalences, also reindexing the (co)roots. -/
 protected def map (e : ι ≃ ι₂) (f : M ≃ₗ[R] M₂) (g : N ≃ₗ[R] N₂) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean
index 28c7e8cfc..80834459f 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean
@@ -271,7 +271,6 @@ lemma rootFormIn_self_smul_coroot (i : ι) :
   intro j hj
   rw [← P.algebraMap_pairingIn S, IsScalarTower.algebraMap_smul, ← mul_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma prod_rootFormIn_smul_coroot_mem_range_PolarizationIn (i : ι) :
     (∏ j : ι, P.RootFormIn S (P.rootSpanMem S j) (P.rootSpanMem S j)) • P.coroot i ∈
       LinearMap.range (P.PolarizationIn S) := by
@@ -301,14 +300,12 @@ lemma corootForm_self_smul_root (i : ι) :
     (P.CorootForm (P.coroot i) (P.coroot i)) • P.root i = 2 • P.CoPolarization (P.coroot i) :=
   rootForm_self_smul_coroot (P.flip) i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma four_nsmul_coPolarization_compl_polarization_apply_root (i : ι) :
     (4 • P.CoPolarization ∘ₗ P.Polarization) (P.root i) =
     (P.RootForm (P.root i) (P.root i) * P.CorootForm (P.coroot i) (P.coroot i)) • P.root i := by
   rw [LinearMap.smul_apply, LinearMap.comp_apply, show 4 = 2 * 2 from rfl, mul_smul, ← map_nsmul,
     ← rootForm_self_smul_coroot, map_smul, smul_comm, ← corootForm_self_smul_root, smul_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma four_smul_rootForm_sq_eq_coxeterWeight_smul (i j : ι) :
     4 • (P.RootForm (P.root i) (P.root j)) ^ 2 = P.coxeterWeight i j •
       (P.RootForm (P.root i) (P.root i) * P.RootForm (P.root j) (P.root j)) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/G2.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/G2.lean
index 26f771a99..5e1faecae 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/G2.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/G2.lean
@@ -294,7 +294,6 @@ lemma threeShortAddLongRoot_eq :
   simp [threeShortAddLongRoot, threeShortAddLong, reflection_apply_root]
   module
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma threeShortAddTwoLongRoot_eq :
     threeShortAddTwoLongRoot P = (3 : R) • shortRoot P + (2 : R) • longRoot P := by
   simp [threeShortAddTwoLongRoot, threeShortAddTwoLong, reflection_apply_root]
@@ -402,7 +401,6 @@ variable (i : ι)
   · simp only [twoShortAddLongRoot_eq, one_smul, add_left_inj]
     norm_cast
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma pairingIn_twoShortAddLong_right :
     P.pairingIn ℤ i (twoShortAddLong P) =
       2 * P.pairingIn ℤ i (short P) + 3 * P.pairingIn ℤ i (long P) := by
@@ -433,7 +431,6 @@ omit [Finite ι] [IsDomain R] in
   · simp only [threeShortAddLongRoot_eq, one_smul, add_left_inj]
     norm_cast
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma pairingIn_threeShortAddLong_right :
     P.pairingIn ℤ i (threeShortAddLong P) =
       P.pairingIn ℤ i (short P) + P.pairingIn ℤ i (long P) := by
@@ -464,7 +461,6 @@ set_option backward.isDefEq.respectTransparency.outParams false in
   · simp only [threeShortAddTwoLongRoot_eq]
     norm_cast
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma pairingIn_threeShortAddTwoLong_right :
     P.pairingIn ℤ i (threeShortAddTwoLong P) =
       P.pairingIn ℤ i (short P) + 2 * P.pairingIn ℤ i (long P) := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/Nondegenerate.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/Nondegenerate.lean
index 798510948..d260e9d12 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/Nondegenerate.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Finite/Nondegenerate.lean
@@ -95,7 +95,6 @@ instance instIsAnisotropicOfIsCrystallographic [CharZero R] [P.IsCrystallographi
   ne_zero := IsAnisotropic.rootForm_root_ne_zero
   isOrthogonal_reflection := P.rootForm_reflection_reflection_apply
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma smul_coroot_eq_of_root_add_root_eq [P.IsAnisotropic] [IsDomain R] [IsTorsionFree R N]
     {i j k : ι} {m n : R} (hk : m • P.root i + n • P.root j = P.root k) :
     letI Q :=
@@ -377,7 +376,6 @@ lemma coroot_eq_polarizationEquiv_apply_root (i : ι) :
     smul_smul, mul_div_cancel₀ _ h₀]
   norm_cast
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma polarizationEquiv_symm_apply_coroot {i : ι} :
     P.PolarizationEquiv.symm (P.coroot i) = (2 / P.RootForm (P.root i) (P.root i)) • P.root i := by
   simp [coroot_eq_polarizationEquiv_apply_root]
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/OfBilinear.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/OfBilinear.lean
index 8ddfc09be..6d82bce06 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/OfBilinear.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/OfBilinear.lean
@@ -53,7 +53,6 @@ lemma of_dvd_two [IsCancelMulZero R] [NeZero (2 : R)] (hx : B x x ∣ 2) :
 
 variable (hx : IsReflective B x)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The coroot attached to a reflective vector. -/
 def coroot : M →ₗ[R] R where
   toFun y := (hx.2 y).choose
@@ -81,7 +80,6 @@ lemma smul_coroot : B x x • coroot B hx = 2 • B x := by
 lemma coroot_apply_self : coroot B hx x = 2 :=
   hx.regular.left <| by simp [mul_comm _ (B x x)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isOrthogonal_reflection (hSB : LinearMap.IsSymm B) :
     B.IsOrthogonal (Module.reflection (coroot_apply_self B hx)) := by
@@ -116,7 +114,6 @@ namespace RootPairing
 
 open LinearMap IsReflective
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The root pairing given by all reflective vectors for a bilinear form. -/
 def ofBilinear [IsReflexive R M] (B : M →ₗ[R] M →ₗ[R] R) (hNB : LinearMap.Nondegenerate B)
diff --git a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Reduced.lean b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Reduced.lean
index d806c1254..ac36cc6b8 100644
--- a/mathlib4/Mathlib/LinearAlgebra/RootSystem/Reduced.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/RootSystem/Reduced.lean
@@ -230,7 +230,6 @@ lemma pairing_neg_two_neg_two_iff :
 
 variable [Module.IsTorsionFree R N]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma pairing_one_four_iff' (h2 : IsSMulRegular R (2 : R)) :
     P.pairing i j = 1 ∧ P.pairing j i = 4 ↔ P.root j = (2 : R) • P.root i := by
   have : IsAddTorsionFree M := .of_isTorsionFree R M
diff --git a/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Basic.lean
index 053ae87e3..e7b501403 100644
--- a/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Basic.lean
@@ -807,7 +807,6 @@ end Nondegenerate
 
 namespace BilinForm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma apply_smul_sub_smul_sub_eq [CommRing R] [AddCommGroup M] [Module R M]
     (B : LinearMap.BilinForm R M) (x y : M) :
@@ -900,7 +899,6 @@ lemma nondegenerate_restrict_iff_disjoint_ker (hs : ∀ x, 0 ≤ B x x) (hB : B.
 
 variable [IsTorsionFree R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Strict **Cauchy-Schwarz** is equivalent to linear independence for positive definite forms. -/
 lemma apply_mul_apply_lt_iff_linearIndependent (hp : ∀ x, x ≠ 0 → 0 < B x x) (x y : M) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Star.lean b/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Star.lean
index 5b0d35c00..b2fc28e05 100644
--- a/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Star.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/SesquilinearForm/Star.lean
@@ -22,7 +22,6 @@ variable {R M n : Type*} [CommSemiring R] [StarRing R] [AddCommMonoid M] [Module
   [Fintype n] [DecidableEq n]
   {B : M →ₗ⋆[R] M →ₗ[R] R} (b : Basis n R M)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma LinearMap.isSymm_iff_basis {ι : Type*} (b : Basis ι R M) :
     IsSymm B ↔ ∀ i j, star (B (b i) (b j)) = B (b j) (b i) where
diff --git a/mathlib4/Mathlib/LinearAlgebra/Span/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Span/Basic.lean
index 495383ecc..1d7829afd 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Span/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Span/Basic.lean
@@ -776,7 +776,6 @@ theorem toSpanSingleton_isIdempotentElem_iff {e : R} :
     smul_eq_mul, mul_assoc]
   exact ⟨fun h ↦ by conv_rhs => rw [← one_mul e, ← h, one_mul], fun h _ ↦ by rw [h]⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isIdempotentElem_map_one_iff {f : Module.End R R} :
     IsIdempotentElem (f 1) ↔ IsIdempotentElem f := by
   rw [IsIdempotentElem, ← smul_eq_mul, ← map_smul, smul_eq_mul, mul_one, IsIdempotentElem,
diff --git a/mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean b/mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean
index ecfcbd5c4..451ec1d3b 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Span/Defs.lean
@@ -461,7 +461,6 @@ theorem mem_span_singleton {y : M} : x ∈ R ∙ y ↔ ∃ a : R, a • y = x :=
 theorem le_span_singleton_iff {s : Submodule R M} {v₀ : M} :
     s ≤ R ∙ v₀ ↔ ∀ v ∈ s, ∃ r : R, r • v₀ = v := by simp_rw [SetLike.le_def, mem_span_singleton]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem eq_span_singleton_of_surjective {s : Submodule R M}
     {f : R →ₗ[R] s} (hf : Surjective f) : s = span R {(f 1 : M)} := by
   refine le_antisymm (fun x hx ↦ mem_span_singleton.mpr ?_)
@@ -682,7 +681,6 @@ theorem Module.isPrincipal_submodule_iff {p : Submodule R M} :
     have ⟨r, hr⟩ := mem_span_singleton.mp (ha.le x.2)
     exact mem_span_singleton.mpr ⟨r, Subtype.ext hr⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem Module.IsPrincipal.of_surjective (f : M →ₗ[R] M₂) (hf : Function.Surjective f)
     [IsPrincipal R M] : IsPrincipal R M₂ where
diff --git a/mathlib4/Mathlib/LinearAlgebra/SpecialLinearGroup.lean b/mathlib4/Mathlib/LinearAlgebra/SpecialLinearGroup.lean
index 9d66df79e..b5c47a967 100644
--- a/mathlib4/Mathlib/LinearAlgebra/SpecialLinearGroup.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/SpecialLinearGroup.lean
@@ -238,7 +238,6 @@ theorem _root_.SpecialLinearGroup.smul_def (g : SpecialLinearGroup R V) (v : V)
 theorem _root_.SpecialLinearGroup.toLinearEquiv_eq_coe (g : SpecialLinearGroup R V) :
     g.toLinearEquiv = (g : V ≃ₗ[R] V) := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : SMulCommClass (SpecialLinearGroup R V) R V where
   smul_comm g a v := by
     simp [SpecialLinearGroup.smul_def]
@@ -356,7 +355,6 @@ theorem center_eq_bot_of_finrank_le_one (h : Module.finrank R V ≤ 1) :
     (Subgroup.centerCongr (Matrix.SpecialLinearGroup.toLin_equiv b)).toEquiv] at this
   exact Subgroup.eq_bot_of_subsingleton _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mem_center_iff {g : SpecialLinearGroup R V} :
     g ∈ Subgroup.center (SpecialLinearGroup R V) ↔
       ∃ (r : R), r ^ (Module.finrank R V) = 1 ∧
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean b/mathlib4/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
index 56a8b0e36..2a9db1c01 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
@@ -55,7 +55,6 @@ theorem toTensorAlgebra_gMul {i j} (a : (⨂[R]^i) M) (b : (⨂[R]^j) M) :
   rw [List.ofFn_comp' _ (TensorAlgebra.ι R), List.ofFn_comp' _ (TensorAlgebra.ι R),
     List.ofFn_comp' _ (TensorAlgebra.ι R), ← List.map_append, List.ofFn_fin_append]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toTensorAlgebra_galgebra_toFun (r : R) :
     TensorPower.toTensorAlgebra (DirectSum.GAlgebra.toFun (R := R) (A := fun n => ⨂[R]^n M) r) =
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorPower/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/TensorPower/Basic.lean
index 113a7e369..49e1a4518 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorPower/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorPower/Basic.lean
@@ -146,7 +146,6 @@ theorem tprod_mul_tprod {na nb} (a : Fin na → M) (b : Fin nb → M) :
   apply funext
   apply Fin.addCases <;> simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem one_mul {n} (a : ⨂[R]^n M) : cast R M (zero_add n) (ₜ1 ₜ* a) = a := by
   rw [gMul_def, gOne_def]
   induction a using PiTensorProduct.induction_on with
@@ -159,7 +158,6 @@ theorem one_mul {n} (a : ⨂[R]^n M) : cast R M (zero_add n) (ₜ1 ₜ* a) = a :
   | add x y hx hy =>
     rw [TensorProduct.tmul_add, map_add, map_add, hx, hy]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mul_one {n} (a : ⨂[R]^n M) : cast R M (add_zero _) (a ₜ* ₜ1) = a := by
   rw [gMul_def, gOne_def]
   induction a using PiTensorProduct.induction_on with
@@ -211,19 +209,16 @@ theorem algebraMap₀_eq_smul_one (r : R) : (algebraMap₀ r : (⨂[R]^0) M) = r
 theorem algebraMap₀_one : (algebraMap₀ 1 : (⨂[R]^0) M) = ₜ1 :=
   (algebraMap₀_eq_smul_one 1).trans (one_smul _ _)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem algebraMap₀_mul {n} (r : R) (a : ⨂[R]^n M) :
     cast R M (zero_add _) (algebraMap₀ r ₜ* a) = r • a := by
   rw [gMul_eq_coe_linearMap, algebraMap₀_eq_smul_one, LinearMap.map_smul₂, map_smul,
     ← gMul_eq_coe_linearMap, one_mul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem mul_algebraMap₀ {n} (r : R) (a : ⨂[R]^n M) :
     cast R M (add_zero _) (a ₜ* algebraMap₀ r) = r • a := by
   rw [gMul_eq_coe_linearMap, algebraMap₀_eq_smul_one, map_smul, map_smul, ← gMul_eq_coe_linearMap,
     mul_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem algebraMap₀_mul_algebraMap₀ (r s : R) :
     cast R M (add_zero _) (algebraMap₀ r ₜ* algebraMap₀ s) = algebraMap₀ (r * s) := by
   rw [← smul_eq_mul, map_smul]
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
index fdcdb8edb..1b7efccfc 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
@@ -186,7 +186,6 @@ noncomputable irreducible_def gradedMul :
   refine (assoc R _ _ _).toLinearMap ∘ₗ .rTensor _ ?_ ∘ₗ (assoc R _ _ _).symm.toLinearMap
   exact (gradedComm _ _ _).toLinearMap
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem tmul_of_gradedMul_of_tmul (j₁ i₂ : ι)
     (a₁ : ⨁ i, 𝒜 i) (b₁ : ℬ j₁) (a₂ : 𝒜 i₂) (b₂ : ⨁ i, ℬ i) :
     gradedMul R 𝒜 ℬ (a₁ ⊗ₜ lof R _ ℬ j₁ b₁) (lof R _ 𝒜 i₂ a₂ ⊗ₜ b₂) =
@@ -237,7 +236,6 @@ theorem gradedMul_one (x : (⨁ i, 𝒜 i) ⊗[R] (⨁ i, ℬ i)) :
   -- Note: https://github.com/leanprover-community/mathlib4/pull/8386 had to specialize `map_one` to avoid timeouts.
   simpa only [RingHom.map_one, one_smul] using! gradedMul_algebraMap 𝒜 ℬ x 1
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 theorem gradedMul_assoc (x y z : DirectSum _ 𝒜 ⊗[R] DirectSum _ ℬ) :
@@ -258,7 +256,6 @@ theorem gradedMul_assoc (x y z : DirectSum _ 𝒜 ⊗[R] DirectSum _ ℬ) :
   congr 2
   abel
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 theorem gradedComm_gradedMul (x y : DirectSum _ 𝒜 ⊗[R] DirectSum _ ℬ) :
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
index 3f2c3e74f..538cd230b 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
@@ -178,7 +178,6 @@ instance instRing : Ring (𝒜 ᵍ⊗[R] ℬ) where
   mul_zero x := by simp_rw [mul_def, map_zero]
   zero_mul x := by simp_rw [mul_def, LinearMap.map_zero₂]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The characterization of this multiplication on partially homogeneous elements. -/
 theorem tmul_coe_mul_coe_tmul {j₁ i₂ : ι} (a₁ : A) (b₁ : ℬ j₁) (a₂ : 𝒜 i₂) (b₂ : B) :
     (a₁ ᵍ⊗ₜ[R] (b₁ : B) * (a₂ : A) ᵍ⊗ₜ[R] b₂ : 𝒜 ᵍ⊗[R] ℬ) =
@@ -274,7 +273,6 @@ def includeLeft : A →ₐ[R] 𝒜 ᵍ⊗[R] ℬ where
   toRingHom := includeLeftRingHom 𝒜 ℬ
   commutes' _ := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The algebra morphism `B →ₐ[R] A ⊗[R] B` sending `b` to `1 ⊗ₜ b`. -/
 @[simps!]
 def includeRight : B →ₐ[R] (𝒜 ᵍ⊗[R] ℬ) :=
@@ -296,7 +294,6 @@ lemma algebraMap_def' (r : R) : algebraMap R (𝒜 ᵍ⊗[R] ℬ) r = 1 ᵍ⊗
 
 variable {C} [Ring C] [Algebra R C]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 /-- The forwards direction of the universal property; an algebra morphism out of the graded tensor
 product can be assembled from maps on each component that (anti)commute on pure elements of the
diff --git a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
index dad8b00be..065aa4006 100644
--- a/mathlib4/Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
@@ -204,7 +204,6 @@ noncomputable def lTensor.toFun (hfg : Exact f g) :
     rw [LinearMap.range_le_iff_comap, ← LinearMap.ker_comp,
       ← lTensor_comp, hfg.linearMap_comp_eq_zero, lTensor_zero, ker_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The inverse map in `lTensor.equiv_of_rightInverse` (computably, given a right inverse) -/
 noncomputable def lTensor.inverse_of_rightInverse {h : P → N} (hfg : Exact f g)
@@ -313,7 +312,6 @@ noncomputable def rTensor.toFun (hfg : Exact f g) :
     rw [range_le_iff_comap, ← ker_comp, ← rTensor_comp,
       hfg.linearMap_comp_eq_zero, rTensor_zero, ker_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The inverse map in `rTensor.equiv_of_rightInverse` (computably, given a right inverse) -/
 noncomputable def rTensor.inverse_of_rightInverse {h : P → N} (hfg : Exact f g)
diff --git a/mathlib4/Mathlib/LinearAlgebra/Trace.lean b/mathlib4/Mathlib/LinearAlgebra/Trace.lean
index bcbbfb16d..15937293e 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Trace.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Trace.lean
@@ -268,7 +268,6 @@ theorem trace_comp_comm' (f : M →ₗ[R] N) (g : N →ₗ[R] M) :
   simp only [llcomp_apply', compr₂_apply, flip_apply] at h
   exact h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma trace_smulRight (f : M →ₗ[R] R) (x : M) :
     trace R M (f.smulRight x) = f x := by
@@ -361,7 +360,6 @@ lemma isNilpotent_trace_of_isNilpotent {f : M →ₗ[R] M} (hf : IsNilpotent f)
   apply Matrix.isNilpotent_trace_of_isNilpotent
   simpa
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma trace_comp_eq_mul_of_commute_of_isNilpotent [IsReduced R] {f g : Module.End R M}
     (μ : R) (h_comm : Commute f g) (hg : IsNilpotent (g - algebraMap R _ μ)) :
     trace R M (f ∘ₗ g) = μ * trace R M f := by
diff --git a/mathlib4/Mathlib/LinearAlgebra/Transvection/Basic.lean b/mathlib4/Mathlib/LinearAlgebra/Transvection/Basic.lean
index aa7d7a33d..6fa4b3ef8 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Transvection/Basic.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Transvection/Basic.lean
@@ -95,7 +95,6 @@ theorem of_right_eq_zero (f : Dual R V) :
   ext
   simp [transvection]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem comp_smul_smul {f : Dual R V} {v : V} {r s : R} :
     transvection f (r • v) ∘ₗ transvection f (s • v) =
       transvection f ((r + s + s * f v * r) • v) := by
@@ -103,7 +102,6 @@ theorem comp_smul_smul {f : Dual R V} {v : V} {r s : R} :
   simp only [LinearMap.comp_apply, apply, map_add, map_smul, add_assoc]
   simp only [smul_add, ← mul_smul, ← add_smul, ← mul_add (f x), mul_assoc]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem eq_id_of_finrank_le_one
     {R V : Type*} [CommSemiring R] [AddCommMonoid V] [Module R V]
     [Free R V] [Module.Finite R V] [StrongRankCondition R]
@@ -124,7 +122,6 @@ theorem eq_id_of_finrank_le_one
     have : x = ∑ i, b.repr x i • b i := (b.sum_equivFun x).symm
     rwa [Finset.sum_eq_single_of_mem i (Finset.mem_univ i) (by grind)] at this
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem congr {W : Type*} [AddCommMonoid W] [Module R W]
     (f : Dual R V) (v : V) (e : V ≃ₗ[R] W) :
     e ∘ₗ (transvection f v) ∘ₗ e.symm = transvection (f ∘ₗ e.symm) (e v) := by
@@ -295,7 +292,6 @@ theorem transvection_mem_dilatransvections {f : Dual R V} {v : V} (hfv : f v = 0
 theorem one_mem_dilatransvections : 1 ∈ dilatransvections R V :=
   refl_mem_dilatransvections
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem symm_mem_dilatransvections_iff {e : V ≃ₗ[R] V} :
     e.symm ∈ dilatransvections R V ↔ e ∈ dilatransvections R V := by
@@ -559,7 +555,6 @@ section Field
 
 variable {K : Type*} {V : Type*} [Field K] [AddCommGroup V] [Module K V]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Determinant of transvections, over a field.
 
 See `LinearMap.Transvection.det` for the general result. -/
diff --git a/mathlib4/Mathlib/LinearAlgebra/Transvection/Generation.lean b/mathlib4/Mathlib/LinearAlgebra/Transvection/Generation.lean
index 2b493f990..fefe9a9ef 100644
--- a/mathlib4/Mathlib/LinearAlgebra/Transvection/Generation.lean
+++ b/mathlib4/Mathlib/LinearAlgebra/Transvection/Generation.lean
@@ -298,7 +298,6 @@ private theorem apply_notMem_sup_of_linearIndependent {u : V}
     grind [smul_sub, sub_smul, one_smul, map_smul]
   aesop
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 omit [Module.Finite K V] in
 variable {e} in
 /-- If `e.fixedReduce` is not a homothety, then there are a linear form `f` and
@@ -341,7 +340,6 @@ private theorem exists_dual_of_fixedReduce_ne_smul
   rw [← LinearIndependent.pair_smul_smul_iff (Ne.isUnit hfu).inv (Ne.isUnit hfu).inv] at hu
   simpa only [← LinearMap.map_smul, ← LinearEquiv.map_smul, ← v_def] using hu
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable {e} in
 /-- Auxiliary lemma for the second non-exceptional case in Dieudonné's theorem:
 with the notation of the proof of
diff --git a/mathlib4/Mathlib/MeasureTheory/Function/Jacobian.lean b/mathlib4/Mathlib/MeasureTheory/Function/Jacobian.lean
index 1e5c41fbd..fe7664d02 100644
--- a/mathlib4/Mathlib/MeasureTheory/Function/Jacobian.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Function/Jacobian.lean
@@ -280,7 +280,6 @@ to the approximating linear map.
 -/
 
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `f` be a function which is sufficiently close (in the Lipschitz sense) to a given linear
 map `A`. Then it expands the volume of any set by at most `m` for any `m > det A`. -/
 theorem addHaar_image_le_mul_of_det_lt (A : E →L[ℝ] E) {m : ℝ≥0}
@@ -458,7 +457,6 @@ theorem mul_le_addHaar_image_of_lt_det (A : E →L[ℝ] E) {m : ℝ≥0}
   -- and our choice of `δ`.
   exact hδ₀ _ _ ((hf'.to_inv h1δ).mono_num h2δ.le)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a differentiable function `f` is approximated by a linear map `A` on a set `s`, up to `δ`,
 then at almost every `x` in `s` one has `‖f' x - A‖ ≤ δ`. -/
 theorem _root_.ApproximatesLinearOn.norm_fderiv_sub_le {A : E →L[ℝ] E} {δ : ℝ≥0}
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/Bochner/L1.lean b/mathlib4/Mathlib/MeasureTheory/Integral/Bochner/L1.lean
index 0848d3309..f8ae4c1ce 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/Bochner/L1.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/Bochner/L1.lean
@@ -589,7 +589,6 @@ theorem integral_sub (f g : α →₁[μ] E) : integral (f - g) = integral f - i
   simp only [integral]
   exact map_sub integralCLM f g
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[integral_simps]
 theorem integral_smul (c : 𝕜) (f : α →₁[μ] E) : integral (c • f) = c • integral f := by
   rw [integral_eq' 𝕜 f, integral_eq' 𝕜 (c • f), map_smul (integralCLM' 𝕜) c f]
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/CircleAverage.lean b/mathlib4/Mathlib/MeasureTheory/Integral/CircleAverage.lean
index 3cbf10623..33e0e2d18 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/CircleAverage.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/CircleAverage.lean
@@ -313,7 +313,6 @@ theorem circleAverage_nonneg_of_nonneg {c : ℂ} {R : ℝ} {f : ℂ → ℝ}
 ## Commutativity with Linear Maps
 -/
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Circle averages commute with continuous linear maps. -/
 theorem _root_.ContinuousLinearMap.circleAverage_comp_comm [CompleteSpace E] (L : E →L[ℝ] F)
     {f : ℂ → E} (hf : CircleIntegrable f c R) :
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/FinMeasAdditive.lean b/mathlib4/Mathlib/MeasureTheory/Integral/FinMeasAdditive.lean
index 4aa707f79..0920a1eeb 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/FinMeasAdditive.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/FinMeasAdditive.lean
@@ -487,7 +487,6 @@ theorem setToSimpleFunc_sub (T : Set α → E →L[ℝ] F) (h_add : FinMeasAddit
   refine hg (-x) ?_
   simp [hx_ne]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem setToSimpleFunc_smul_real (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T) (c : ℝ)
     {f : α →ₛ E} (hf : Integrable f μ) : setToSimpleFunc T (c • f) = c • setToSimpleFunc T f :=
   calc
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean b/mathlib4/Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean
index cf9ca77a2..3a73e6791 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean
@@ -280,7 +280,6 @@ noncomputable def rieszContent (Λ : C_c(X, ℝ≥0) →ₗ[ℝ≥0] ℝ≥0) :
 lemma rieszContent_ne_top {K : Compacts X} : rieszContent Λ K ≠ ⊤ := by
   simp [rieszContent, ne_eq, not_false_eq_true]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma contentRegular_rieszContent : (rieszContent Λ).ContentRegular := by
   intro K
diff --git a/mathlib4/Mathlib/MeasureTheory/Integral/SetToL1.lean b/mathlib4/Mathlib/MeasureTheory/Integral/SetToL1.lean
index 238a3285f..cfc8c8c87 100644
--- a/mathlib4/Mathlib/MeasureTheory/Integral/SetToL1.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Integral/SetToL1.lean
@@ -500,7 +500,6 @@ theorem setToL1_smul_left' (hT : DominatedFinMeasAdditive μ T C)
   apply setToL1_unique hT' (A := c • setToL1 hT) _ f
   simp [setToL1_eq_setToL1SCLM, setToL1SCLM_smul_left' c hT hT' h_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem setToL1_smul (hT : DominatedFinMeasAdditive μ T C)
     (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜) (f : α →₁[μ] E) :
     setToL1 hT (c • f) = c • setToL1 hT f := by
diff --git a/mathlib4/Mathlib/MeasureTheory/Measure/CharacteristicFunction/TaylorExpansion.lean b/mathlib4/Mathlib/MeasureTheory/Measure/CharacteristicFunction/TaylorExpansion.lean
index fa39fe30c..e11fe18fb 100644
--- a/mathlib4/Mathlib/MeasureTheory/Measure/CharacteristicFunction/TaylorExpansion.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Measure/CharacteristicFunction/TaylorExpansion.lean
@@ -66,7 +66,6 @@ lemma continuous_charFun : Continuous (charFun μ) := by
   refine contDiff_zero.1 (contDiff_charFun ?_)
   simpa using by fun_prop
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem iteratedFDeriv_charFun {n : ℕ} {t : E} (hint : MemLp id n μ) (x : Fin n → E) :
     iteratedFDeriv ℝ n (charFun μ) t x = I ^ n * ∫ y, (∏ i, ⟪y, x i⟫) * exp (⟪y, t⟫ * I) ∂μ := by
   have h : innerₗ E = (innerSL ℝ).toLinearMap₁₂ := rfl
diff --git a/mathlib4/Mathlib/MeasureTheory/Measure/Haar/Extension.lean b/mathlib4/Mathlib/MeasureTheory/Measure/Haar/Extension.lean
index 1e661c6ee..944f3c6e1 100644
--- a/mathlib4/Mathlib/MeasureTheory/Measure/Haar/Extension.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Measure/Haar/Extension.lean
@@ -148,7 +148,6 @@ theorem pushforward_mono {f g : CompactlySupportedContinuousMap B ℝ} (h : f 
 
 variable [MeasurableSpace C] [BorelSpace C] (μC : Measure C) [hμC : IsHaarMeasure μC]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `φ : A →* B` and `ψ : B →* C` define a short exact sequence of topological groups, then we
 can integrate a continuous compactly supported function on `B` by integrating over `A` and `C`. -/
 @[to_additive /-- If `φ : A →+ B` and `ψ : B →+ C` define a short exact sequence of additive
@@ -165,7 +164,6 @@ noncomputable def integrate : CompactlySupportedContinuousMap B E →ₗ[ℝ] E
 
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 theorem integrate_apply (f : CompactlySupportedContinuousMap B E) :
     H.integrate μA μC f = ∫ c, pushforward H μA f c ∂μC :=
@@ -173,7 +171,6 @@ theorem integrate_apply (f : CompactlySupportedContinuousMap B E) :
 
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 theorem integrate_mono {f g : CompactlySupportedContinuousMap B ℝ} (h : f ≤ g) :
     integrate H μA μC f ≤ integrate H μA μC g :=
@@ -184,7 +181,6 @@ variable [T2Space B] [MeasurableSpace B] [BorelSpace B]
 
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `φ : A →* B` and `ψ : B →* C` define a short exact sequence of topological groups, then we
 can define a Haar measure on `B` induced by the Haar measures on `A` and `C`. -/
 @[to_additive /-- If `φ : A →+ B` and `ψ : B →+ C` define a short exact sequence of additive
@@ -195,14 +191,12 @@ noncomputable def inducedMeasure : Measure B :=
 
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 instance inducedMeasure_regular : (inducedMeasure H μA μC).Regular :=
   RealRMK.regular_rieszMeasure _
 
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 theorem integral_inducedMeasure (f : CompactlySupportedContinuousMap B ℝ) :
     ∫ b : B, f b ∂(inducedMeasure H μA μC) = integrate H μA μC f := by
@@ -210,7 +204,6 @@ theorem integral_inducedMeasure (f : CompactlySupportedContinuousMap B ℝ) :
 
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive]
 instance isHaarMeasure_inducedMeasure : IsHaarMeasure (inducedMeasure H μA μC) where
   lt_top_of_isCompact K hK := by
@@ -251,7 +244,6 @@ instance isHaarMeasure_inducedMeasure : IsHaarMeasure (inducedMeasure H μA μC)
 
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- If `φ : A →* B` and `ψ : B →* C` define a short exact sequence of topological groups, and if
 `ψ` is injective on an open set `U`, then the induced measure on `U` is bounded above by
diff --git a/mathlib4/Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean b/mathlib4/Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
index 38b6b4435..76ce2932f 100644
--- a/mathlib4/Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
+++ b/mathlib4/Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
@@ -54,7 +54,6 @@ theorem mem_parallelepiped_iff (v : ι → E) (x : E) :
     x ∈ parallelepiped v ↔ ∃ t ∈ Icc (0 : ι → ℝ) 1, x = ∑ i, t i • v i := by
   simp [parallelepiped, eq_comm]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem parallelepiped_basis_eq (b : Basis ι ℝ E) :
     parallelepiped b = {x | ∀ i, b.repr x i ∈ Set.Icc 0 1} := by
diff --git a/mathlib4/Mathlib/ModelTheory/Arithmetic/Presburger/Semilinear/Basic.lean b/mathlib4/Mathlib/ModelTheory/Arithmetic/Presburger/Semilinear/Basic.lean
index 2aad3f4ee..f310d3887 100644
--- a/mathlib4/Mathlib/ModelTheory/Arithmetic/Presburger/Semilinear/Basic.lean
+++ b/mathlib4/Mathlib/ModelTheory/Arithmetic/Presburger/Semilinear/Basic.lean
@@ -558,7 +558,6 @@ private theorem fract_add_of_mem_closure {x y} (hy : y ∈ closure hs.basisSet)
   rw [map_add, ← sub_add_eq_add_sub]
   simp [-nsmul_eq_mul, ← hs.basis_apply, Finsupp.single_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 private theorem fract_mem_fundamentalDomain (x) : hs.fract x ∈ hs.fundamentalDomain := by
   classical
diff --git a/mathlib4/Mathlib/NumberTheory/ClassNumber/Finite.lean b/mathlib4/Mathlib/NumberTheory/ClassNumber/Finite.lean
index 19d1df1be..3d9bd5728 100644
--- a/mathlib4/Mathlib/NumberTheory/ClassNumber/Finite.lean
+++ b/mathlib4/Mathlib/NumberTheory/ClassNumber/Finite.lean
@@ -70,7 +70,6 @@ theorem normBound_pos : 0 < normBound abv bS := by
   refine lt_of_lt_of_le (abv.pos hijk) (Finset.le_max' _ _ ?_)
   exact Finset.mem_image.mpr ⟨⟨i, j, k⟩, Finset.mem_univ _, rfl⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If the `R`-integral element `a : S` has coordinates `≤ y` with respect to some basis `b`,
 its norm is less than `normBound abv b * y ^ dim S`. -/
 theorem norm_le (a : S) {y : ℤ} (hy : ∀ k, abv (bS.repr a k) ≤ y) :
@@ -186,7 +185,6 @@ open Real
 
 attribute [-instance] Real.decidableEq
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- We can approximate `a / b : L` with `q / r`, where `r` has finitely many options for `L`. -/
 theorem exists_mem_finsetApprox (a : S) {b} (hb : b ≠ (0 : R)) :
diff --git a/mathlib4/Mathlib/NumberTheory/ModularForms/LevelOne/DimensionFormula.lean b/mathlib4/Mathlib/NumberTheory/ModularForms/LevelOne/DimensionFormula.lean
index b8eb2bc27..d64e0c83b 100644
--- a/mathlib4/Mathlib/NumberTheory/ModularForms/LevelOne/DimensionFormula.lean
+++ b/mathlib4/Mathlib/NumberTheory/ModularForms/LevelOne/DimensionFormula.lean
@@ -220,7 +220,6 @@ private lemma eq_zero_of_pow_eq_smul {p p4 p6 : PowerSeries ℂ} {c4 c6 : ℂ}
     grind
   grind [pow_eq_zero_iff, zero_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma weight_two_qExpansion_eq_zero (f : ModularForm 𝒮ℒ 2) : qExpansion 1 f = 0 := by
   obtain ⟨c4, hc4⟩ : ∃ c4, c4 • E₄ = f.mul f :=
     (finrank_eq_one_iff_of_nonzero' E₄ (E_ne_zero _ ⟨2, rfl⟩)).mp
diff --git a/mathlib4/Mathlib/NumberTheory/NumberField/CanonicalEmbedding/NormLeOne.lean b/mathlib4/Mathlib/NumberTheory/NumberField/CanonicalEmbedding/NormLeOne.lean
index 6f3742779..22ee702d4 100644
--- a/mathlib4/Mathlib/NumberTheory/NumberField/CanonicalEmbedding/NormLeOne.lean
+++ b/mathlib4/Mathlib/NumberTheory/NumberField/CanonicalEmbedding/NormLeOne.lean
@@ -531,7 +531,6 @@ theorem norm_expMapBasis_ne_zero (x : realSpace K) :
     mixedEmbedding.norm (mixedSpaceOfRealSpace (expMapBasis x)) ≠ 0 :=
   norm_expMapBasis x ▸ pow_ne_zero _ (Real.exp_ne_zero _)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open scoped Classical in
 theorem logMap_expMapBasis (x : realSpace K) :
     logMap (mixedSpaceOfRealSpace (expMapBasis x)) ∈
diff --git a/mathlib4/Mathlib/NumberTheory/NumberField/Cyclotomic/Basic.lean b/mathlib4/Mathlib/NumberTheory/NumberField/Cyclotomic/Basic.lean
index 3a3adda3c..2b3facbfa 100644
--- a/mathlib4/Mathlib/NumberTheory/NumberField/Cyclotomic/Basic.lean
+++ b/mathlib4/Mathlib/NumberTheory/NumberField/Cyclotomic/Basic.lean
@@ -428,7 +428,6 @@ lemma prime_norm_toInteger_sub_one_of_prime_ne_two' [hcycl : IsCyclotomicExtensi
   replace hζ : IsPrimitiveRoot ζ (p ^ (0 + 1)) := by simpa using hζ
   exact hζ.prime_norm_toInteger_sub_one_of_prime_ne_two hodd
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- In a `p ^ (k + 1)`-th cyclotomic extension of `ℚ `, we have that `ζ` is not congruent to an
   integer modulo `p` if `p ^ (k  + 1) ≠ 2`. -/
 theorem not_exists_int_prime_dvd_sub_of_prime_pow_ne_two
diff --git a/mathlib4/Mathlib/NumberTheory/NumberField/Ideal/Asymptotics.lean b/mathlib4/Mathlib/NumberTheory/NumberField/Ideal/Asymptotics.lean
index 5fd464b75..ae19ab8ba 100644
--- a/mathlib4/Mathlib/NumberTheory/NumberField/Ideal/Asymptotics.lean
+++ b/mathlib4/Mathlib/NumberTheory/NumberField/Ideal/Asymptotics.lean
@@ -70,7 +70,6 @@ private def tendsto_norm_le_and_mk_eq_div_atTop_aux₂ :
   · rintro ⟨⟨hx₁, ⟨x, hx₂, rfl⟩⟩, hx₃⟩
     exact ⟨(toMixed K).symm (mixedEmbedding K x), ⟨⟨hx₁, hx₃⟩, ⟨(x : K), by simp [hx₂], rfl⟩⟩, rfl⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (C) in
 /--
 The limit of the number of nonzero integral ideals of norm `≤ s` in a fixed class `C` of the
diff --git a/mathlib4/Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean b/mathlib4/Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
index 0d10dc6af..5e74556f7 100644
--- a/mathlib4/Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
+++ b/mathlib4/Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
@@ -403,7 +403,6 @@ theorem logEmbeddingQuot_apply (x : (𝓞 K)ˣ) :
       logEmbedding K (Additive.ofMul x) := rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem logEmbeddingQuot_injective :
     Function.Injective (logEmbeddingQuot K) := by
   unfold logEmbeddingQuot
diff --git a/mathlib4/Mathlib/NumberTheory/Padics/Measure/Basic.lean b/mathlib4/Mathlib/NumberTheory/Padics/Measure/Basic.lean
index 99d254570..f8a2f46b2 100644
--- a/mathlib4/Mathlib/NumberTheory/Padics/Measure/Basic.lean
+++ b/mathlib4/Mathlib/NumberTheory/Padics/Measure/Basic.lean
@@ -131,7 +131,6 @@ section Prod
 
 -- note we define `contractSnd` first, because `f.curry` only works one way round
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Send a measure `ν` on `Y` and a function `f` on `X × Y` to the function on `X` given by
 `x ↦ ν (f (x, ·))`, or more suggestively, `x ↦ ∫ f(x, y) dμ(y)`. -/
 def contractSnd : D(Y, R) →ₗ[R] C(X × Y, R) →ₗ[R] C(X, R) :=
@@ -187,7 +186,6 @@ def prodMk : D(X, R) →ₗ[R] D(Y, R) →ₗ[R] D(X × Y, R) :=
 @[simp] lemma prodMk_apply (f : C(X × Y, R)) :
   prodMk μ ν f = ν (μ.contractFst f) := (rfl)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- On functions of the form `(x, y) ↦ f x * g y`, the measure `prodMk μ ν` agrees with the
 algebraic tensor product of `μ` and `ν`. -/
 lemma prodMk_prod_apply (f : C(X, R)) (g : C(Y, R)) :
@@ -211,7 +209,6 @@ lemma prodMk'_apply (f : C(X × Y, R)) : (μ.prodMk' ν) f = μ (ν.contractSnd
 lemma prodMk'_flip (f : C(X × Y, R)) :
     (μ.prodMk' ν) f = (ν.prodMk μ) (f.comp ContinuousMap.prodSwap) := (rfl)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma prodMk'_prod_apply (f : C(X, R)) (g : C(Y, R)) :
     prodMk' μ ν ((f.comp .fst) * (g.comp .snd)) = μ f * ν g := by
   simp only [prodMk'_apply, mul_comm (μ f) (ν g), ← smul_eq_mul, ← map_smul]
diff --git a/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean b/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
index 407520045..83e353c35 100644
--- a/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
+++ b/mathlib4/Mathlib/NumberTheory/Padics/WithVal.lean
@@ -69,7 +69,6 @@ Potential fix: make the following definitions implicit-reducible:
 Then both backward compatibility options can go.
 -/
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.instanceTypes false in
 open MonoidWithZeroHom.ValueGroup₀ in
 lemma isUniformInducing_cast_withVal : IsUniformInducing ((Rat.castHom ℚ_[p]).comp
diff --git a/mathlib4/Mathlib/NumberTheory/RamificationInertia/Basic.lean b/mathlib4/Mathlib/NumberTheory/RamificationInertia/Basic.lean
index 151da2816..9195283f3 100644
--- a/mathlib4/Mathlib/NumberTheory/RamificationInertia/Basic.lean
+++ b/mathlib4/Mathlib/NumberTheory/RamificationInertia/Basic.lean
@@ -180,7 +180,6 @@ theorem FinrankQuotientMap.span_eq_top [IsDomain R] [IsDomain S] [Algebra K L] [
 
 variable [hRK : IsFractionRing R K]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `V` be a vector space over `K = Frac(R)`, `S / R` a ring extension
 and `V'` a module over `S`. If `b`, in the intersection `V''` of `V` and `V'`,
 is linear independent over `S` in `V'`, then it is linear independent over `R` in `V`.
diff --git a/mathlib4/Mathlib/Order/Category/FinBoolAlg.lean b/mathlib4/Mathlib/Order/Category/FinBoolAlg.lean
index 63fed931b..7dadc33bb 100644
--- a/mathlib4/Mathlib/Order/Category/FinBoolAlg.lean
+++ b/mathlib4/Mathlib/Order/Category/FinBoolAlg.lean
@@ -61,7 +61,6 @@ instance largeCategory : LargeCategory FinBoolAlg :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance concreteCategory : ConcreteCategory FinBoolAlg (BoundedLatticeHom · ·) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toBoolAlg) _
 
diff --git a/mathlib4/Mathlib/Order/Category/FinPartOrd.lean b/mathlib4/Mathlib/Order/Category/FinPartOrd.lean
index 56ad860a3..4a816124e 100644
--- a/mathlib4/Mathlib/Order/Category/FinPartOrd.lean
+++ b/mathlib4/Mathlib/Order/Category/FinPartOrd.lean
@@ -55,7 +55,6 @@ instance largeCategory : LargeCategory FinPartOrd :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance concreteCategory : ConcreteCategory FinPartOrd (· →o ·) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toPartOrd) _
 
diff --git a/mathlib4/Mathlib/Order/Category/NonemptyFinLinOrd.lean b/mathlib4/Mathlib/Order/Category/NonemptyFinLinOrd.lean
index dc67e2109..ad5702b6a 100644
--- a/mathlib4/Mathlib/Order/Category/NonemptyFinLinOrd.lean
+++ b/mathlib4/Mathlib/Order/Category/NonemptyFinLinOrd.lean
@@ -46,7 +46,6 @@ instance : LargeCategory NonemptyFinLinOrd :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ConcreteCategory NonemptyFinLinOrd (· →o ·) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toLinOrd) _
 
diff --git a/mathlib4/Mathlib/Order/CompleteLattice/PiLex.lean b/mathlib4/Mathlib/Order/CompleteLattice/PiLex.lean
index 85761d47c..df0503f30 100644
--- a/mathlib4/Mathlib/Order/CompleteLattice/PiLex.lean
+++ b/mathlib4/Mathlib/Order/CompleteLattice/PiLex.lean
@@ -111,19 +111,16 @@ instance : InfSet (Colex ((i : ι) → α i)) where
   sInf s := sInf (α := Πₗ i : ιᵒᵈ, α i) s
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem sInf_apply (s : Set (Colex ((i : ι) → α i))) (i : ι) :
     sInf s i = ⨅ e : {e ∈ s | ∀ j > i, e j = sInf s j}, e.1 i :=
   Lex.sInf_apply (ι := ιᵒᵈ) s i
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem sInf_apply_le {s : Set (Colex ((i : ι) → α i))} {i : ι} {e : Colex ((i : ι) → α i)}
     (he : e ∈ s) (h : ∀ j > i, e j = sInf s j) : sInf s i ≤ e i :=
   Lex.sInf_apply_le (ι := ιᵒᵈ) he h
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem le_sInf_apply {s : Set (Colex ((i : ι) → α i))} {i : ι} {e : Colex ((i : ι) → α i)}
     (h : ∀ f ∈ s, (∀ j > i, f j = sInf s j) → e i ≤ f i) : e i ≤ sInf s i :=
   Lex.le_sInf_apply (ι := ιᵒᵈ) h
@@ -136,25 +133,21 @@ instance : SupSet (Colex ((i : ι) → α i)) where
   sSup s := sSup (α := Πₗ i : ιᵒᵈ, α i) s
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem sSup_apply (s : Set (Colex ((i : ι) → α i))) (i : ι) :
     sSup s i = ⨆ e : {e ∈ s | ∀ j > i, e j = sSup s j}, e.1 i :=
   Lex.sSup_apply (ι := ιᵒᵈ) s i
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem le_sSup_apply {s : Set (Colex ((i : ι) → α i))} {i : ι} {e : Colex ((i : ι) → α i)}
     (he : e ∈ s) (h : ∀ j > i, e j = sSup s j) : e i ≤ sSup s i :=
   Lex.le_sSup_apply (ι := ιᵒᵈ) he h
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem sSup_apply_le {s : Set (Colex ((i : ι) → α i))} {i : ι} {e : Colex ((i : ι) → α i)}
     (h : ∀ f ∈ s, (∀ j > i, f j = sSup s j) → f i ≤ e i) : sSup s i ≤ e i :=
   Lex.sSup_apply_le (ι := ιᵒᵈ) h
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 noncomputable instance completeLattice : CompleteLattice (Colex ((i : ι) → α i)) where
   isLUB_sSup _ := by exact Lex.isLUB_sSup (ι := ιᵒᵈ)
   isGLB_sInf _ := by exact Lex.isGLB_sInf (ι := ιᵒᵈ)
diff --git a/mathlib4/Mathlib/Order/PiLex.lean b/mathlib4/Mathlib/Order/PiLex.lean
index f952c3280..1d2a72aec 100644
--- a/mathlib4/Mathlib/Order/PiLex.lean
+++ b/mathlib4/Mathlib/Order/PiLex.lean
@@ -121,7 +121,6 @@ instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
       ⟨N₂, fun j hj => (lt_N₁ _ (hj.trans H)).trans (lt_N₂ _ hj), (lt_N₁ _ H).symm ▸ b_lt_c⟩]
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance Colex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
     IsStrictOrder (Colex (∀ i, β i)) (· < ·) :=
   Lex.isStrictOrder (ι := ιᵒᵈ)
@@ -139,7 +138,6 @@ noncomputable instance Lex.linearOrder [LinearOrder ι] [WellFoundedLT ι]
     { trichotomous := (trichotomous_lex _ _ IsWellFounded.wf).1 } (Classical.decRel _)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `Colex (∀ i, α i)` is a linear order if the original order has well-founded `>`. -/
 noncomputable instance Colex.linearOrder [LinearOrder ι] [WellFoundedGT ι]
     [∀ a, LinearOrder (β a)] : LinearOrder (Colex (∀ i, β i)) :=
@@ -218,35 +216,29 @@ section Colex
 variable [WellFoundedGT ι]
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toColex_monotone : Monotone (@toColex (∀ i, β i)) :=
   toLex_monotone (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem toColex_strictMono : StrictMono (@toColex (∀ i, β i)) :=
   toLex_strictMono (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem lt_toColex_update_self_iff : toColex x < toColex (update x i a) ↔ x i < a :=
   lt_toLex_update_self_iff (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toColex_update_lt_self_iff : toColex (update x i a) < toColex x ↔ a < x i :=
   toLex_update_lt_self_iff (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem le_toColex_update_self_iff : toColex x ≤ toColex (update x i a) ↔ x i ≤ a :=
   le_toLex_update_self_iff (ι := ιᵒᵈ)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toColex_update_le_self_iff : toColex (update x i a) ≤ toColex x ↔ a ≤ x i :=
   toLex_update_le_self_iff (ι := ιᵒᵈ)
@@ -336,7 +328,6 @@ theorem Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (
       (Function.update_of_ne hj.ne b a).symm, by rwa [Function.update_self i b]⟩⟩
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem Colex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
     NoMaxOrder (Colex (∀ i, β i)) :=
   Lex.noMaxOrder' (ι := ιᵒᵈ) i
diff --git a/mathlib4/Mathlib/Order/RelIso/Set.lean b/mathlib4/Mathlib/Order/RelIso/Set.lean
index 14c1110ec..dc7326068 100644
--- a/mathlib4/Mathlib/Order/RelIso/Set.lean
+++ b/mathlib4/Mathlib/Order/RelIso/Set.lean
@@ -37,7 +37,6 @@ theorem map_inf [SemilatticeInf α] [LinearOrder β] [FunLike F β α]
 
 -- Defeq abuse: should mediate between `β` and `βᵒᵈ` explicitly
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem map_sup [SemilatticeSup α] [LinearOrder β] [FunLike F β α]
     [RelHomClass F (· > ·) (· > ·)] (a : F) (m n : β) :
     a (m ⊔ n) = a m ⊔ a n :=
diff --git a/mathlib4/Mathlib/Probability/Distributions/Binomial.lean b/mathlib4/Mathlib/Probability/Distributions/Binomial.lean
index dcba34c6d..7c124b3f6 100644
--- a/mathlib4/Mathlib/Probability/Distributions/Binomial.lean
+++ b/mathlib4/Mathlib/Probability/Distributions/Binomial.lean
@@ -127,7 +127,6 @@ lemma binomial_real_self (n : ℕ) (p : I) :
 lemma map_cast_binomial_real_self [MeasurableSingletonClass R] [CharZero R] (n : ℕ) (p : I) :
     Bin(R, n, p).real {(n : R)} = p ^ n := by simp [map_cast_binomial_real_singleton]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 @[simp]
 lemma binomial_one_eq_bernoulliMeasure (p : I) :
diff --git a/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean b/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
index 7ae90d5eb..42f9b7b88 100644
--- a/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
+++ b/mathlib4/Mathlib/Probability/Distributions/Gaussian/CharFun.lean
@@ -60,7 +60,6 @@ lemma IsGaussian.charFunDual_eq' [IsGaussian μ] (L : StrongDual ℝ E) :
   · exact IsGaussian.integrable_id
   · exact IsGaussian.memLp_two_id
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The measure `μ` is Gaussian if and only if there
 exist `m : E` and `f : StrongDual ℝ E →L[ℝ] StrongDual ℝ E →L[ℝ] ℝ`
 satisfying `f.toBilinForm.IsPosSemidef` and `charFunDual μ L = exp (L m * I - f L L / 2)`. -/
@@ -144,7 +143,6 @@ lemma IsGaussian.charFun_eq' [IsGaussian μ] (t : E) :
 
 -- See comment on `ProbabilityTheory.covarianceBilin`.
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The measure `μ` is Gaussian if and only if there
 exist `m : E` and `f : E →L[ℝ]  E →L[ℝ] ℝ`
 satisfying `f.toBilinForm.IsPosSemidef` and `charFun μ t = exp (⟪t, m⟫ * I - f t t / 2)`. -/
@@ -168,7 +166,6 @@ lemma isGaussian_iff_gaussian_charFun [IsFiniteMeasure μ] :
 
 -- See comment on `ProbabilityTheory.covarianceBilin`.
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If the characteristic function of `μ` takes the form of a gaussian characteristic function,
 then the parameters have to be the expectation and the covariance bilinear form. -/
 lemma gaussian_charFun_congr [IsFiniteMeasure μ] (m : E) (f : E →L[ℝ] E →L[ℝ] ℝ)
diff --git a/mathlib4/Mathlib/Probability/Moments/CovarianceBilin.lean b/mathlib4/Mathlib/Probability/Moments/CovarianceBilin.lean
index 4bd5aa894..02a4ae2c9 100644
--- a/mathlib4/Mathlib/Probability/Moments/CovarianceBilin.lean
+++ b/mathlib4/Mathlib/Probability/Moments/CovarianceBilin.lean
@@ -50,7 +50,6 @@ variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
 -- `RingHomCompTriple (starRingEnd ℝ) (RingHom.id ℝ) (starRingEnd ℝ)`, but the third parameter is
 -- an `outParam` so we can't just add the missing instance for `TrivialStar R`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Covariance of a measure on an inner product space, as a continuous bilinear form. -/
 noncomputable
 def covarianceBilin (μ : Measure E) : E →L[ℝ] E →L[ℝ] ℝ :=
@@ -192,7 +191,6 @@ variable [CompleteSpace E]
 
 -- See comment on `ProbabilityTheory.covarianceBilin`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The covariance operator of the measure `μ`. This is the bounded operator `F : E →L[ℝ] E`
 associated to the continuous bilinear form `B : E →L[ℝ] E →L[ℝ] ℝ` such that
 `B x y = ∫ z, ⟪x, z⟫ * ⟪y, z⟫ ∂μ` (see `covarianceOperator_inner`). Namely we have
diff --git a/mathlib4/Mathlib/RepresentationTheory/Basic.lean b/mathlib4/Mathlib/RepresentationTheory/Basic.lean
index 92ef4e7a9..a0d2d91c6 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Basic.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Basic.lean
@@ -224,7 +224,6 @@ we have `Module k[G] (restrictScalars k k[G] M)`.
 -/
 
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp]
 theorem ofModule_asAlgebraHom_apply_apply (r : k[G])
@@ -494,7 +493,6 @@ end
 variable {k G V : Type*} [CommSemiring k] [Group G] [AddCommMonoid V] [Module k V]
   (ρ : Representation k G V)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma asAlgebraHom_ofMulAction_smul_eq_mul (x y : k[G]) :
     (ofMulAction k G G).asAlgebraHom x y = x * y := by
@@ -739,7 +737,6 @@ lemma free_single_single (g h : G) (i : α) (r : k) :
 variable (k G) (α : Type*)
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The free `k[G]`-module on a type `α` is isomorphic to the representation `free k G α`. -/
 noncomputable def finsuppLEquivFreeAsModule : (α →₀ k[G]) ≃ₗ[k[G]] (free k G α).asModule where
   toAddEquiv := (asModuleEquiv _).symm.toAddEquiv
diff --git a/mathlib4/Mathlib/RepresentationTheory/Character.lean b/mathlib4/Mathlib/RepresentationTheory/Character.lean
index 422b8227b..768f3d7f3 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Character.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Character.lean
@@ -101,7 +101,6 @@ theorem char_linHom (g : G) :
 
 variable [Fintype G] [Invertible (Nat.card G : k)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem card_inv_mul_sum_char_eq_finrank :
     (Nat.card G : k)⁻¹ * ∑ g : G, ρ.character g = finrank k (invariants ρ) := by
   have : Invertible (Fintype.card G : k) := by rw [Fintype.card_eq_nat_card]; assumption
@@ -197,7 +196,6 @@ theorem char_linHom (V W : FDRep k G) (g : G) :
 
 variable [Fintype G] [Invertible (Nat.card G : k)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem average_char_eq_finrank_invariants (V : FDRep k G) :
     (Nat.card G : k)⁻¹ * ∑ g : G, V.character g = finrank k (invariants V.ρ) := by
   have : Invertible (Fintype.card G : k) := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Continuous/Basic.lean b/mathlib4/Mathlib/RepresentationTheory/Continuous/Basic.lean
index e20ba486a..81d7d2a93 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Continuous/Basic.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Continuous/Basic.lean
@@ -576,7 +576,6 @@ def coind₁ (π : ContRepresentation R G V) :
 lemma coind₁_apply_apply (π : ContRepresentation R G V) (g : G) (f : C(G, V)) (x : G) :
     π.coind₁ g f x = π g (f (g⁻¹ * x)) := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The functoriality of `coind₁`. -/
 @[simps]
 def coind₁Map {π₁ : ContRepresentation R G V} {π₂ : ContRepresentation R G W} (f : π₁ →ⁱL π₂) :
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/Functoriality.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/Functoriality.lean
index 5e3e0f193..69f6b38f9 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/Functoriality.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/Functoriality.lean
@@ -46,7 +46,6 @@ theorem congr {f₁ f₂ : G →* H} (h : f₁ = f₂) {φ : res f₁ A ⟶ B} {
   subst h
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a group homomorphism `f : G →* H` and a representation morphism `φ : Res(f)(A) ⟶ B`,
 this is the chain map sending `x : Hⁿ → A` to `(g : Gⁿ) ↦ φ (x (f ∘ g))`. -/
 @[simps! -isSimp f f_hom]
@@ -60,18 +59,15 @@ noncomputable def cochainsMap :
     simpa [inhomogeneousCochains.d_hom_apply, Fin.comp_contractNth, CochainComplex.of.d]
       using! (hom_comm_apply φ _ _).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma cochainsMap_id :
     cochainsMap (MonoidHom.id _) (𝟙 A) = 𝟙 (inhomogeneousCochains A) := by
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma cochainsMap_id_f_hom_eq_compLeft {A B : Rep k G} (f : A ⟶ B) (i : ℕ) :
     ((cochainsMap (MonoidHom.id G) f).f i).hom = f.hom.toLinearMap.compLeft _ := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc]
 lemma cochainsMap_comp {G H K : Type u} [Group G] [Group H]
     [Group K] {A : Rep k K} {B : Rep k H} {C : Rep k G} (f : H →* K) (g : G →* H)
@@ -80,18 +76,15 @@ lemma cochainsMap_comp {G H K : Type u} [Group G] [Group H]
       cochainsMap f φ ≫ cochainsMap g ψ := by
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc]
 lemma cochainsMap_id_comp {A B C : Rep k G} (φ : A ⟶ B) (ψ : B ⟶ C) :
     cochainsMap (MonoidHom.id G) (φ ≫ ψ) =
       cochainsMap (MonoidHom.id G) φ ≫ cochainsMap (MonoidHom.id G) ψ := by
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma cochainsMap_zero : cochainsMap (A := A) (B := B) f 0 = 0 := by rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cochainsMap_f_map_mono (hf : Function.Surjective f) [Mono φ] (i : ℕ) :
     Mono ((cochainsMap f φ).f i) := by
   simpa [ModuleCat.mono_iff_injective] using!
@@ -102,7 +95,6 @@ instance cochainsMap_id_f_map_mono {A B : Rep k G} (φ : A ⟶ B) [Mono φ] (i :
     Mono ((cochainsMap (MonoidHom.id G) φ).f i) :=
   cochainsMap_f_map_mono (MonoidHom.id G) φ (fun x => ⟨x, rfl⟩) i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma cochainsMap_f_map_epi (hf : Function.Injective f) [Epi φ] (i : ℕ) :
     Epi ((cochainsMap f φ).f i) := by
   simpa [ModuleCat.epi_iff_surjective] using!
@@ -125,7 +117,6 @@ lemma cochainsMap_congr {f g : G →* H} {φ : res f A ⟶ B} {ψ : res g A ⟶
     cochainsMap f φ = cochainsMap g ψ := by
   subst hfg; congr; ext; simp [hφψ]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma cocyclesMap_id : cocyclesMap (MonoidHom.id G) (𝟙 B) n = 𝟙 _ :=
   HomologicalComplex.cyclesMap_id _ _
@@ -162,7 +153,6 @@ theorem π_map (n : ℕ) :
     π A n ≫ map f φ n = cocyclesMap f φ n ≫ π B n := by
   simp [map, cocyclesMap]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma map_id : map (MonoidHom.id G) (𝟙 B) n = 𝟙 _ := HomologicalComplex.homologyMap_id _ _
 
@@ -225,12 +215,10 @@ lemma cochainsMap_f_0_comp_cochainsIso₀ :
   simp only [cochainsMap_f, Unique.eq_default (f ∘ _)]
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma cochainsMap_f_1_comp_cochainsIso₁ :
     (cochainsMap f φ).f 1 ≫ (cochainsIso₁ B).hom = (cochainsIso₁ A).hom ≫ cochainsMap₁ f φ := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma cochainsMap_f_2_comp_cochainsIso₂ :
     (cochainsMap f φ).f 2 ≫ (cochainsIso₂ B).hom = (cochainsIso₂ A).hom ≫ cochainsMap₂ f φ := by
@@ -239,7 +227,6 @@ lemma cochainsMap_f_2_comp_cochainsIso₂ :
   rcongr x
   fin_cases x <;> rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma cochainsMap_f_3_comp_cochainsIso₃ :
     (cochainsMap f φ).f 3 ≫ (cochainsIso₃ B).hom = (cochainsIso₃ A).hom ≫ cochainsMap₃ f φ := by
@@ -344,7 +331,6 @@ lemma mapCocycles₁_comp_i :
 lemma coe_mapCocycles₁ (x) :
     ⇑(mapCocycles₁ f φ x) = cochainsMap₁ f φ x := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[reassoc (attr := simp), elementwise (attr := simp)]
 lemma cocyclesMap_comp_isoCocycles₁_hom :
@@ -532,10 +518,8 @@ noncomputable def cochainsFunctor : Rep k G ⥤ CochainComplex (ModuleCat k) ℕ
   map_comp φ ψ := cochainsMap_comp (MonoidHom.id G) (MonoidHom.id G) φ ψ
 
 instance : (cochainsFunctor k G).PreservesZeroMorphisms where
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (cochainsFunctor k G).Additive where
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The functor sending a `G`-representation `A` to `Hⁿ(G, A)`. -/
 @[simps]
@@ -547,14 +531,12 @@ noncomputable def functor (n : ℕ) : Rep k G ⥤ ModuleCat k where
     simp only [← HomologicalComplex.homologyMap_comp]
     rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance (n : ℕ) : (functor k G n).PreservesZeroMorphisms where
   map_zero _ _ := by simp [map]
 
 variable {G}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a group homomorphism `f : G →* H`, this is a natural transformation between the functors
 sending `A : Rep k H` to `Hⁿ(H, A)` and to `Hⁿ(G, Res(f)(A))`. -/
@@ -569,7 +551,6 @@ noncomputable def resNatTrans (n : ℕ) :
       ← cochainsMap_comp, res_obj_ρ, Category.comp_id]
     rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Given a normal subgroup `S ≤ G`, this is a natural transformation between the functors
 sending `A : Rep k G` to `Hⁿ(G ⧸ S, A^S)` and to `Hⁿ(G, A)`. -/
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
index 1c5574ed8..9c06581a3 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupCohomology/LowDegree.lean
@@ -91,7 +91,6 @@ end Cochains
 
 section Differentials
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The 0th differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
 `k`-linear map `A → Fun(G, A)`. It sends `(a, g) ↦ ρ_A(g)(a) - a.` -/
 @[simps!]
@@ -118,7 +117,6 @@ lemma subtype_comp_d₀₁ : ModuleCat.ofHom (A.ρ.invariants.subtype) ≫ d₀
   rw [← sub_eq_zero] at hx
   exact hx
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The 1st differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
 `k`-linear map `Fun(G, A) → Fun(G × G, A)`. It sends
 `(f, (g₁, g₂)) ↦ ρ_A(g₁)(f(g₂)) - f(g₁g₂) + f(g₁).` -/
@@ -129,7 +127,6 @@ def d₁₂ : ModuleCat.of k (G → A) ⟶ ModuleCat.of k (G × G → A) :=
     map_add' x y := funext fun g => by dsimp; rw [map_add, add_add_add_comm, add_sub_add_comm]
     map_smul' r x := funext fun g => by dsimp; rw [map_smul, smul_add, smul_sub] }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The 2nd differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
 `k`-linear map `Fun(G × G, A) → Fun(G × G × G, A)`. It sends
 `(f, (g₁, g₂, g₃)) ↦ ρ_A(g₁)(f(g₂, g₃)) - f(g₁g₂, g₃) + f(g₁, g₂g₃) - f(g₁, g₂).` -/
@@ -563,7 +560,6 @@ def cocyclesOfIsCocycle₁ {f : G → A} (hf : IsCocycle₁ f) :
   ⟨f, (mem_cocycles₁_iff (A := Rep.ofDistribMulAction k G A) f).2 hf⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCocycle₁_of_mem_cocycles₁
     (f : G → A) (hf : f ∈ cocycles₁ (Rep.ofDistribMulAction k G A)) :
     IsCocycle₁ f :=
@@ -578,7 +574,6 @@ def coboundariesOfIsCoboundary₁ {f : G → A} (hf : IsCoboundary₁ f) :
   ⟨f, hf.choose, funext hf.choose_spec⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCoboundary₁_of_mem_coboundaries₁
     (f : G → A) (hf : f ∈ coboundaries₁ (Rep.ofDistribMulAction k G A)) :
     IsCoboundary₁ f := by
@@ -594,7 +589,6 @@ def cocyclesOfIsCocycle₂ {f : G × G → A} (hf : IsCocycle₂ f) :
   ⟨f, (mem_cocycles₂_iff (A := Rep.ofDistribMulAction k G A) f).2 hf⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCocycle₂_of_mem_cocycles₂
     (f : G × G → A) (hf : f ∈ cocycles₂ (Rep.ofDistribMulAction k G A)) :
     IsCocycle₂ f := (mem_cocycles₂_iff (A := Rep.ofDistribMulAction k G A) f).1 hf
@@ -608,7 +602,6 @@ def coboundariesOfIsCoboundary₂ {f : G × G → A} (hf : IsCoboundary₂ f) :
   ⟨f, hf.choose,funext fun g ↦ hf.choose_spec g.1 g.2⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCoboundary₂_of_mem_coboundaries₂
     (f : G × G → A) (hf : f ∈ coboundaries₂ (Rep.ofDistribMulAction k G A)) :
     IsCoboundary₂ f := by
@@ -703,7 +696,6 @@ def cocyclesOfIsMulCocycle₁ {f : G → M} (hf : IsMulCocycle₁ f) :
   ⟨Additive.ofMul ∘ f, (mem_cocycles₁_iff (A := Rep.ofMulDistribMulAction G M) f).2 hf⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isMulCocycle₁_of_mem_cocycles₁
     (f : G → M) (hf : f ∈ cocycles₁ (Rep.ofMulDistribMulAction G M)) :
     IsMulCocycle₁ (Additive.toMul ∘ f) :=
@@ -718,7 +710,6 @@ def coboundariesOfIsMulCoboundary₁ {f : G → M} (hf : IsMulCoboundary₁ f) :
   ⟨Additive.ofMul ∘ f, hf.choose, funext hf.choose_spec⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isMulCoboundary₁_of_mem_coboundaries₁
     (f : G → M) (hf : f ∈ coboundaries₁ (Rep.ofMulDistribMulAction G M)) :
     IsMulCoboundary₁ (M := M) (Additive.ofMul ∘ f) := by
@@ -734,7 +725,6 @@ def cocyclesOfIsMulCocycle₂ {f : G × G → M} (hf : IsMulCocycle₂ f) :
   ⟨Additive.ofMul ∘ f, (mem_cocycles₂_iff (A := Rep.ofMulDistribMulAction G M) f).2 hf⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isMulCocycle₂_of_mem_cocycles₂
     (f : G × G → M) (hf : f ∈ cocycles₂ (Rep.ofMulDistribMulAction G M)) :
     IsMulCocycle₂ (Additive.toMul ∘ f) :=
@@ -748,7 +738,6 @@ def coboundariesOfIsMulCoboundary₂ {f : G × G → M} (hf : IsMulCoboundary₂
   ⟨Additive.ofMul ∘ f, hf.choose, funext fun g ↦ hf.choose_spec g.1 g.2⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isMulCoboundary₂_of_mem_coboundaries₂
     (f : G × G → M) (hf : f ∈ coboundaries₂ (Rep.ofMulDistribMulAction G M)) :
     IsMulCoboundary₂ (M := M) (Additive.toMul ∘ f) := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
index 2b2710aae..63cc8f3ef 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/Functoriality.lean
@@ -52,7 +52,6 @@ theorem congr {f₁ f₂ : G →* H} (h : f₁ = f₂) {φ : A ⟶ res f₁ B} {
   subst h
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a group homomorphism `f : G →* H` and a representation morphism `φ : A ⟶ Res(f)(B)`,
 this is the chain map sending `∑ aᵢ·gᵢ : Gⁿ →₀ A` to `∑ φ(aᵢ)·(f ∘ gᵢ) : Hⁿ →₀ B`. -/
 @[simps! -isSimp f f_hom]
@@ -109,7 +108,6 @@ lemma chainsMap_id_comp {A B C : Rep k G} (φ : A ⟶ B) (ψ : B ⟶ C) :
 lemma chainsMap_zero : chainsMap f (0 : A ⟶ res f B) = 0 := by
   ext; simp [chainsMap_f, LinearMap.zero_apply (M₂ := B)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma chainsMap_f_map_mono (hf : Function.Injective f) [Mono φ] (i : ℕ) :
     Mono ((chainsMap f φ).f i) := by
   simpa [ModuleCat.mono_iff_injective] using!
@@ -120,7 +118,6 @@ instance chainsMap_id_f_map_mono {A B : Rep k G} (φ : A ⟶ B) [Mono φ] (i : 
     Mono ((chainsMap (MonoidHom.id G) φ).f i) :=
   chainsMap_f_map_mono (MonoidHom.id G) φ (fun _ _ h => h) _
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma chainsMap_f_map_epi (hf : Function.Surjective f) [Epi φ] (i : ℕ) :
     Epi ((chainsMap f φ).f i) := by
   simpa [ModuleCat.epi_iff_surjective] using!
@@ -620,7 +617,6 @@ and `Y - ∑ aᵢ·sᵢ` is a cycle. -/
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given a `G`-representation `A` and a normal subgroup `S ≤ G`, the degree 1
 corestriction-coinflation sequence `H₁(S, A) ⟶ H₁(G, A) ⟶ H₁(G ⧸ S, A_S)` is exact. `simp`s
 squeezed for performance. -/
@@ -828,7 +824,6 @@ noncomputable def chainsFunctor :
   map_id _ := chainsMap_id
   map_comp φ ψ := chainsMap_comp (MonoidHom.id G) (MonoidHom.id G) φ ψ
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : (chainsFunctor k G).PreservesZeroMorphisms where
   map_zero _ _ := chainsMap_zero (MonoidHom.id G)
 
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
index b481aec9c..5c2b8af84 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean
@@ -636,7 +636,6 @@ def cyclesOfIsCycle₁ (x : G →₀ A) (hx : IsCycle₁ x) :
   ⟨x, (mem_cycles₁_iff (A := Rep.ofDistribMulAction k G A) x).2 hx⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCycle₁_of_mem_cycles₁
     (x : G →₀ A) (hx : x ∈ cycles₁ (Rep.ofDistribMulAction k G A)) :
     IsCycle₁ x := by
@@ -651,7 +650,6 @@ def boundariesOfIsBoundary₁ (x : G →₀ A) (hx : IsBoundary₁ x) :
   ⟨x, hx⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isBoundary₁_of_mem_boundaries₁
     (x : G →₀ A) (hx : x ∈ boundaries₁ (Rep.ofDistribMulAction k G A)) :
     IsBoundary₁ x := hx
@@ -665,7 +663,6 @@ def cyclesOfIsCycle₂ (x : G × G →₀ A) (hx : IsCycle₂ x) :
   ⟨x, (mem_cycles₂_iff (A := Rep.ofDistribMulAction k G A) x).2 hx⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isCycle₂_of_mem_cycles₂
     (x : G × G →₀ A) (hx : x ∈ cycles₂ (Rep.ofDistribMulAction k G A)) :
     IsCycle₂ x := (mem_cycles₂_iff (A := Rep.ofDistribMulAction k G A) x).1 hx
@@ -679,7 +676,6 @@ def boundariesOfIsBoundary₂ (x : G × G →₀ A) (hx : IsBoundary₂ x) :
   ⟨x, hx⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem isBoundary₂_of_mem_boundaries₂
     (x : G × G →₀ A) (hx : x ∈ boundaries₂ (Rep.ofDistribMulAction k G A)) :
     IsBoundary₂ x := hx
@@ -1001,7 +997,6 @@ lemma mkH1OfIsTrivial_apply (g : G) (a : A) :
       H1π A ((cycles₁IsoOfIsTrivial A).inv (single g a)) := rfl
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a `G`-representation on `A` is trivial, this is the natural map `H₁(G, A) → Gᵃᵇ ⊗[ℤ] A`
 sending `⟦single g a⟧` to `⟦g⟧ ⊗ₜ a`. -/
 def H1ToTensorOfIsTrivial : H1 A →ₗ[ℤ] (Additive <| Abelianization G) ⊗[ℤ] A :=
diff --git a/mathlib4/Mathlib/RepresentationTheory/Homological/Resolution.lean b/mathlib4/Mathlib/RepresentationTheory/Homological/Resolution.lean
index a6a4fc58a..137e240b6 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Homological/Resolution.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Homological/Resolution.lean
@@ -190,7 +190,6 @@ theorem d_of {n : ℕ} (c : Fin (n + 1) → G) :
     d k G n (.single c 1) = ∑ p : Fin (n + 1), .single (c ∘ p.succAbove) ((-1 : k) ^ p.val) := by
   simp [d]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma d_single {n : ℕ} (c : Fin (n + 1) → G) (r : k) :
     d k G n (.single c r) =
       ∑ p : Fin (n + 1), .single (c ∘ p.succAbove) (r * (-1 : k) ^ p.val) := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Intertwining.lean b/mathlib4/Mathlib/RepresentationTheory/Intertwining.lean
index 2cd8a6ee2..59254b7f5 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Intertwining.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Intertwining.lean
@@ -536,7 +536,6 @@ def equivLinearMapAsModule :
   left_inv f := rfl
   right_inv f := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Composition of intertwining maps. -/
 def llcomp : IntertwiningMap σ τ →ₗ[A] IntertwiningMap ρ σ →ₗ[A] IntertwiningMap ρ τ where
diff --git a/mathlib4/Mathlib/RepresentationTheory/Invariants.lean b/mathlib4/Mathlib/RepresentationTheory/Invariants.lean
index c49820a10..50c4e2cff 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Invariants.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Invariants.lean
@@ -135,7 +135,6 @@ theorem averageMap_invariant (v : V) : averageMap ρ v ∈ invariants ρ := fun
   rw [averageMap, ← asAlgebraHom_single_one, ← Module.End.mul_apply, ← map_mul (asAlgebraHom ρ),
     mul_average_left]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The `averageMap` acts as the identity on the subspace of invariants.
 -/
 theorem averageMap_id (v : V) (hv : v ∈ invariants ρ) : averageMap ρ v = v := by
diff --git a/mathlib4/Mathlib/RepresentationTheory/Rep/Iso.lean b/mathlib4/Mathlib/RepresentationTheory/Rep/Iso.lean
index 8fe09aa69..4c3818e73 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Rep/Iso.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Rep/Iso.lean
@@ -69,7 +69,6 @@ variable {k : Type u} {G : Type v} [CommRing k] [Monoid G]
 
 open MonoidAlgebra
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Auxiliary lemma for `toModuleMonoidAlgebra`. -/
 theorem to_Module_monoidAlgebra_map_aux {k G : Type*} [CommRing k] [Monoid G] (V W : Type*)
     [AddCommGroup V] [AddCommGroup W] [Module k V] [Module k W] (ρ : G →* V →ₗ[k] V)
diff --git a/mathlib4/Mathlib/RepresentationTheory/Submodule.lean b/mathlib4/Mathlib/RepresentationTheory/Submodule.lean
index 1c5daff13..34683e179 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Submodule.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Submodule.lean
@@ -60,7 +60,6 @@ instance [Nontrivial V] : Nontrivial ρ.invtSubmodule :=
 
 end invtSubmodule
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma asAlgebraHom_mem_of_forall_mem (p : Submodule k V) (hp : ∀ g, ∀ v ∈ p, ρ g v ∈ p)
     (v : V) (hv : v ∈ p) (x : k[G]) :
diff --git a/mathlib4/Mathlib/RepresentationTheory/Subrepresentation.lean b/mathlib4/Mathlib/RepresentationTheory/Subrepresentation.lean
index 6dcc4ad8c..2ef50abca 100644
--- a/mathlib4/Mathlib/RepresentationTheory/Subrepresentation.lean
+++ b/mathlib4/Mathlib/RepresentationTheory/Subrepresentation.lean
@@ -101,7 +101,6 @@ variable [CommSemiring A] [Monoid G] [AddCommMonoid W] [Module A W]
   {ρ : Representation A G W} [AddCommMonoid M] [Module A[G] M]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A subrepresentation of `ρ` can be thought of as an `A[G]` submodule of `ρ.asModule`.
 -/
 def asSubmodule (σ : Subrepresentation ρ) : Submodule A[G] ρ.asModule where
@@ -116,7 +115,6 @@ def asSubmodule (σ : Subrepresentation ρ) : Submodule A[G] ρ.asModule where
 
 -- Type-correct statement would be `(Representation.asModuleEquiv ρ).symm v ∈ asSubmodule σ`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_asSubmodule_iff {σ : Subrepresentation ρ} {v : W} :
     v ∈ asSubmodule σ ↔ v ∈ σ := by rfl
@@ -138,7 +136,6 @@ def asSubmodule' (σ : Subrepresentation (Representation.ofModule (k := A) (G :=
 -- Type-correct statement would be
 -- `m ∈ asSubmodule' σ ↔ Representation.asModuleEquiv (Representation.ofModule M) m ∈ σ`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_asSubmodule'_iff {σ : Subrepresentation (Representation.ofModule (k := A) (G := G) M)}
     {m : M} : m ∈ asSubmodule' σ ↔ m ∈ σ := by rfl
@@ -156,12 +153,10 @@ def ofSubmodule (N : Submodule A[G] M) :
 -- Type-correct statement would be
 -- `Representation.asModuleEquiv (Representation.ofModule M) m ∈ ofSubmodule N ↔ m ∈ N`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_ofSubmodule_iff {N : Submodule A[G] M} {m : M} : m ∈ ofSubmodule N ↔ m ∈ N := by rfl
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An `A[G]`-submodule of `ρ.asModule` can be thought of as a subrepresentation of `ρ`.
 -/
 def ofSubmodule' (N : Submodule A[G] ρ.asModule) : Subrepresentation ρ where
@@ -175,7 +170,6 @@ def ofSubmodule' (N : Submodule A[G] ρ.asModule) : Subrepresentation ρ where
     exact h
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma mem_ofSubmodule'_iff {N : Submodule A[G] ρ.asModule} {w : W} : w ∈ ofSubmodule' N ↔ w ∈ N :=
   .rfl
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/Algebra.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/Algebra.lean
index 9ea23eb4a..07afcc4ab 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/Algebra.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/Algebra.lean
@@ -304,7 +304,6 @@ instance : IsScalarTower R (R ⧸ (I • ⊤ : Ideal R)) (M ⧸ (I • ⊤ : Sub
     rw [← Submodule.Quotient.mk_smul, Ideal.Quotient.mk_eq_mk, mk_smul_mk, smul_assoc]
     rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance smul : SMul (AdicCompletion I R) (AdicCompletion I M) where
   smul r x := {
@@ -317,13 +316,11 @@ instance smul : SMul (AdicCompletion I R) (AdicCompletion I M) where
       rw [smul_mk I hmn]
   }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem smul_eval (n : ℕ) (r : AdicCompletion I R) (x : AdicCompletion I M) :
     (r • x).val n = r.val n • x.val n :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `AdicCompletion I M` is naturally an `AdicCompletion I R` module. -/
 instance module : Module (AdicCompletion I R) (AdicCompletion I M) where
   one_smul b := by
@@ -342,7 +339,6 @@ instance : IsScalarTower R (AdicCompletion I R) (AdicCompletion I M) where
     ext n
     rw [smul_eval, val_smul_apply, val_smul_apply, smul_eval, smul_assoc]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- A priori `AdicCompletion I R` has two `AdicCompletion I R`-module instances.
 Both agree definitionally. -/
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/Basic.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/Basic.lean
index 9bfd9bc40..48c570d3a 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/Basic.lean
@@ -263,7 +263,6 @@ end IsPrecomplete
 
 namespace AdicCompletion
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `AdicCompletion` is the submodule of compatible families in
 `∀ n : ℕ, M ⧸ (I ^ n • ⊤)`. -/
 def submodule : Submodule R (∀ n : ℕ, M ⧸ (I ^ n • ⊤ : Submodule R M)) where
@@ -679,7 +678,6 @@ theorem of_ofLinearEquiv_symm (x : AdicCompletion I M) :
 
 end Bijective
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem pow_smul_top_le_ker_eval (n : ℕ) : I ^ n • ⊤ ≤ (eval I M n).ker := by
   simp only [smul_le, mem_top, LinearMap.mem_ker, map_smul, coe_eval, forall_const]
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/Completeness.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/Completeness.lean
index 24c3fd5c6..418dd7fdd 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/Completeness.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/Completeness.lean
@@ -124,7 +124,6 @@ theorem restrictScalars_range_ofPowSMul_eq_ker_eval {n : ℕ} :
   simp only [LinearMap.mem_ker, coe_eval] at hx
   use ofValEqZero I hx; simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /- An intermediate helper lemma for the theorem below to avoid introducing
 `AdicCompletion.finsuppSum` (the `Finsupp` version of `AdicCompletion.sum`).
 It proves the equality of two linear maps:
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/Functoriality.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/Functoriality.lean
index e30c3544e..b71da4435 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/Functoriality.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@@ -102,7 +102,6 @@ theorem map_zero : map I (0 : M →ₗ[R] N) = 0 :=
 
 end AdicCauchySequence
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- A linear map induces a map on adic completions. -/
 def map (f : M →ₗ[R] N) :
     AdicCompletion I M →ₗ[AdicCompletion I R] AdicCompletion I N where
@@ -360,7 +359,6 @@ open Submodule
 
 variable {I}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem exists_smodEq_pow_add_one_smul {f : M →ₗ[R] N}
     (h : Function.Surjective (mkQ (I • ⊤) ∘ₗ f)) {y : N} {n : ℕ}
diff --git a/mathlib4/Mathlib/RingTheory/AdicCompletion/LocalRing.lean b/mathlib4/Mathlib/RingTheory/AdicCompletion/LocalRing.lean
index d0f972467..dc5d64818 100644
--- a/mathlib4/Mathlib/RingTheory/AdicCompletion/LocalRing.lean
+++ b/mathlib4/Mathlib/RingTheory/AdicCompletion/LocalRing.lean
@@ -153,7 +153,6 @@ lemma residueField_map_bijective [IsNoetherianRing R] [IsLocalRing R] :
       (algebraMap R (AdicCompletion (maximalIdeal R) R))) :=
     AdicCompletion.residueField_map_bijective_of_fg (maximalIdeal R).fg_of_isNoetherianRing
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma spanFinrank_maximalIdeal_eq [IsNoetherianRing R] [IsLocalRing R] :
     (maximalIdeal (AdicCompletion (maximalIdeal R) R)).spanFinrank =
     (maximalIdeal R).spanFinrank := by
diff --git a/mathlib4/Mathlib/RingTheory/Adjoin/PowerBasis.lean b/mathlib4/Mathlib/RingTheory/Adjoin/PowerBasis.lean
index f000745ef..315df15f4 100644
--- a/mathlib4/Mathlib/RingTheory/Adjoin/PowerBasis.lean
+++ b/mathlib4/Mathlib/RingTheory/Adjoin/PowerBasis.lean
@@ -92,7 +92,6 @@ variable {R : Type*} [CommRing R] [Algebra R S] [Algebra R K] [IsScalarTower R K
 variable {A : Type*} [CommRing A] [Algebra R A] [Algebra S A]
 variable [IsScalarTower R S A] {B : PowerBasis S A}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `B : PowerBasis S A` is such that `IsIntegral R B.gen`, then
 `IsIntegral R (B.basis.repr (B.gen ^ n) i)` for all `i` if
 `minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)`. This is the case if `R` is a GCD domain
@@ -168,7 +167,6 @@ theorem repr_pow_isIntegral (hB : IsIntegral R B.gen) {x : A}
     rw [pow_succ]
     exact repr_mul_isIntegral hB (fun _ => hn _ le_rfl (fun _ => hx _) _) hx hmin
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `B B' : PowerBasis K S` be such that `IsIntegral R B.gen`, and let `P : R[X]` be such that
 `aeval B.gen P = B'.gen`. Then `IsIntegral R (B.basis.to_matrix B'.basis i j)` for all `i` and `j`
 if `minpoly K B.gen = (minpoly R B.gen).map (algebraMap R L)`. This is the case
diff --git a/mathlib4/Mathlib/RingTheory/AlgebraTower.lean b/mathlib4/Mathlib/RingTheory/AlgebraTower.lean
index d51af1f58..115298b10 100644
--- a/mathlib4/Mathlib/RingTheory/AlgebraTower.lean
+++ b/mathlib4/Mathlib/RingTheory/AlgebraTower.lean
@@ -135,7 +135,6 @@ theorem smulTower_repr (x ij) :
 theorem smulTower_repr_mk (x i j) : (b.smulTower c).repr x (i, j) = b.repr (c.repr x j) i :=
   b.smulTower_repr c x (i, j)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem smulTower_apply (ij) : (b.smulTower c) ij = b ij.1 • c ij.2 := by
   classical
diff --git a/mathlib4/Mathlib/RingTheory/Algebraic/Integral.lean b/mathlib4/Mathlib/RingTheory/Algebraic/Integral.lean
index 7bce98242..9ef1db23b 100644
--- a/mathlib4/Mathlib/RingTheory/Algebraic/Integral.lean
+++ b/mathlib4/Mathlib/RingTheory/Algebraic/Integral.lean
@@ -244,7 +244,6 @@ theorem restrictScalars_of_isIntegral [int : Algebra.IsIntegral R S]
     e, ← Algebra.smul_def, mul_comm, mul_smul]
   exact isIntegral_trans _ (int_s.smul _)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 theorem restrictScalars [Algebra.IsAlgebraic R S]
     {a : A} (h : IsAlgebraic S a) : IsAlgebraic R a := by
diff --git a/mathlib4/Mathlib/RingTheory/Bialgebra/Equiv.lean b/mathlib4/Mathlib/RingTheory/Bialgebra/Equiv.lean
index c2d46634e..a121f140f 100644
--- a/mathlib4/Mathlib/RingTheory/Bialgebra/Equiv.lean
+++ b/mathlib4/Mathlib/RingTheory/Bialgebra/Equiv.lean
@@ -55,7 +55,6 @@ variable {F R A B : Type*} [CommSemiring R] [Semiring A] [Semiring B]
   [Algebra R A] [Algebra R B] [CoalgebraStruct R A] [CoalgebraStruct R B]
   [EquivLike F A B] [BialgEquivClass F R A B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance (priority := 100) toBialgHomClass : BialgHomClass F R A B where
   map_add := map_add
   map_smulₛₗ := map_smul
@@ -311,7 +310,6 @@ end
 
 variable [Semiring A] [Semiring B] [Bialgebra R A] [Bialgebra R B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Construct a bialgebra equiv from an algebra equiv respecting counit and comultiplication. -/
 @[simps apply] def ofAlgEquiv (f : A ≃ₐ[R] B)
     (counit_comp : (Bialgebra.counitAlgHom R B).comp f = Bialgebra.counitAlgHom R A)
diff --git a/mathlib4/Mathlib/RingTheory/Bialgebra/Hom.lean b/mathlib4/Mathlib/RingTheory/Bialgebra/Hom.lean
index f544284a8..3f5f5d8f0 100644
--- a/mathlib4/Mathlib/RingTheory/Bialgebra/Hom.lean
+++ b/mathlib4/Mathlib/RingTheory/Bialgebra/Hom.lean
@@ -65,7 +65,6 @@ variable [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B]
   [CoalgebraStruct R A] [CoalgebraStruct R B] [FunLike F A B]
   [BialgHomClass F R A B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 instance (priority := 100) toAlgHomClass : AlgHomClass F R A B where
   map_mul := map_mul
@@ -316,7 +315,6 @@ end AlgebraCoalgebra
 
 variable [Bialgebra R A] [Bialgebra R B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Construct a bialgebra hom from an algebra hom respecting counit and comultiplication. -/
 @[simps!]
 def ofAlgHom (f : A →ₐ[R] B) (counit_comp : (counitAlgHom R B).comp f = counitAlgHom R A)
diff --git a/mathlib4/Mathlib/RingTheory/Bialgebra/MonoidAlgebra.lean b/mathlib4/Mathlib/RingTheory/Bialgebra/MonoidAlgebra.lean
index c9012f9f5..a974bdfd2 100644
--- a/mathlib4/Mathlib/RingTheory/Bialgebra/MonoidAlgebra.lean
+++ b/mathlib4/Mathlib/RingTheory/Bialgebra/MonoidAlgebra.lean
@@ -284,7 +284,6 @@ def mapDomainOfBialgHom (f : R[G] →ₐc[R] R[H]) : G →* H where
     rw [← mul_one (1 : R), ← single_mul_single, ← single_mul_single, map_mul]
     simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[to_additive (dont_translate := R) (attr := simp)]
 lemma single_mapDomainOfBialgHom (f : R[G] →ₐc[R] R[H]) (g : G) (r : R) :
     single (mapDomainOfBialgHom f g) r = f (single g r) := by
diff --git a/mathlib4/Mathlib/RingTheory/DedekindDomain/Different.lean b/mathlib4/Mathlib/RingTheory/DedekindDomain/Different.lean
index 9668bfe14..d4f293ebe 100644
--- a/mathlib4/Mathlib/RingTheory/DedekindDomain/Different.lean
+++ b/mathlib4/Mathlib/RingTheory/DedekindDomain/Different.lean
@@ -439,7 +439,6 @@ theorem smul_mem_dual_one {x : L} (hx : x ∈ dual A K (1 : FractionalIdeal B⁰
 
 variable [IsTorsionFree B C]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem dual_eq_dual_mul_dual :
     dual A K (1 : FractionalIdeal C⁰ M) = dual B L (1 : FractionalIdeal C⁰ M) *
         (dual A K (1 : FractionalIdeal B⁰ L)).extendedHom M C := by
@@ -688,7 +687,6 @@ variable [IsFractionRing B L] [IsDedekindDomain A] [IsDedekindDomain B]
 
 set_option linter.overlappingInstances false
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include K L in
 lemma pow_sub_one_dvd_differentIdeal_aux
     {p : Ideal A} [p.IsMaximal] (P : Ideal B) {e : ℕ} (he : e ≠ 0) (hp : p ≠ ⊥)
@@ -848,7 +846,6 @@ theorem not_dvd_differentIdeal_of_isCoprime
       exact Ideal.mul_le_right
   exact not_dvd_differentIdeal_of_isCoprime_of_isSeparable A P Q hPQ hP
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma dvd_differentIdeal_of_not_isSeparable
     [Algebra.IsSeparable (FractionRing A) (FractionRing B)]
     {p : Ideal A} [p.IsMaximal] (hp : p ≠ ⊥)
diff --git a/mathlib4/Mathlib/RingTheory/Derivation/Basic.lean b/mathlib4/Mathlib/RingTheory/Derivation/Basic.lean
index a34ac262f..e0e05c8fe 100644
--- a/mathlib4/Mathlib/RingTheory/Derivation/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Derivation/Basic.lean
@@ -264,7 +264,6 @@ variable {N : Type*} [AddCommMonoid N] [Module A N] [Module R N] [IsScalarTower
 
 variable (f : M →ₗ[A] N) (e : M ≃ₗ[A] N)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- We can push forward derivations using linear maps, i.e., the composition of a derivation with a
 linear map is a derivation. Furthermore, this operation is linear on the spaces of derivations. -/
@@ -278,17 +277,14 @@ def _root_.LinearMap.compDer : Derivation R A M →ₗ[A] Derivation R A N where
   map_add' D₁ D₂ := by ext; exact LinearMap.map_add _ _ _
   map_smul' r D := by ext; dsimp; simp only [_root_.map_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_to_linearMap_comp : (f.compDer D : A →ₗ[R] N) = (f : M →ₗ[R] N).comp (D : A →ₗ[R] M) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem coe_comp : (f.compDer D : A → N) = (f : M →ₗ[R] N).comp (D : A →ₗ[R] M) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The composition of a derivation with a linear map as a bilinear map -/
 @[simps]
 def llcomp : (M →ₗ[A] N) →ₗ[A] Derivation R A M →ₗ[A] Derivation R A N where
@@ -296,7 +292,6 @@ def llcomp : (M →ₗ[A] N) →ₗ[A] Derivation R A M →ₗ[A] Derivation R A
   map_add' f₁ f₂ := by ext; rfl
   map_smul' r D := by ext; rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Pushing a derivation forward through a linear equivalence is an equivalence. -/
 def _root_.LinearEquiv.compDer : Derivation R A M ≃ₗ[A] Derivation R A N :=
   { e.toLinearMap.compDer with
@@ -304,13 +299,11 @@ def _root_.LinearEquiv.compDer : Derivation R A M ≃ₗ[A] Derivation R A N :=
     left_inv := fun D => by ext a; exact e.symm_apply_apply (D a)
     right_inv := fun D => by ext a; exact e.apply_symm_apply (D a) }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem linearEquiv_coe_to_linearMap_comp :
     (e.compDer D : A →ₗ[R] N) = (e.toLinearMap : M →ₗ[R] N).comp (D : A →ₗ[R] M) :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem linearEquiv_coe_comp :
     (e.compDer D : A → N) = (e.toLinearMap : M →ₗ[R] N).comp (D : A →ₗ[R] M) :=
@@ -368,7 +361,6 @@ variable [CommSemiring R] [CommRing A] [CommRing M]
 variable [Algebra R A] [Algebra R M]
 variable {F : Type*} [FunLike F A M] [AlgHomClass F R A M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /--
 Lift a derivation via an algebra homomorphism `f` with a right inverse such that
diff --git a/mathlib4/Mathlib/RingTheory/DividedPowerAlgebra/Init.lean b/mathlib4/Mathlib/RingTheory/DividedPowerAlgebra/Init.lean
index 2f51e9c0a..388a23a45 100644
--- a/mathlib4/Mathlib/RingTheory/DividedPowerAlgebra/Init.lean
+++ b/mathlib4/Mathlib/RingTheory/DividedPowerAlgebra/Init.lean
@@ -302,7 +302,6 @@ variable (R M)
 
 variable {A : Type*} [CommSemiring A] [Algebra R A]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private theorem lift'_imp {f : ℕ × M → A} (hf_zero : ∀ m, f (0, m) = 1)
     (hf_smul : ∀ (n : ℕ) (r : R) (m : M), f ⟨n, r • m⟩ = r ^ n • f ⟨n, m⟩)
     (hf_mul : ∀ n p m, f ⟨n, m⟩ * f ⟨p, m⟩ = (n + p).choose n • f ⟨n + p, m⟩)
diff --git a/mathlib4/Mathlib/RingTheory/Etale/Kaehler.lean b/mathlib4/Mathlib/RingTheory/Etale/Kaehler.lean
index c705d373f..7831c3c5a 100644
--- a/mathlib4/Mathlib/RingTheory/Etale/Kaehler.lean
+++ b/mathlib4/Mathlib/RingTheory/Etale/Kaehler.lean
@@ -138,7 +138,6 @@ def tensorCotangentSpaceOfFormallyEtale
       ext a
       simp; rfl }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- (Implementation)
 If `J ≃ Q ⊗ₚ I` (e.g. when `T = Q ⊗ₚ S` and `P → Q` is flat), then `T ⊗ₛ I/I² ≃ J/J²`.
 This is the inverse. -/
@@ -201,7 +200,6 @@ lemma tensorCotangentInvFun_smul_mk
   rw [e.symm_apply_apply]
   simp
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `J ≃ Q ⊗ₚ I` (e.g. when `T = Q ⊗ₚ S` and `P → Q` is flat), then `T ⊗ₛ I/I² ≃ J/J²`. -/
 noncomputable
 def tensorCotangent [alg : Algebra P.Ring Q.Ring] (halg : algebraMap P.Ring Q.Ring = f.toRingHom)
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/BaseChange.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/BaseChange.lean
index 12fa897ef..a173e7618 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/BaseChange.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/BaseChange.lean
@@ -112,7 +112,6 @@ noncomputable def tensorCotangentOfFlat [Module.Flat R T] :
     (Ideal.Cotangent.equivOfEq _ _ (P.ker_baseChange T).symm).restrictScalars T ≪≫ₗ
     (P.baseChange (T := T)).cotangentEquivCotangentKer.symm.restrictScalars T
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 attribute [local instance] Algebra.TensorProduct.rightAlgebra in
 @[simp]
@@ -206,7 +205,6 @@ noncomputable def tensorH1CotangentOfFlat (T : Type*) [CommRing T] [Algebra R T]
       ((Generators.self R S).baseChangeToBaseChange T)).restrictScalars T ≪≫ₗ
     ((Generators.self R S).baseChange (T := T)).equivH1Cotangent.restrictScalars T
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 attribute [local instance] TensorProduct.rightAlgebra in
 lemma tensorH1CotangentOfFlat_tmul (T : Type*) [CommRing T] [Algebra R T] [Module.Flat R T]
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basic.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basic.lean
index bf719aee7..fee707ff8 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basic.lean
@@ -243,7 +243,6 @@ def Hom.subToKer (f g : Hom P P') : P.Ring →ₗ[R] P'.ker := by
     Submodule.restrictScalars_mem, RingHom.mem_ker, map_sub, algebraMap_toRingHom,
     sub_self, toAlgHom_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable [IsScalarTower R S S'] in
 /--
 If `f` and `g` are two maps `P → P'` between presentations,
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
index bbeceb700..e39bf3448 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Basis.lean
@@ -55,7 +55,6 @@ variable {P} {b}
 variable (D : Aux P b)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `T = R[X₁, ..., Xₙ] / (b₁, ..., bᵣ)` where the `bᵢ` are lifts of the basis elements
 of `I/I²` in `I`. -/
 abbrev T :=
@@ -347,7 +346,6 @@ Then `respectTransparency false` and `instanceTypes false` can both go.
 set_option backward.isDefEq.instanceTypes false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 open PresentationOfFreeCotangent in
 /--
 Version of `Algebra.Generators.exists_presentation_of_free_cotangent` taking a basis instead
@@ -403,7 +401,6 @@ public lemma exists_presentation_of_basis_cotangent [Algebra.FinitePresentation
 
 open PresentationOfFreeCotangent in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `S` be a finitely presented `R`-algebra and suppose `P : R[X] → S` generates `S` with
 kernel `I`. If `I/I²` is free, there exists an `R`-presentation `P'` of `S` extending `P` with
 kernel `I'`, such that `I'/I'²` is free on the images of the relations of `P'`.
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Free.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Free.lean
index 06921833e..4fb3164a8 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Free.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/Free.lean
@@ -78,7 +78,6 @@ lemma cotangentRestrict_bijective_of_isCompl
     · exact P.cotangentSpaceBasis.repr.symm.surjective
   · simpa [g, Submodule.map_comp, Submodule.map_span, ← Set.range_comp, Function.comp_def]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma disjoint_ker_toKaehler_of_linearIndependent
     (h : LinearIndependent S (fun k ↦ D R S (P.val (v k)))) :
     Disjoint (LinearMap.ker P.toExtension.toKaehler)
diff --git a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean
index 8623136c0..0afd7ec27 100644
--- a/mathlib4/Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean
+++ b/mathlib4/Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean
@@ -118,7 +118,6 @@ lemma sq_ker_comp_le_ker_compLocalizationAwayAlgHom :
       simp [hsple hx]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 Let `R → S → T` be algebras such that `T` is the localization of `S` away from one
 element, where `S` is generated over `R` by `P` with kernel `I` and `Q` is the
diff --git a/mathlib4/Mathlib/RingTheory/FiniteType.lean b/mathlib4/Mathlib/RingTheory/FiniteType.lean
index dcd0b6434..1ba1ee31b 100644
--- a/mathlib4/Mathlib/RingTheory/FiniteType.lean
+++ b/mathlib4/Mathlib/RingTheory/FiniteType.lean
@@ -374,7 +374,6 @@ end Ring
 
 end Span
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a set `S` generates an additive monoid `M`, then the image of `M` generates, as algebra,
 `R[M]`. -/
 theorem mvPolynomial_aeval_of_surjective_of_closure [AddCommMonoid M] [CommSemiring R] {S : Set M}
@@ -403,7 +402,6 @@ theorem mvPolynomial_aeval_of_surjective_of_closure [AddCommMonoid M] [CommSemir
 
 variable [AddMonoid M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a set `S` generates an additive monoid `M`, then the image of `M` generates, as algebra,
 `R[M]`. -/
 theorem freeAlgebra_lift_of_surjective_of_closure [CommSemiring R] {S : Set M}
@@ -525,7 +523,6 @@ end Ring
 
 end Span
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a set `S` generates a monoid `M`, then the image of `M` generates, as algebra,
 `R[M]`. -/
 theorem mvPolynomial_aeval_of_surjective_of_closure [CommMonoid M] [CommSemiring R] {S : Set M}
@@ -553,7 +550,6 @@ theorem mvPolynomial_aeval_of_surjective_of_closure [CommMonoid M] [CommSemiring
 
 variable [Monoid M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If a set `S` generates an additive monoid `M`, then the image of `M` generates, as algebra,
 `R[M]`. -/
 theorem freeAlgebra_lift_of_surjective_of_closure [CommSemiring R] {S : Set M}
@@ -605,7 +601,6 @@ end MonoidAlgebra
 
 section Orzech
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open Submodule Module Module.Finite in
 /--
 Any commutative ring `R` satisfies the `OrzechProperty`, that is, for any finitely generated
diff --git a/mathlib4/Mathlib/RingTheory/Flat/EquationalCriterion.lean b/mathlib4/Mathlib/RingTheory/Flat/EquationalCriterion.lean
index a36517a6e..f5de68128 100644
--- a/mathlib4/Mathlib/RingTheory/Flat/EquationalCriterion.lean
+++ b/mathlib4/Mathlib/RingTheory/Flat/EquationalCriterion.lean
@@ -100,7 +100,6 @@ end Module
 
 namespace Module.Flat
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (R M) in
 /-- **Equational criterion for flatness**, combined form.
 
diff --git a/mathlib4/Mathlib/RingTheory/Flat/FaithfullyFlat/Basic.lean b/mathlib4/Mathlib/RingTheory/Flat/FaithfullyFlat/Basic.lean
index 6b4f32e4e..c2d6c3c60 100644
--- a/mathlib4/Mathlib/RingTheory/Flat/FaithfullyFlat/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Flat/FaithfullyFlat/Basic.lean
@@ -267,7 +267,6 @@ variable {N2 : Type*} [AddCommGroup N2] [Module R N2]
 variable {N3 : Type*} [AddCommGroup N3] [Module R N3]
 variable (l12 : N1 →ₗ[R] N2) (l23 : N2 →ₗ[R] N3)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 If `M` is faithfully flat, then exactness of `N₁ ⊗ M -> N₂ ⊗ M -> N₃ ⊗ M` implies that the
 composition `N₁ -> N₂ -> N₃` is `0`.
diff --git a/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean b/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
index ccd039d68..9b639fe65 100644
--- a/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
+++ b/mathlib4/Mathlib/RingTheory/FractionalIdeal/Operations.lean
@@ -53,7 +53,6 @@ section
 variable {P' : Type*} [CommRing P'] [Algebra R P']
 variable {P'' : Type*} [CommRing P''] [Algebra R P'']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.IsFractional.map (g : P →ₐ[R] P') {I : Submodule R P} :
     IsFractional S I → IsFractional S (Submodule.map g.toLinearMap I)
   | ⟨a, a_nonzero, hI⟩ =>
@@ -951,7 +950,6 @@ theorem _root_.IsFractional.mapEquiv {I : Submodule R K} (hI : IsFractional R⁰
     ← map_mul, ← Algebra.smul_def, ← hr', ringEquivOfRingEquiv_algebraMap]
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The equiv `FractionalIdeal R⁰ K ≃+* FractionalIdeal S⁰ L`
   induced by a ring isomorphism `f : R ≃+* S`. -/
 @[simps -isSimp]
@@ -1018,7 +1016,6 @@ lemma ringEquivOfRingEquiv_refl :
   simp [semilinearEquivOfRingEquiv]
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ringEquivOfRingEquiv_spanSingleton (x : K) :
     FractionalIdeal.ringEquivOfRingEquiv K L f (spanSingleton R⁰ x) =
       spanSingleton S⁰ (IsFractionRing.ringEquivOfRingEquiv (L := L) f x) := by
diff --git a/mathlib4/Mathlib/RingTheory/HopfAlgebra/Basic.lean b/mathlib4/Mathlib/RingTheory/HopfAlgebra/Basic.lean
index 1d10dfbe9..8383ce9c3 100644
--- a/mathlib4/Mathlib/RingTheory/HopfAlgebra/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/HopfAlgebra/Basic.lean
@@ -120,7 +120,6 @@ lemma sum_mul_antipode_eq_smul (repr : Repr R a ι) :
       counit (R := R) a • 1 := by
   rw [sum_mul_antipode_eq_algebraMap_counit, Algebra.smul_def, mul_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 @[simp] lemma counit_antipode (a : A) : counit (R := R) (antipode R a) = counit a := by
   calc
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean b/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean
index 6c6988b3b..4c6e4b8ec 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Basic.lean
@@ -115,7 +115,6 @@ theorem isAssociatedPrime_iff [IsNoetherianRing R] :
     IsAssociatedPrime I M ↔ I.IsPrime ∧ ∃ x : M, I = colon ⊥ {x} :=
   (⊥ : Submodule R M).isAssociatedPrime_iff
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem IsAssociatedPrime.map_of_injective (h : IsAssociatedPrime I M) (hf : Function.Injective f) :
     IsAssociatedPrime I M' := by
@@ -164,7 +163,6 @@ contained in that of `M'`. -/
 theorem subset_of_injective (hf : Function.Injective f) :
     associatedPrimes R M ⊆ associatedPrimes R M' := fun _I h => h.map_of_injective f hf
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If `0 → M → M' → M''` is an exact sequence, then the set of associated primes of `M'` is
 contained in the union of those of `M` and `M''`. -/
 @[stacks 02M3 "second part"]
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean b/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean
index d0f70376d..8981a4233 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/AssociatedPrime/Finiteness.lean
@@ -51,7 +51,6 @@ variable {A : Type u} [CommRing A] {M : Type v} [AddCommGroup M] [Module A M]
 def Submodule.IsQuotientEquivQuotientPrime (N₁ N₂ : Submodule A M) :=
   N₁ ≤ N₂ ∧ ∃ (p : PrimeSpectrum A), Nonempty ((↥N₂ ⧸ N₁.submoduleOf N₂) ≃ₗ[A] A ⧸ p.1)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open LinearMap in
 theorem Submodule.isQuotientEquivQuotientPrime_iff {N₁ N₂ : Submodule A M} :
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Cotangent.lean b/mathlib4/Mathlib/RingTheory/Ideal/Cotangent.lean
index 593edfd56..1a2e1331f 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Cotangent.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Cotangent.lean
@@ -103,7 +103,6 @@ lemma cotangentToQuotientSquare_injective : Function.Injective I.cotangentToQuot
   rw [toCotangent_to_quotient_square] at hx
   rwa [Ideal.toCotangent_eq_zero, ← Submodule.Quotient.mk_eq_zero (I ^ 2)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Cotangent.smul_eq_zero_of_mem {I : Ideal R}
     {x} (hx : x ∈ I) (m : I.Cotangent) : x • m = 0 := by
   obtain ⟨m, rfl⟩ := Ideal.toCotangent_surjective _ m
@@ -236,7 +235,6 @@ section Lift
 variable {S : Type*} [CommRing S] [Algebra R S] {I : Ideal S}
 variable {M : Type*} [AddCommGroup M] [Module R M]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Lift a linear map `f : I →ₗ[R] M` that vanishes on products to a linear map on the
 cotangent space `I ⧸ I ^ 2`. -/
 def lift (f : I →ₗ[R] M) (hf : ∀ (x y : I), f (x * y) = 0) :
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Maps.lean b/mathlib4/Mathlib/RingTheory/Ideal/Maps.lean
index fac6d124e..2dd5b2513 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Maps.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Maps.lean
@@ -868,12 +868,10 @@ lemma Module.mem_annihilator_iff_lsmul_eq_zero {R : Type*} [CommSemiring R]
 instance (priority := low) : (Module.annihilator R M).IsTwoSided :=
   inferInstanceAs (RingHom.ker _).IsTwoSided
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem LinearMap.annihilator_le_of_injective (f : M →ₗ[R] M') (hf : Function.Injective f) :
     Module.annihilator R M' ≤ Module.annihilator R M := fun x h ↦ by
   rw [Module.mem_annihilator] at h ⊢; exact fun m ↦ hf (by rw [map_smul, h, f.map_zero])
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem LinearMap.annihilator_le_of_surjective (f : M →ₗ[R] M')
     (hf : Function.Surjective f) : Module.annihilator R M ≤ Module.annihilator R M' := fun x h ↦ by
   rw [Module.mem_annihilator] at h ⊢
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean b/mathlib4/Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean
index 18e9c58b9..3b1983bbe 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean
@@ -273,7 +273,6 @@ theorem span_singleton_absNorm {I : Ideal S} (hI : (Ideal.absNorm I).Prime) :
 variable [Module.Finite ℤ S]
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `e : S ≃ I` be an additive isomorphism (therefore a `ℤ`-linear equiv).
 Then an alternative way to compute the norm of `I` is given by taking the determinant of `e`.
 See `natAbs_det_basis_change` for a more familiar formulation of this result. -/
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Basic.lean b/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Basic.lean
index 2bed3a81f..40e51966a 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Basic.lean
@@ -201,7 +201,6 @@ noncomputable def piQuotEquiv [I.IsTwoSided] : ((ι → R) ⧸ pi fun _ ↦ I) 
     exact Ideal.Quotient.eq.2 fun i ↦ Ideal.Quotient.eq.1 (Quotient.out_eq' _)
   right_inv x := funext fun i ↦ Quotient.out_eq' (x i)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- If `f : R^n → R^m` is an `R`-linear map and `I ⊆ R` is an ideal, then the image of `I^n` is
     contained in `I^m`. -/
diff --git a/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Operations.lean b/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Operations.lean
index 6fde85e86..f576ed389 100644
--- a/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Operations.lean
+++ b/mathlib4/Mathlib/RingTheory/Ideal/Quotient/Operations.lean
@@ -466,7 +466,6 @@ section
 
 variable [Semiring B] [Algebra R₁ B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- `Ideal.quotient.lift` as an `AlgHom`. -/
 def Quotient.liftₐ (I : Ideal A) [I.IsTwoSided] (f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) :
@@ -502,7 +501,6 @@ lemma Quotient.smul_top {R : Type*} [CommRing R] (a : R) (I : Ideal R) :
     (a • ⊤ : Submodule R (R ⧸ I)) = Submodule.span R {Submodule.Quotient.mk a} := by
   simp [← Ideal.Quotient.span_singleton_one, Algebra.smul_def, Submodule.smul_span]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem KerLift.map_smul (f : A →ₐ[R₁] B) (r : R₁) (x : A ⧸ (RingHom.ker f)) :
     f.kerLift (r • x) = r • f.kerLift x := by
   obtain ⟨a, rfl⟩ := Quotient.mkₐ_surjective R₁ _ x
diff --git a/mathlib4/Mathlib/RingTheory/IdealFilter/Topology.lean b/mathlib4/Mathlib/RingTheory/IdealFilter/Topology.lean
index c2d52d29b..770337cb0 100644
--- a/mathlib4/Mathlib/RingTheory/IdealFilter/Topology.lean
+++ b/mathlib4/Mathlib/RingTheory/IdealFilter/Topology.lean
@@ -127,7 +127,6 @@ lemma mem_nhds_zero_iff {s : Set (WithIdealFilter F)} :
 -- Defeq abuse: uses `AddSubmonoidClass (Submodule A A) A` as
 -- `AddSubmonoidClass (Submodule A A) (WithIdealFilter F)`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The topology is linear in the sense that `𝓝 0` has a basis of ideals. -/
 instance instIsLinearTopology : IsLinearTopology (WithIdealFilter F) (WithIdealFilter F) :=
   IsLinearTopology.mk_of_hasBasis' (R := (WithIdealFilter F))
diff --git a/mathlib4/Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean b/mathlib4/Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
index 19be15bd5..4d82e9594 100644
--- a/mathlib4/Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
@@ -320,7 +320,6 @@ lemma Polynomial.Monic.quotient_isIntegralElem {g : S[X]} (mon : g.Monic) {I : I
   nth_rw 3 [(as_sum_range_C_mul_X_pow g)]
   simp only [map_sum, algebraMap_eq, RingHom.coe_comp, Function.comp_apply, map_mul, map_pow]⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /- If `I` is an ideal of the polynomial ring `S[X]` and contains a monic polynomial `f`,
 then `S[X]/I` is integral over `S`. -/
 lemma Polynomial.Monic.quotient_isIntegral {g : S[X]} (mon : g.Monic) {I : Ideal S[X]} (h : g ∈ I) :
diff --git a/mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean b/mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean
index caa59a131..4ef8c7a7b 100644
--- a/mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean
+++ b/mathlib4/Mathlib/RingTheory/IsAdjoinRoot.lean
@@ -547,7 +547,6 @@ theorem coeff_one [Nontrivial S] : h.coeff 1 = Pi.single 0 1 := by
 theorem coeff_root (hdeg : 1 < natDegree f) : h.coeff h.root = Pi.single 1 1 := by
   rw [← h.coeff_root_pow hdeg, pow_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem coeff_algebraMap [Nontrivial S] (x : R) : h.coeff (algebraMap R S x) = Pi.single 0 x := by
   ext i
   rw [Algebra.algebraMap_eq_smul_one, map_smul, coeff_one, Pi.smul_apply, smul_eq_mul]
diff --git a/mathlib4/Mathlib/RingTheory/IsGaloisGroup/Defs.lean b/mathlib4/Mathlib/RingTheory/IsGaloisGroup/Defs.lean
index ade9e38d7..c0ae57e8a 100644
--- a/mathlib4/Mathlib/RingTheory/IsGaloisGroup/Defs.lean
+++ b/mathlib4/Mathlib/RingTheory/IsGaloisGroup/Defs.lean
@@ -79,7 +79,6 @@ theorem top_iff : IsGaloisGroup (⊤ : Subgroup G) A B ↔ IsGaloisGroup G A B :
 instance [IsGaloisGroup G A B] : IsGaloisGroup (⊤ : Subgroup G) A B :=
   IsGaloisGroup.top_iff.mpr ‹_›
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem of_algEquiv [hG : IsGaloisGroup G A B] (B' : Type*) [Semiring B']
     [Algebra A B'] [MulSemiringAction G B'] (e : B ≃ₐ[A] B')
     (he : ∀ (g : G) (x : B), e (g • x) = g • (e x)) :
diff --git a/mathlib4/Mathlib/RingTheory/IsPrimary.lean b/mathlib4/Mathlib/RingTheory/IsPrimary.lean
index 235bfbd05..c69a3f470 100644
--- a/mathlib4/Mathlib/RingTheory/IsPrimary.lean
+++ b/mathlib4/Mathlib/RingTheory/IsPrimary.lean
@@ -114,7 +114,6 @@ section CommRing
 
 variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] {S : Submodule R M}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma isPrimary_iff_zero_divisor_quotient_imp_nilpotent_smul :
     S.IsPrimary ↔ S ≠ ⊤ ∧ ∀ (r : R) (x : M ⧸ S), x ≠ 0 → r • x = 0 →
diff --git a/mathlib4/Mathlib/RingTheory/IsTensorProduct.lean b/mathlib4/Mathlib/RingTheory/IsTensorProduct.lean
index 54acb8728..108f9bb12 100644
--- a/mathlib4/Mathlib/RingTheory/IsTensorProduct.lean
+++ b/mathlib4/Mathlib/RingTheory/IsTensorProduct.lean
@@ -174,7 +174,6 @@ variable {R S : Type*} [CommSemiring R] [CommSemiring S] [Algebra R S]
   [Module R M₁₂] [Module S M₁₂] [IsScalarTower R S M₁₂]
   [Module R M₂₃] [Module S M₂₃] [IsScalarTower R S M₂₃]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 /-- (Implementation): Use the more linear `IsTensorProduct.assoc`. -/
@@ -421,7 +420,6 @@ theorem IsBaseChange.equiv_tmul (s : S) (m : M) : h.equiv (s ⊗ₜ m) = s • f
 theorem IsBaseChange.equiv_symm_apply (m : M) : h.equiv.symm (f m) = 1 ⊗ₜ m := by
   rw [h.equiv.symm_apply_eq, h.equiv_tmul, one_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma IsBaseChange.of_equiv (e : S ⊗[R] M ≃ₗ[S] N) (he : ∀ x, e (1 ⊗ₜ x) = f x) :
     IsBaseChange S f := by
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean b/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
index 9131df775..bb0f69e93 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/Basic.lean
@@ -556,7 +556,6 @@ theorem KaehlerDifferential.derivationQuotKerTotal_apply (x) :
     KaehlerDifferential.derivationQuotKerTotal R S x = 1𝖣x :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem KaehlerDifferential.derivationQuotKerTotal_lift_comp_linearCombination :
     (KaehlerDifferential.derivationQuotKerTotal R S).liftKaehlerDifferential.comp
         (Finsupp.linearCombination S (KaehlerDifferential.D R S)) =
@@ -751,7 +750,6 @@ This is the first map in the exact sequence `B ⊗[A] Ω[A⁄R] → Ω[B⁄R] 
 noncomputable def KaehlerDifferential.mapBaseChange : B ⊗[A] Ω[A⁄R] →ₗ[B] Ω[B⁄R] :=
   (TensorProduct.isBaseChange A Ω[A⁄R] B).lift (KaehlerDifferential.map R R A B)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem KaehlerDifferential.mapBaseChange_tmul (x : B) (y : Ω[A⁄R]) :
     KaehlerDifferential.mapBaseChange R A B (x ⊗ₜ y) = x • KaehlerDifferential.map R R A B y := by
@@ -804,7 +802,6 @@ def KaehlerDifferential.kerToTensor :
     algebraMap_eq_smul_one, RingHom.mem_ker.mp x.prop, TensorProduct.zero_tmul, add_zero,
     RingHom.id_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The map `I/I² → B ⊗[A] Ω[A⁄R]` where `I = ker(A → B)`. -/
 noncomputable
 def KaehlerDifferential.kerCotangentToTensor :
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean b/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
index 85f8a08c2..ee13f7d06 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/JacobiZariski.lean
@@ -76,7 +76,6 @@ attribute [local instance] SMulCommClass.of_commMonoid
 namespace Generators
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Cotangent.surjective_map_ofComp :
     Function.Surjective (Extension.Cotangent.map (Q.ofComp P).toExtensionHom) := by
   intro x
@@ -263,7 +262,6 @@ lemma δAux_C (r) :
     δAux R Q (C r) = 1 ⊗ₜ D R S r := by
   rw [← monomial_zero', δAux_monomial, Finsupp.prod_zero_index]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable {Q} {Q'} in
 lemma δAux_toAlgHom (f : Hom Q Q') (x) :
@@ -286,7 +284,6 @@ lemma δAux_toAlgHom (f : Hom Q Q') (x) :
     rw [add_left_comm]
     rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma δAux_ofComp (x : (Q.comp P).Ring) :
     δAux R Q ((Q.ofComp P).toAlgHom x) =
@@ -467,7 +464,6 @@ lemma exact_map_δ' (f : Hom W Q) :
   rw [← Extension.H1Cotangent.map_comp, Extension.H1Cotangent.map_eq _ (Q.ofComp P).toExtensionHom]
   exact exact_map_δ Q P
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 open LinearMap in
 lemma liftBaseChange_range_le :
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/Polynomial.lean b/mathlib4/Mathlib/RingTheory/Kaehler/Polynomial.lean
index 578b63447..0da83d7b5 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/Polynomial.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/Polynomial.lean
@@ -26,7 +26,6 @@ suppress_compilation
 
 section MvPolynomial
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The relative differential module of a polynomial algebra `R[σ]` is the free module generated by
 `{ dx | x ∈ σ }`. Also see `KaehlerDifferential.mvPolynomialBasis`. -/
 def KaehlerDifferential.mvPolynomialEquiv (σ : Type*) :
diff --git a/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean b/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
index 99d6d31df..9c88bcbb0 100644
--- a/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
+++ b/mathlib4/Mathlib/RingTheory/Kaehler/TensorProduct.lean
@@ -113,7 +113,6 @@ instance [Algebra.IsPushout R S A B] :
       (algebraMap S B r)) • x = r • x
   simp only [Algebra.pushoutDesc_left, Module.End.smul_def, Algebra.lsmul_coe]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma map_liftBaseChange_smul [h : Algebra.IsPushout R S A B] (b : B) (x) :
     ((map R S A B).restrictScalars R).liftBaseChange S (b • x) =
     b • ((map R S A B).restrictScalars R).liftBaseChange S x := by
@@ -127,7 +126,6 @@ lemma map_liftBaseChange_smul [h : Algebra.IsPushout R S A B] (b : B) (x) :
     · simp [smul_comm]
     · simp only [map_add, smul_add, *]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- (Implementation).
 The `S`-derivation `B = S ⊗[R] A` to `S ⊗[R] Ω[A⁄R]` sending `a ⊗ b` to `a ⊗ d b`. -/
 noncomputable
diff --git a/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean b/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
index d4f48cf6c..84dc38f0c 100644
--- a/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalProperties/Injective.lean
@@ -35,7 +35,6 @@ section
 
 universe u' v'
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open IsLocalizedModule in
 theorem Module.injective_of_isLocalizedModule [Small.{v} R] [IsNoetherianRing R] {Rₛ : Type u'}
     [Small.{v'} Rₛ] [CommRing Rₛ] [Algebra R Rₛ] {Mₛ : Type v'} [AddCommGroup Mₛ] [Module R Mₛ]
@@ -114,7 +113,6 @@ variable
 
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 include f in
 /--
diff --git a/mathlib4/Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean b/mathlib4/Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean
index 2e687f1c4..b3d1c3fed 100644
--- a/mathlib4/Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalProperties/IntegrallyClosed.lean
@@ -29,7 +29,6 @@ open Localization Ideal IsLocalization
 variable {R K : Type*} [CommRing R] [Field K] [Algebra R K] [IsFractionRing R K]
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem IsIntegrallyClosed.iInf {ι : Type*} (S : ι → Subalgebra R K)
     (h : ∀ i, IsIntegrallyClosed (S i)) :
     IsIntegrallyClosed (⨅ i, S i : Subalgebra R K) := by
diff --git a/mathlib4/Mathlib/RingTheory/LocalProperties/Projective.lean b/mathlib4/Mathlib/RingTheory/LocalProperties/Projective.lean
index cf4d7492d..d0077f827 100644
--- a/mathlib4/Mathlib/RingTheory/LocalProperties/Projective.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalProperties/Projective.lean
@@ -158,7 +158,6 @@ variable
   (f : ∀ (P : Ideal R) [P.IsMaximal], M →ₗ[R] Mₚ P)
   [inst : ∀ (P : Ideal R) [P.IsMaximal], IsLocalizedModule P.primeCompl (f P)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 set_option backward.isDefEq.respectTransparency false in
 attribute [local instance] RingHomInvPair.of_ringEquiv RingHomInvPair.of_ringEquiv_symm in
diff --git a/mathlib4/Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean b/mathlib4/Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean
index 1cd0d0725..93c620109 100644
--- a/mathlib4/Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean
+++ b/mathlib4/Mathlib/RingTheory/LocalRing/ResidueField/Fiber.lean
@@ -75,7 +75,6 @@ structure on `(p.Fiber S)_q` agrees with the one coming from the fact that `q` l
 instance (q : Ideal (p.Fiber S)) [q.IsPrime] : Localization.AtPrime.IsLiesOverAlgebra p q where
   algebraMap_eq := (Localization.localRingHom_unique p q _ (Ideal.over_def q p) fun _ ↦ rfl).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Fiber.exists_smul_eq_one_tmul (x : p.Fiber S) : ∃ r ∉ p, ∃ s, r • x = 1 ⊗ₜ[R] s := by
   obtain ⟨r, hr, s, e⟩ := Ideal.ResidueField.exists_smul_eq_tmul_one _
     (Algebra.TensorProduct.comm _ _ _ x)
diff --git a/mathlib4/Mathlib/RingTheory/Localization/Basic.lean b/mathlib4/Mathlib/RingTheory/Localization/Basic.lean
index 77af066bd..3ed65e423 100644
--- a/mathlib4/Mathlib/RingTheory/Localization/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Localization/Basic.lean
@@ -130,7 +130,6 @@ section CompatibleSMul
 
 variable (N₁ N₂ : Type*) [AddCommMonoid N₁] [AddCommMonoid N₂] [Module R N₁] [Module R N₂]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (M S) in
 include M in
diff --git a/mathlib4/Mathlib/RingTheory/Localization/Finiteness.lean b/mathlib4/Mathlib/RingTheory/Localization/Finiteness.lean
index e02fb4293..789e01c7c 100644
--- a/mathlib4/Mathlib/RingTheory/Localization/Finiteness.lean
+++ b/mathlib4/Mathlib/RingTheory/Localization/Finiteness.lean
@@ -45,7 +45,6 @@ variable {R S : Type*} [CommSemiring R] [CommSemiring S] (M : Submonoid R) (f :
 variable (R' S' : Type*) [CommSemiring R'] [CommSemiring S']
 variable [Algebra R R'] [Algebra S S']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 open scoped Classical in
 /-- Let `S` be an `R`-algebra, `M` a submonoid of `R`, and `S' = M⁻¹S`.
diff --git a/mathlib4/Mathlib/RingTheory/Localization/Module.lean b/mathlib4/Mathlib/RingTheory/Localization/Module.lean
index da8da87b7..a7ae587f6 100644
--- a/mathlib4/Mathlib/RingTheory/Localization/Module.lean
+++ b/mathlib4/Mathlib/RingTheory/Localization/Module.lean
@@ -53,7 +53,6 @@ theorem span_eq_top_of_isLocalizedModule {v : Set M} (hv : span R v = ⊤) :
   rw [← LinearMap.coe_restrictScalars R, ← LinearMap.map_span, hv]
   exact mem_map_of_mem mem_top
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem LinearIndependent.of_isLocalizedModule {ι : Type*} {v : ι → M}
     (hv : LinearIndependent R v) : LinearIndependent Rₛ (f ∘ v) := by
@@ -73,7 +72,6 @@ theorem LinearIndependent.of_isLocalizedModule {ι : Type*} {v : ι → M}
   simpa only [map_mul, (IsLocalization.map_units Rₛ s).mul_right_inj, hfg.1 ⟨i, hi⟩, hfg.2 ⟨i, hi⟩,
     Algebra.smul_def, (IsLocalization.map_units Rₛ a).mul_right_inj] using this
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem LinearIndependent.of_isLocalizedModule_of_isRegular {ι : Type*} {v : ι → M}
     (hv : LinearIndependent R v) (h : ∀ s : S, IsRegular (s : R)) : LinearIndependent R (f ∘ v) :=
@@ -91,7 +89,6 @@ theorem LinearIndependent.localization [Module Rₛ M] [IsScalarTower R Rₛ M]
   have := isLocalizedModule_id S M Rₛ
   exact hli.of_isLocalizedModule Rₛ S .id
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 include f in
 lemma IsLocalizedModule.linearIndependent_lift {ι} {v : ι → Mₛ} (hf : LinearIndependent R v) :
diff --git a/mathlib4/Mathlib/RingTheory/Morita/Matrix.lean b/mathlib4/Mathlib/RingTheory/Morita/Matrix.lean
index 86f4640f1..a02d76851 100644
--- a/mathlib4/Mathlib/RingTheory/Morita/Matrix.lean
+++ b/mathlib4/Mathlib/RingTheory/Morita/Matrix.lean
@@ -73,7 +73,6 @@ lemma mem_toModuleCatObj (i : ι) {x : M} :
     x ∈ toModuleCatObj R M i ↔ ∃ y : M, single i i (1 : R) • y = x :=
   Iff.rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable {R} in
 /-- An `R`-linear map between `Eᵢᵢ • M` and `Eᵢᵢ • N` induced by an `Mₙ(R)`-linear map
   from `M` to `N`. -/
diff --git a/mathlib4/Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean b/mathlib4/Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
index a52619d27..ff5f4d1f4 100644
--- a/mathlib4/Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
@@ -419,7 +419,6 @@ theorem weightedHomogeneousComponent_mem (w : σ → M) (φ : MvPolynomial σ R)
   rw [mem_weightedHomogeneousSubmodule]
   exact weightedHomogeneousComponent_isWeightedHomogeneous m φ
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem weightedHomogeneousComponent_C_mul (n : M) (r : R) :
     weightedHomogeneousComponent w n (C r * φ) = C r * weightedHomogeneousComponent w n φ := by
diff --git a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Basic.lean b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Basic.lean
index de9af14bf..48a29cd8a 100644
--- a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Basic.lean
@@ -975,13 +975,11 @@ theorem _root_.MvPowerSeries.prod_smul_X_eq_smul_monomial_one
   · intro x _
     rw [algebra_compatible_smul R, MvPowerSeries.smul_eq_C_mul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.MvPowerSeries.monomial_eq (e : σ →₀ ℕ) (r : σ → R) :
     MvPowerSeries.monomial e (e.prod (fun s n => r s ^ n))
       = e.prod fun s e => (r s • MvPowerSeries.X s) ^ e := by
   rw [MvPowerSeries.prod_smul_X_eq_smul_monomial_one, ← map_smul, smul_eq_mul, mul_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem _root_.MvPowerSeries.monomial_smul_const
     {σ : Type*} {R : Type*} [CommSemiring R]
     (e : σ →₀ ℕ) (r : R) :
diff --git a/mathlib4/Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean b/mathlib4/Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean
index 995f1d443..19af3d3b6 100644
--- a/mathlib4/Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPowerSeries/LinearTopology.lean
@@ -116,7 +116,6 @@ variable [TopologicalSpace R]
 open WithPiTopology
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- If the ring `R` is endowed with a linear topology, then the sets `↑basis σ R (J, d)`,
 for `J : TwoSidedIdeal R` which are neighborhoods of `0 : R` and `d : σ →₀ ℕ`,
 constitute a basis of neighborhoods of `0 : MvPowerSeries σ R` for the product topology. -/
diff --git a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Order.lean b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Order.lean
index f179005e6..5590d111e 100644
--- a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Order.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Order.lean
@@ -587,7 +587,6 @@ protected theorem IsWeightedHomogeneous.mul {f g : MvPowerSeries σ R} {p q : 
   apply hd
   rw [← hx, map_add, hp, hq]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The weighted homogeneous components of an `MvPowerSeries f`. -/
 def weightedHomogeneousComponent (p : ℕ) : MvPowerSeries σ R →ₗ[R] MvPowerSeries σ R where
diff --git a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Substitution.lean b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Substitution.lean
index 983defbe4..9fe7b2c38 100644
--- a/mathlib4/Mathlib/RingTheory/MvPowerSeries/Substitution.lean
+++ b/mathlib4/Mathlib/RingTheory/MvPowerSeries/Substitution.lean
@@ -710,7 +710,6 @@ theorem rescale_mul (a b : σ → R) : rescale (a * b) = (rescale b).comp (resca
   ext
   simp [← rescale_rescale]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- Rescaling a homogeneous power series -/
 lemma rescale_homogeneous_eq_smul {n : ℕ} {r : R} {f : MvPowerSeries σ R}
diff --git a/mathlib4/Mathlib/RingTheory/NoetherNormalization.lean b/mathlib4/Mathlib/RingTheory/NoetherNormalization.lean
index debaa32f8..60025b2f9 100644
--- a/mathlib4/Mathlib/RingTheory/NoetherNormalization.lean
+++ b/mathlib4/Mathlib/RingTheory/NoetherNormalization.lean
@@ -78,7 +78,6 @@ noncomputable abbrev T1 (c : k) :
     MvPolynomial (Fin (n + 1)) k →ₐ[k] MvPolynomial (Fin (n + 1)) k :=
   aeval fun i ↦ if i = 0 then X 0 else X i + c • X 0 ^ r i
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma t1_comp_t1_neg (c : k) : (T1 f c).comp (T1 f (-c)) = AlgHom.id _ _ := by
   rw [comp_aeval, ← MvPolynomial.aeval_X_left]
   ext i v
diff --git a/mathlib4/Mathlib/RingTheory/NormTrace.lean b/mathlib4/Mathlib/RingTheory/NormTrace.lean
index 9af29acbc..5d36a5568 100644
--- a/mathlib4/Mathlib/RingTheory/NormTrace.lean
+++ b/mathlib4/Mathlib/RingTheory/NormTrace.lean
@@ -16,7 +16,6 @@ public section
 
 open Module
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Algebra.norm_one_add_smul {A B} [CommRing A] [CommRing B] [Algebra A B]
     [Module.Free A B] [Module.Finite A B] (a : A) (x : B) :
     ∃ r : A, Algebra.norm A (1 + a • x) = 1 + Algebra.trace A B x * a + r * a ^ 2 := by
diff --git a/mathlib4/Mathlib/RingTheory/PiTensorProduct.lean b/mathlib4/Mathlib/RingTheory/PiTensorProduct.lean
index d044bcccb..298b7534a 100644
--- a/mathlib4/Mathlib/RingTheory/PiTensorProduct.lean
+++ b/mathlib4/Mathlib/RingTheory/PiTensorProduct.lean
@@ -76,7 +76,6 @@ nonrec theorem _root_.Commute.tprod {a₁ a₂ : Π i, A i} (ha : Commute a₁ a
     Commute (tprod R a₁) (tprod R a₂) :=
   ha.tprod
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma smul_tprod_mul_smul_tprod (r s : R) (x y : Π i, A i) :
     (r • tprod R x) * (s • tprod R y) = (r * s) • tprod R (x * y) := by
diff --git a/mathlib4/Mathlib/RingTheory/PicardGroup.lean b/mathlib4/Mathlib/RingTheory/PicardGroup.lean
index 6790ec9a5..3c5c3e090 100644
--- a/mathlib4/Mathlib/RingTheory/PicardGroup.lean
+++ b/mathlib4/Mathlib/RingTheory/PicardGroup.lean
@@ -263,7 +263,6 @@ theorem toModuleEnd_bijective : Function.Bijective (toModuleEnd R (S := R) M) :=
 instance : FaithfulSMul R M where
   eq_of_smul_eq_smul {_ _} h := (toModuleEnd_bijective R M).injective <| LinearMap.ext h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable {R M N} in
 private theorem bijective_self_of_surjective (f : R →ₗ[R] M) (hf : Function.Surjective f) :
     Function.Bijective f where
@@ -797,7 +796,6 @@ instance : Flat R (submoduleAlgebra e) := .of_linearEquiv (submoduleAlgebraEquiv
 instance [Module.Invertible R M] : Module.Invertible R (submoduleAlgebra e) :=
   .congr (submoduleAlgebraEquiv e).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.defeqAttrib.useBackward true in
 /-- When a flat `R`-module `M` is embedded as a submodule of a faithful `R`-algebra `A`,
 the multiplication map induces an isomorphism `A ⊗[R] M ≃ₗ[A] A`. -/
@@ -917,7 +915,6 @@ See https://mathoverflow.net/a/499611. -/
 example [IsNoetherianRing R] : ∃ I : Ideal R, Nonempty (M ≃ₗ[R] I) :=
   Module.Invertible.exists_linearEquiv_ideal R M
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable {R} in
 /-- In a total ring of fractions, if two ideals are inverse to each other in the Picard group,
 the only possibility is that they are both the whole ring. -/
diff --git a/mathlib4/Mathlib/RingTheory/Polynomial/DegreeLT.lean b/mathlib4/Mathlib/RingTheory/Polynomial/DegreeLT.lean
index 6bb866dc0..c0d28c96f 100644
--- a/mathlib4/Mathlib/RingTheory/Polynomial/DegreeLT.lean
+++ b/mathlib4/Mathlib/RingTheory/Polynomial/DegreeLT.lean
@@ -104,13 +104,11 @@ lemma addLinearEquiv_symm_apply_inr_basis (j : Fin n) :
       basis R (m + n) (j.natAdd m) :=
   (LinearEquiv.symm_apply_eq _).2 (addLinearEquiv_natAdd j).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma addLinearEquiv_symm_apply_inl (P : R[X]_m) :
     ((addLinearEquiv R m n).symm (LinearMap.inl R _ _ P) : R[X]) = (P : R[X]) := by
   rw [← (basis ..).sum_repr P]
   simp [-LinearMap.coe_inl, addLinearEquiv_symm_apply_inl_basis]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma addLinearEquiv_symm_apply_inr (Q : R[X]_n) :
     ((addLinearEquiv R m n).symm (LinearMap.inr R _ _ Q) : R[X]) = (Q : R[X]) * X ^ (m : ℕ) := by
   rw [← (basis ..).sum_repr Q]
diff --git a/mathlib4/Mathlib/RingTheory/Polynomial/Resultant/Basic.lean b/mathlib4/Mathlib/RingTheory/Polynomial/Resultant/Basic.lean
index 7c85d8902..a49308f17 100644
--- a/mathlib4/Mathlib/RingTheory/Polynomial/Resultant/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Polynomial/Resultant/Basic.lean
@@ -855,7 +855,6 @@ def adjSylvester (f g : R[X]) :
   (f.sylvester g m n).adjugate.toLin (degreeLT.basis R (m + n))
     (((degreeLT.basis R m).prod (degreeLT.basis R n)).reindex finSumFinEquiv)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma sylveserMap_comp_adjSylvester (f g : R[X]) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n) :
     sylvesterMap f g hf hg ∘ₗ adjSylvester f g = f.resultant g m n • LinearMap.id := by
   let b₁ := ((degreeLT.basis R m).prod (degreeLT.basis R n)).reindex finSumFinEquiv
@@ -864,7 +863,6 @@ lemma sylveserMap_comp_adjSylvester (f g : R[X]) (hf : f.natDegree ≤ m) (hg :
   rwa [Matrix.toLin_mul b₂ b₁ b₂, Matrix.toLin_toMatrix, map_smul,
     toMatrix_sylvesterMap', Matrix.toLin_one, ← resultant] at this
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma adjSylvester_comp_sylveserMap (f g : R[X]) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n) :
     adjSylvester f g ∘ₗ sylvesterMap f g hf hg = f.resultant g m n • LinearMap.id := by
   let b₁ := ((degreeLT.basis R m).prod (degreeLT.basis R n)).reindex finSumFinEquiv
diff --git a/mathlib4/Mathlib/RingTheory/Polynomial/UniversalFactorizationRing.lean b/mathlib4/Mathlib/RingTheory/Polynomial/UniversalFactorizationRing.lean
index 97b92d453..87cbda33d 100644
--- a/mathlib4/Mathlib/RingTheory/Polynomial/UniversalFactorizationRing.lean
+++ b/mathlib4/Mathlib/RingTheory/Polynomial/UniversalFactorizationRing.lean
@@ -334,7 +334,6 @@ lemma finitePresentation_universalFactorizationMap :
   letI := (universalFactorizationMap R n m k hn).toAlgebra
   (universalFactorizationMapPresentation R n m k hn).finitePresentation_of_isFinite
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 lemma finite_universalFactorizationMap :
     (universalFactorizationMap R n m k hn).Finite := by
diff --git a/mathlib4/Mathlib/RingTheory/PolynomialLaw/Basic.lean b/mathlib4/Mathlib/RingTheory/PolynomialLaw/Basic.lean
index 7771a0fdc..d6a797419 100644
--- a/mathlib4/Mathlib/RingTheory/PolynomialLaw/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/PolynomialLaw/Basic.lean
@@ -243,7 +243,6 @@ theorem one_tmul_ground_apply' {S : Type u} [CommSemiring S] [Algebra R S] (x :
   · simp only [includeRight_lid]
   · rw [rTensor_tmul, toLinearMap_apply, map_one]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The map ground assigning a function `M → N` to a polynomial map `f : M →ₚₗ[R] N` as a
   linear map. -/
 def lground : (M →ₚₗ[R] N) →ₗ[R] (M → N) where
@@ -556,7 +555,6 @@ theorem toFun_add :
   ext t
   simp only [Pi.add_apply, toFun_add_apply]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 theorem toFun_neg {R : Type u} [CommRing R]
     {M : Type*} [AddCommGroup M] [Module R M]
@@ -568,7 +566,6 @@ theorem toFun_neg {R : Type u} [CommRing R]
   obtain ⟨⟨s, p⟩, ha⟩ := π_surjective t
   simp only [toFun_eq_rTensor_φ_toFun' _ ha, neg_def, Pi.smul_apply, map_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (S) in
 /-- Extension of `PolynomialLaw.smul_def` -/
 @[simp]
diff --git a/mathlib4/Mathlib/RingTheory/PowerBasis.lean b/mathlib4/Mathlib/RingTheory/PowerBasis.lean
index 4caafa73a..8dff9019a 100644
--- a/mathlib4/Mathlib/RingTheory/PowerBasis.lean
+++ b/mathlib4/Mathlib/RingTheory/PowerBasis.lean
@@ -247,7 +247,6 @@ section Equiv
 
 variable [Algebra A S] {S' : Type*} [Ring S'] [Algebra A S']
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem constr_pow_aeval (pb : PowerBasis A S) {y : S'} (hy : aeval y (minpoly A pb.gen) = 0)
     (f : A[X]) : pb.basis.constr A (fun i => y ^ (i : ℕ)) (aeval pb.gen f) = aeval y f := by
   cases subsingleton_or_nontrivial A
diff --git a/mathlib4/Mathlib/RingTheory/QuasiFinite/Weakly.lean b/mathlib4/Mathlib/RingTheory/QuasiFinite/Weakly.lean
index 6e0de5feb..32073e6d2 100644
--- a/mathlib4/Mathlib/RingTheory/QuasiFinite/Weakly.lean
+++ b/mathlib4/Mathlib/RingTheory/QuasiFinite/Weakly.lean
@@ -225,7 +225,6 @@ lemma of_restrictScalars [Algebra S T] [IsScalarTower R S T]
   refine .trans ?_ (Ideal.comap_map_of_surjective _ Ideal.Quotient.mk_surjective _).symm
   simp [← RingHom.ker_eq_comap_bot, Ideal.map_comap_le]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Use `Algebra.QuasiFinite.of_quasiFiniteAt_residueField` instead
 for `Algebra.QuasiFiniteAt R q`. -/
 lemma of_quasiFiniteAt_residueField [p.IsPrime] [q.LiesOver p]
diff --git a/mathlib4/Mathlib/RingTheory/Regular/Free.lean b/mathlib4/Mathlib/RingTheory/Regular/Free.lean
index ae0dade9f..8c268f5df 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/Free.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/Free.lean
@@ -29,7 +29,6 @@ instance [Module.Free R M] (x : R) : Module.Free (R ⧸ Ideal.span {x}) (QuotSMu
   Module.Free.of_equiv ((QuotSMulTop.equivQuotTensor x M).extendScalarsOfSurjective
     Ideal.Quotient.mk_surjective).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 open Pointwise in
 lemma Module.free_quotSMulTop_iff_free [Module.FinitePresentation R M] {x : R}
     (mem : x ∈ (⊥ : Ideal R).jacobson) (reg : IsSMulRegular M x) :
diff --git a/mathlib4/Mathlib/RingTheory/Regular/IsSMulRegular.lean b/mathlib4/Mathlib/RingTheory/Regular/IsSMulRegular.lean
index b96ee4fb5..89b9259c3 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/IsSMulRegular.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/IsSMulRegular.lean
@@ -45,7 +45,6 @@ end Congr
 
 variable {R S M M' M'' : Type*}
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma IsSMulRegular.submodule [Semiring R] [AddCommMonoid M] [Module R M]
     (N : Submodule R M) (r : R) (h : IsSMulRegular M r) : IsSMulRegular N r :=
   h.of_injective N.subtype N.injective_subtype
@@ -81,7 +80,6 @@ lemma isSMulRegular_submodule_iff_right_eq_zero_of_smul :
     Subtype.forall.trans <| by
       simp only [SetLike.mk_smul_mk, Submodule.mk_eq_zero]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma isSMulRegular_quotient_iff_mem_of_smul_mem :
     IsSMulRegular (M ⧸ N) r ↔ ∀ x : M, r • x ∈ N → x ∈ N :=
   isSMulRegular_iff_right_eq_zero_of_smul.trans <|
@@ -170,7 +168,6 @@ lemma smul_top_inf_eq_smul_of_isSMulRegular_on_quot :
   exact Eq.trans (congrArg (· ⊓ N) (map_top _)) (map_comap_eq _ _).symm
 
 -- Who knew this didn't rely on exactness at the right!?
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 open Function in
 lemma QuotSMulTop.map_first_exact_on_four_term_exact_of_isSMulRegular_last
diff --git a/mathlib4/Mathlib/RingTheory/Regular/LinearMap.lean b/mathlib4/Mathlib/RingTheory/Regular/LinearMap.lean
index 321374bb1..9835b4202 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/LinearMap.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/LinearMap.lean
@@ -36,7 +36,6 @@ namespace IsSMulRegular
 
 variable {R M N : Type*} [CommRing R] [AddCommGroup M] [AddCommGroup N] [Module R M] [Module R N]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma linearMap_subsingleton_of_mem_annihilator {r : R} (reg : IsSMulRegular M r)
     (mem_ann : r ∈ Module.annihilator R N) : Subsingleton (N →ₗ[R] M) := by
   apply subsingleton_of_forall_eq 0 (fun f ↦ ext fun x ↦ ?_)
diff --git a/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean b/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
index 3da23274d..61f3150db 100644
--- a/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
+++ b/mathlib4/Mathlib/RingTheory/Regular/RegularSequence.lean
@@ -602,7 +602,6 @@ LinearMap.mk₂'ₛₗ
 Then both backward compatibility options can go.
 -/
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.instanceTypes false in
 open _root_.LinearMap in
 private lemma IsWeaklyRegular.swap {a b : R} (h1 : IsWeaklyRegular M [a, b])
diff --git a/mathlib4/Mathlib/RingTheory/SimpleModule/Basic.lean b/mathlib4/Mathlib/RingTheory/SimpleModule/Basic.lean
index 6e4e7e9b4..99af6ae41 100644
--- a/mathlib4/Mathlib/RingTheory/SimpleModule/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/SimpleModule/Basic.lean
@@ -565,7 +565,6 @@ open Submodule
 variable [IsSemisimpleModule R M]
 
 -- Statement and proof follow [Lorenz2008], Chapter 28, F20.
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem jacobson_density (f : End (End R M) M) (s : Finset M) :
     ∃ r : R, ∀ m ∈ s, f m = r • m :=
   let x := Finsupp.equivFunOnFinite.symm (·.1 : s → M)
@@ -577,7 +576,6 @@ theorem jacobson_density (f : End (End R M) M) (s : Finset M) :
   have ⟨r, hr⟩ := mem_span_singleton.mp this
   ⟨r, fun m hm ↦ by simpa [x] using! congr($hr ⟨m, hm⟩).symm⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The Jacobson density theorem for a module finite over its endomorphism ring. -/
 protected theorem Module.Finite.toModuleEnd_moduleEnd_surjective [Module.Finite (End R M) M] :
diff --git a/mathlib4/Mathlib/RingTheory/Smooth/Basic.lean b/mathlib4/Mathlib/RingTheory/Smooth/Basic.lean
index 122bd4fb8..696c5eb87 100644
--- a/mathlib4/Mathlib/RingTheory/Smooth/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Smooth/Basic.lean
@@ -455,7 +455,6 @@ variable {R : Type*} [CommRing R]
 variable {A : Type*} [CommRing A] [Algebra R A]
 variable (B : Type*) [CommRing B] [Algebra R B]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 instance [FormallySmooth R A] : FormallySmooth B (B ⊗[R] A) := by
   refine .of_comp_surjective fun C _ _ I hI f ↦ ?_
diff --git a/mathlib4/Mathlib/RingTheory/Smooth/Kaehler.lean b/mathlib4/Mathlib/RingTheory/Smooth/Kaehler.lean
index a0dd1ef5c..57ca05e5b 100644
--- a/mathlib4/Mathlib/RingTheory/Smooth/Kaehler.lean
+++ b/mathlib4/Mathlib/RingTheory/Smooth/Kaehler.lean
@@ -151,7 +151,6 @@ variable [Algebra R S] [IsScalarTower R P S]
 variable (hf' : (RingHom.ker (algebraMap P S)) ^ 2 = ⊥)
 include hf'
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 Given a surjective algebra homomorphism `f : P →ₐ[R] S` with square-zero kernel `I`.
 Let `σ` be an arbitrary (set-theoretic) section of `f`.
diff --git a/mathlib4/Mathlib/RingTheory/Smooth/Quotient.lean b/mathlib4/Mathlib/RingTheory/Smooth/Quotient.lean
index 70d8992f8..ab8e81d72 100644
--- a/mathlib4/Mathlib/RingTheory/Smooth/Quotient.lean
+++ b/mathlib4/Mathlib/RingTheory/Smooth/Quotient.lean
@@ -72,7 +72,6 @@ private lemma comap_ker_eq_sup_of_ker_eq_map (surjRS : Function.Surjective (alge
       ← RingHom.comap_ker]
   simp [eqmap, Ideal.comap_map_of_surjective' _ surjRS]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 private lemma mul_le_ker_of_range_le_mul_of_sq_zero {J I : Ideal R} (sq : I ^ 2 = ⊥)
     (f : J.Cotangent →ₗ[R] J.Cotangent)
     (le : f.range ≤ (Submodule.comap J.subtype (I * J)).map J.toCotangent) :
@@ -95,7 +94,6 @@ private lemma mul_le_ker_of_range_le_mul_of_sq_zero {J I : Ideal R} (sq : I ^ 2
   rcases Submodule.mem_map.mp hx with ⟨x', hx', eq⟩
   simpa [← eq] using this hx'
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 /-- For flat ring homomorphism `f : R →+* S`, `I` an ideal of `R` which is square zero,
 if `R ⧸ I →+* S ⧸ IS` is formally smooth, so is `f`. -/
diff --git a/mathlib4/Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean b/mathlib4/Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean
index 2ca1c9afc..1e13f8b83 100644
--- a/mathlib4/Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean
+++ b/mathlib4/Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean
@@ -260,7 +260,6 @@ instance : Module.Free S (Generators.localizationAway S r).toExtension.Cotangent
     Module.Free S ((SubmersivePresentation.localizationAway S r).toExtension.Cotangent)
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable (S) in
 /-- The image of `g * X - 1` in `I/I²` if `I` is the kernel of the canonical presentation
 of the localization of `S` away from `g`. -/
@@ -269,7 +268,6 @@ abbrev Generators.cMulXSubOneCotangent : (Generators.localizationAway S r).toExt
   Extension.Cotangent.mk ⟨C r * X () - 1, C_mul_X_sub_one_mem_ker _⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Generators.cMulXSubOneCotangent_eq :
     cMulXSubOneCotangent S r = Extension.Cotangent.mk ⟨C r * X () - 1, C_mul_X_sub_one_mem_ker _⟩ :=
   rfl
diff --git a/mathlib4/Mathlib/RingTheory/Spectrum/Prime/FreeLocus.lean b/mathlib4/Mathlib/RingTheory/Spectrum/Prime/FreeLocus.lean
index b1b24ba77..01c58fd0d 100644
--- a/mathlib4/Mathlib/RingTheory/Spectrum/Prime/FreeLocus.lean
+++ b/mathlib4/Mathlib/RingTheory/Spectrum/Prime/FreeLocus.lean
@@ -56,7 +56,6 @@ lemma mem_freeLocus {p} : p ∈ freeLocus R M ↔
   Iff.rfl
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 attribute [local instance] RingHomInvPair.of_ringEquiv in
 lemma mem_freeLocus_of_isLocalization (p : PrimeSpectrum R)
     (Rₚ Mₚ) [CommRing Rₚ] [Algebra R Rₚ] [IsLocalization.AtPrime Rₚ p.asIdeal]
diff --git a/mathlib4/Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean b/mathlib4/Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean
index 8a6719995..ab76a77a3 100644
--- a/mathlib4/Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean
+++ b/mathlib4/Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean
@@ -71,7 +71,6 @@ lemma isNilpotent_tensor_residueField_iff
 namespace PrimeSpectrum
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `A` be an `R`-algebra.
 `𝔭 : Spec R` is in the image of `Z(I) ∩ D(f) ⊆ Spec S`
 if and only if `f` is not nilpotent on `κ(𝔭) ⊗ A ⧸ I`. -/
diff --git a/mathlib4/Mathlib/RingTheory/Support.lean b/mathlib4/Mathlib/RingTheory/Support.lean
index 928b73bd0..4a8562f9b 100644
--- a/mathlib4/Mathlib/RingTheory/Support.lean
+++ b/mathlib4/Mathlib/RingTheory/Support.lean
@@ -168,7 +168,6 @@ lemma Module.support_subset_of_surjective (hf : Function.Surjective f) :
   obtain ⟨m, rfl⟩ := hf m
   exact ⟨m, fun r hr e ↦ hm r hr (by simpa using congr(f $e))⟩
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable {f g} in
 /-- Given an exact sequence `0 → M → N → P → 0` of `R`-modules, `Supp N = Supp M ∪ Supp P`. -/
 @[stacks 00L3 "(4)"]
diff --git a/mathlib4/Mathlib/RingTheory/TensorProduct/IsBaseChangeFree.lean b/mathlib4/Mathlib/RingTheory/TensorProduct/IsBaseChangeFree.lean
index 28b33d892..6d345c2ab 100644
--- a/mathlib4/Mathlib/RingTheory/TensorProduct/IsBaseChangeFree.lean
+++ b/mathlib4/Mathlib/RingTheory/TensorProduct/IsBaseChangeFree.lean
@@ -44,7 +44,6 @@ theorem basis_apply (i) : ibc.basis b i = ε (b i) := by
     simp [LinearEquiv.symm_apply_eq, IsBaseChange.equiv_tmul]
   simp [this, IsBaseChange.equiv_tmul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem basis_repr_comp_apply (v i) :
     (ibc.basis b).repr (ε v) i = algebraMap R S (b.repr v i) := by
diff --git a/mathlib4/Mathlib/RingTheory/Trace/Basic.lean b/mathlib4/Mathlib/RingTheory/Trace/Basic.lean
index 4cbc47aea..f0706b9cc 100644
--- a/mathlib4/Mathlib/RingTheory/Trace/Basic.lean
+++ b/mathlib4/Mathlib/RingTheory/Trace/Basic.lean
@@ -382,7 +382,6 @@ theorem traceMatrix_of_basis [Fintype κ] [DecidableEq κ] (b : Basis κ A B) :
   ext (i j)
   rw [traceMatrix_apply, traceForm_apply, traceForm_toMatrix]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem traceMatrix_of_basis_mulVec [Fintype ι] (b : Basis ι A B) (z : B) :
     traceMatrix A b *ᵥ b.equivFun z = fun i => trace A B (z * b i) := by
   ext i
diff --git a/mathlib4/Mathlib/RingTheory/Unramified/Field.lean b/mathlib4/Mathlib/RingTheory/Unramified/Field.lean
index 0f30f7dcf..f7256c8fe 100644
--- a/mathlib4/Mathlib/RingTheory/Unramified/Field.lean
+++ b/mathlib4/Mathlib/RingTheory/Unramified/Field.lean
@@ -58,7 +58,6 @@ theorem of_isSeparable [Algebra.IsSeparable K L] : FormallyUnramified K L := by
 variable [FormallyUnramified K A] [EssFiniteType K A]
 variable [FormallyUnramified K L] [EssFiniteType K L]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem bijective_of_isAlgClosed_of_isLocalRing
     [IsAlgClosed K] [IsLocalRing A] :
     Function.Bijective (algebraMap K A) := by
diff --git a/mathlib4/Mathlib/RingTheory/Unramified/Finite.lean b/mathlib4/Mathlib/RingTheory/Unramified/Finite.lean
index 68b7a66ad..28ef842ef 100644
--- a/mathlib4/Mathlib/RingTheory/Unramified/Finite.lean
+++ b/mathlib4/Mathlib/RingTheory/Unramified/Finite.lean
@@ -83,7 +83,6 @@ theorem iff_exists_tensorProduct [EssFiniteType R S] :
       use 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1
       linear_combination ht₁ s
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma finite_of_free_aux (I) [DecidableEq I] (b : Basis I R S)
     (f : I →₀ S) (x : S) (a : I → I →₀ R) (ha : a = fun i ↦ b.repr (b i * x)) :
     (1 ⊗ₜ[R] x * Finsupp.sum f fun i y ↦ y ⊗ₜ[R] b i) =
diff --git a/mathlib4/Mathlib/RingTheory/Valuation/LocalSubring.lean b/mathlib4/Mathlib/RingTheory/Valuation/LocalSubring.lean
index 83a0b033b..36f6345db 100644
--- a/mathlib4/Mathlib/RingTheory/Valuation/LocalSubring.lean
+++ b/mathlib4/Mathlib/RingTheory/Valuation/LocalSubring.lean
@@ -144,7 +144,6 @@ lemma LocalSubring.exists_le_valuationSubring (A : LocalSubring K) :
     exact isUnit_iff_exists_inv.mpr ⟨⟨b, hCB.1 hbB⟩, Subtype.ext congr(($e).1)⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma Ideal.image_subset_nonunits_valuationSubring {A : Subring K} (I : Ideal A) (hI : I ≠ ⊤) :
     ∃ B : ValuationSubring K, A ≤ B.toSubring ∧ A.subtype '' I ⊆ B.nonunits := by
   have ⟨M, hM, le⟩ := I.exists_le_maximal hI
diff --git a/mathlib4/Mathlib/RingTheory/Valuation/RankOne.lean b/mathlib4/Mathlib/RingTheory/Valuation/RankOne.lean
index 7a0a6a7cf..324cb1f1d 100644
--- a/mathlib4/Mathlib/RingTheory/Valuation/RankOne.lean
+++ b/mathlib4/Mathlib/RingTheory/Valuation/RankOne.lean
@@ -140,7 +140,6 @@ instance restrict_RankOne : RankOne (v.restrict) where
   strictMono' := (strictMono v).comp embedding_strictMono
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma restrict_RankOne_hom_eq :
   RankOne.hom v.restrict = (RankOne.hom v).comp embedding := rfl
@@ -148,7 +147,6 @@ lemma restrict_RankOne_hom_eq :
 set_option backward.isDefEq.respectTransparency.types false in
 set_option backward.defeqAttrib.useBackward true in
 variable {K} in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem exists_val_lt {γ : ℝ≥0} (hγ : γ ≠ 0) : ∃ x ≠ 0, RankOne.hom v (v.restrict x) < γ := by
   have hγ_pos : 0 < γ := pos_iff_ne_zero.mpr hγ
   obtain ⟨x, h⟩ := NNReal.exists_lt_of_strictMono (RankOne.strictMono v.restrict) hγ_pos
diff --git a/mathlib4/Mathlib/RingTheory/WittVector/Isocrystal.lean b/mathlib4/Mathlib/RingTheory/WittVector/Isocrystal.lean
index 899958784..3d56a10e8 100644
--- a/mathlib4/Mathlib/RingTheory/WittVector/Isocrystal.lean
+++ b/mathlib4/Mathlib/RingTheory/WittVector/Isocrystal.lean
@@ -168,7 +168,6 @@ section PerfectRing
 variable [IsDomain k] [CharP k p] [PerfectRing k p]
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The standard one-dimensional isocrystal of slope `m : ℤ` is an isocrystal. -/
 instance (m : ℤ) : Isocrystal p k (StandardOneDimIsocrystal p k m) where
   frob :=
diff --git a/mathlib4/Mathlib/Topology/Algebra/Algebra.lean b/mathlib4/Mathlib/Topology/Algebra/Algebra.lean
index ae779e6b9..7b4f51e59 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Algebra.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Algebra.lean
@@ -217,7 +217,6 @@ protected theorem map_zero (f : A →A[R] B) : f (0 : A) = 0 := map_zero f
 
 protected theorem map_add (f : A →A[R] B) (x y : A) : f (x + y) = f x + f y := map_add f x y
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 protected theorem map_smul (f : A →A[R] B) (c : R) (x : A) :
     f (c • x) = c • f x :=
   map_smul ..
diff --git a/mathlib4/Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean b/mathlib4/Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
index 0835b3d9a..ac6e6ed44 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
@@ -95,7 +95,6 @@ def toLimit (P : ProfiniteGrp.{u}) : P ⟶ limit (diagram P) :=
 
 -- Defeq abuse, see `change` below.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An auxiliary result, superseded by `toLimit_surjective` -/
 theorem denseRange_toLimit (P : ProfiniteGrp.{u}) : DenseRange (toLimit P) := by
   apply dense_iff_inter_open.mpr
@@ -156,7 +155,6 @@ noncomputable def isoLimittoFiniteQuotientFunctor (P : ProfiniteGrp.{u}) :
   ContinuousMulEquiv.toProfiniteGrpIso (continuousMulEquivLimittoFiniteQuotientFunctor P)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The projection from `P` to the quotient by an open normal subgroup. -/
 @[to_additive /-- The projection from `P` to the quotient by an open normal subgroup. -/]
 def proj {P : ProfiniteGrp.{u}} (U : OpenNormalSubgroup P) : P ⟶ (diagram P).obj U :=
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/ContinuousLinearMap/Basic.lean b/mathlib4/Mathlib/Topology/Algebra/Module/ContinuousLinearMap/Basic.lean
index 28ce81e1a..2f0b3d8ff 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/ContinuousLinearMap/Basic.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/ContinuousLinearMap/Basic.lean
@@ -658,7 +658,6 @@ instance applyFaithfulSMul : FaithfulSMul (M₁ →L[R₁] M₁) M₁ :=
 instance applySMulCommClass : SMulCommClass R₁ (M₁ →L[R₁] M₁) M₁ where
   smul_comm r e m := (e.map_smul r m).symm
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance applySMulCommClass' : SMulCommClass (M₁ →L[R₁] M₁) R₁ M₁ where
   smul_comm := map_smul
 
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimension.lean b/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimension.lean
index bbd9e7973..384955324 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimension.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimension.lean
@@ -148,7 +148,6 @@ theorem unique_topology_of_t2 {t : TopologicalSpace 𝕜} (h₁ : @IsTopological
           tendsto_id (1 : 𝕜))
       _ = @nhds 𝕜 t 0 := by rw [zero_smul]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Any linear form on a topological vector space over a nontrivially normed field is continuous if
 its kernel is closed. -/
 theorem LinearMap.continuous_of_isClosed_ker (l : E →ₗ[𝕜] 𝕜)
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimensionBilinear.lean b/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimensionBilinear.lean
index 828898571..c93784a24 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimensionBilinear.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/FiniteDimensionBilinear.lean
@@ -33,7 +33,6 @@ variable
     {G : Type*} [AddCommGroup G] [Module 𝕜 G] [TopologicalSpace G]
     [IsTopologicalAddGroup G] [ContinuousSMul 𝕜 G]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Building continuous bilinear maps from bilinear maps between finite dimensional topological
   vector spaces over a complete field. -/
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/IsWeak.lean b/mathlib4/Mathlib/Topology/Algebra/Module/IsWeak.lean
index 2b6a245bd..a3bd4fe91 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/IsWeak.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/IsWeak.lean
@@ -152,7 +152,6 @@ theorem continuousAdd [ContinuousAdd 𝕜] : ContinuousAdd E where
     simp only [Function.comp_def, map_add, add_apply]
     fun_prop
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 include hB in
 /-- Scalar multiplication in `E` is continuous when `E` is equipped with a `LinearMap.IsWeak`
 topology. -/
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/Spaces/CharacterSpace.lean b/mathlib4/Mathlib/Topology/Algebra/Module/Spaces/CharacterSpace.lean
index 432a1041e..50bcaaf52 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/Spaces/CharacterSpace.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/Spaces/CharacterSpace.lean
@@ -84,7 +84,6 @@ def toCLM (φ : characterSpace 𝕜 A) : A →L[𝕜] 𝕜 :=
 theorem coe_toCLM (φ : characterSpace 𝕜 A) : ⇑(toCLM φ) = φ :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Elements of the character space are non-unital algebra homomorphisms. -/
 instance instNonUnitalAlgHomClass : NonUnitalAlgHomClass (characterSpace 𝕜 A) 𝕜 A 𝕜 :=
   { CharacterSpace.instContinuousLinearMapClass with
@@ -92,7 +91,6 @@ instance instNonUnitalAlgHomClass : NonUnitalAlgHomClass (characterSpace 𝕜 A)
     map_zero := fun φ => map_zero φ
     map_mul := fun φ => φ.prop.2 }
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- An element of the character space, as a non-unital algebra homomorphism. -/
 noncomputable def toNonUnitalAlgHom (φ : characterSpace 𝕜 A) : A →ₙₐ[𝕜] 𝕜 where
   toFun := (φ : A → 𝕜)
@@ -137,7 +135,6 @@ section Unital
 variable [CommRing 𝕜] [NoZeroDivisors 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜]
   [ContinuousConstSMul 𝕜 𝕜] [TopologicalSpace A] [Semiring A] [Algebra 𝕜 A]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- In a unital algebra, elements of the character space are algebra homomorphisms. -/
 instance instAlgHomClass : AlgHomClass (characterSpace 𝕜 A) 𝕜 A 𝕜 :=
   haveI map_one' : ∀ φ : characterSpace 𝕜 A, φ 1 = 1 := fun φ => by
diff --git a/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean b/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
index fbf347944..41e74f81e 100644
--- a/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/Module/UniformConvergence.lean
@@ -52,7 +52,6 @@ variable (𝕜 α E H : Type*) {hom : Type*} [NormedField 𝕜] [AddCommGroup H]
   [ContinuousSMul 𝕜 E] {𝔖 : Set <| Set α}
   [FunLike hom H (α → E)] [LinearMapClass hom 𝕜 H (α → E)]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- Let `E` be a topological vector space over a normed field `𝕜`, let `α` be any type.
 Let `H` be a submodule of `α →ᵤ E` such that the range of each `f ∈ H` is von Neumann bounded.
@@ -88,7 +87,6 @@ lemma UniformFun.continuousSMul_induced_of_range_bounded (φ : hom)
     simp only [Set.mem_ofPred_eq, map_smul, Pi.smul_apply]
     simpa only [Set.mapsTo_range_iff] using (h u hU).eventually_nhds_zero (mem_of_mem_nhds hU)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
 `S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
 equipped with the topology of `𝔖`-convergence, is a TVS.
@@ -116,7 +114,6 @@ variable (H : Submodule 𝕜 (α →ᵤ[𝔖] E))
 
 -- Abuses defeq `α →ᵤ[𝔖] E = α → E`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
 `S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
 equipped with the topology of `𝔖`-convergence, is a TVS.
diff --git a/mathlib4/Mathlib/Topology/Algebra/MulAction.lean b/mathlib4/Mathlib/Topology/Algebra/MulAction.lean
index 7efa23072..ce466c4e9 100644
--- a/mathlib4/Mathlib/Topology/Algebra/MulAction.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/MulAction.lean
@@ -95,7 +95,6 @@ instance OrderDual.instContinuousSMul_left : ContinuousSMul Mᵒᵈ X where
 instance (priority := 100) ContinuousSMul.continuousConstSMul : ContinuousConstSMul M X where
   continuous_const_smul _ := continuous_smul.comp (continuous_const.prodMk continuous_id)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 theorem ContinuousSMul.induced {R : Type*} {α : Type*} {β : Type*} {F : Type*} [FunLike F α β]
     [Semiring R] [AddCommMonoid α] [AddCommMonoid β] [Module R α] [Module R β]
diff --git a/mathlib4/Mathlib/Topology/Algebra/StarSubalgebra.lean b/mathlib4/Mathlib/Topology/Algebra/StarSubalgebra.lean
index 137c392a3..403ae5bee 100644
--- a/mathlib4/Mathlib/Topology/Algebra/StarSubalgebra.lean
+++ b/mathlib4/Mathlib/Topology/Algebra/StarSubalgebra.lean
@@ -258,7 +258,6 @@ theorem induction_on {x y : A}
     exact mul u (subset_closure hu_mem) v (subset_closure hv_mem) (hu hu_mem) (hv hv_mem)
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem starAlgHomClass_ext [T2Space B] {F : Type*} {a : A}
     [FunLike F (elemental R a) B] [AlgHomClass F R _ B] [StarHomClass F _ B]
     {φ ψ : F} (hφ : Continuous φ)
diff --git a/mathlib4/Mathlib/Topology/Category/CompHausLike/Basic.lean b/mathlib4/Mathlib/Topology/Category/CompHausLike/Basic.lean
index 1e2605ce2..6efae58bf 100644
--- a/mathlib4/Mathlib/Topology/Category/CompHausLike/Basic.lean
+++ b/mathlib4/Mathlib/Topology/Category/CompHausLike/Basic.lean
@@ -94,7 +94,6 @@ instance category : Category (CompHausLike P) :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance concreteCategory : ConcreteCategory (CompHausLike P) (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTop) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/CompHausLike/Cartesian.lean b/mathlib4/Mathlib/Topology/Category/CompHausLike/Cartesian.lean
index c51534467..1bd5cf355 100644
--- a/mathlib4/Mathlib/Topology/Category/CompHausLike/Cartesian.lean
+++ b/mathlib4/Mathlib/Topology/Category/CompHausLike/Cartesian.lean
@@ -42,7 +42,6 @@ def productCone : BinaryFan X Y :=
     (ofHom _ { toFun := Prod.fst }) (ofHom _ { toFun := Prod.snd })
 
 -- `continuity` getting confused about category theory
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 When the predicate `P` is preserved under taking type-theoretic products, that product is a
 category-theoretic product in `CompHausLike P`.
@@ -82,7 +81,6 @@ def coproductCocone : BinaryCofan X Y := BinaryCofan.mk (P := CompHausLike.of P
   (ofHom _ { toFun := Sum.inl }) (ofHom _ { toFun := Sum.inr })
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /--
 When the predicate `P` is preserved under taking type-theoretic sums, that sum is a
 category-theoretic coproduct in `CompHausLike P`.
diff --git a/mathlib4/Mathlib/Topology/Category/CompactlyGenerated.lean b/mathlib4/Mathlib/Topology/Category/CompactlyGenerated.lean
index 97c48c9a0..46ab31b24 100644
--- a/mathlib4/Mathlib/Topology/Category/CompactlyGenerated.lean
+++ b/mathlib4/Mathlib/Topology/Category/CompactlyGenerated.lean
@@ -51,7 +51,6 @@ instance : Category.{w, w + 1} CompactlyGenerated.{u, w} :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ConcreteCategory.{w} CompactlyGenerated.{u, w} (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTop) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/FinTopCat.lean b/mathlib4/Mathlib/Topology/Category/FinTopCat.lean
index 104511c23..9d37cb403 100644
--- a/mathlib4/Mathlib/Topology/Category/FinTopCat.lean
+++ b/mathlib4/Mathlib/Topology/Category/FinTopCat.lean
@@ -44,7 +44,6 @@ instance : Category FinTopCat :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ConcreteCategory FinTopCat (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTop) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/LightProfinite/Basic.lean b/mathlib4/Mathlib/Topology/Category/LightProfinite/Basic.lean
index 538b0b4bc..b8a0262fe 100644
--- a/mathlib4/Mathlib/Topology/Category/LightProfinite/Basic.lean
+++ b/mathlib4/Mathlib/Topology/Category/LightProfinite/Basic.lean
@@ -259,7 +259,6 @@ instance : Category LightDiagram :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance hasForget : ConcreteCategory LightDiagram (fun X Y => C(X.toProfinite, Y.toProfinite)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toProfinite) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean b/mathlib4/Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
index f22e43881..37c048e5b 100644
--- a/mathlib4/Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
+++ b/mathlib4/Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
@@ -527,7 +527,6 @@ theorem good_lt_maxProducts (q : GoodProducts (π C (ord I · < o)))
     simp only [term, Ordinal.typein_enum]
     exact Products.prop_of_isGood C _ q.prop q.val.val.head! (List.head!_mem_self h)
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency.types false in
 include hC hsC in
 /--
diff --git a/mathlib4/Mathlib/Topology/Category/Profinite/Product.lean b/mathlib4/Mathlib/Topology/Category/Profinite/Product.lean
index 53ff533be..53f9493c3 100644
--- a/mathlib4/Mathlib/Topology/Category/Profinite/Product.lean
+++ b/mathlib4/Mathlib/Topology/Category/Profinite/Product.lean
@@ -100,7 +100,6 @@ def indexCone (hC : IsCompact C) : Cone (indexFunctor hC) where
 variable (hC : IsCompact C)
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance isIso_indexCone_lift :
     IsIso ((limitConeIsLimit.{u, u} (indexFunctor hC)).lift (indexCone hC)) :=
   haveI : CompactSpace C := by rwa [← isCompact_iff_compactSpace]
diff --git a/mathlib4/Mathlib/Topology/Category/Sequential.lean b/mathlib4/Mathlib/Topology/Category/Sequential.lean
index cf9c219c9..b5fd3c922 100644
--- a/mathlib4/Mathlib/Topology/Category/Sequential.lean
+++ b/mathlib4/Mathlib/Topology/Category/Sequential.lean
@@ -46,7 +46,6 @@ instance : Category.{u, u + 1} Sequential.{u} :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : ConcreteCategory.{u} Sequential.{u} (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTop) _
 
diff --git a/mathlib4/Mathlib/Topology/Category/TopCat/Limits/Products.lean b/mathlib4/Mathlib/Topology/Category/TopCat/Limits/Products.lean
index f9f5f5d65..6cb768118 100644
--- a/mathlib4/Mathlib/Topology/Category/TopCat/Limits/Products.lean
+++ b/mathlib4/Mathlib/Topology/Category/TopCat/Limits/Products.lean
@@ -129,7 +129,6 @@ abbrev prodSnd {X Y : TopCat.{u}} : TopCat.of (X × Y) ⟶ Y :=
 def prodBinaryFan (X Y : TopCat.{u}) : BinaryFan X Y :=
   BinaryFan.mk prodFst prodSnd
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The constructed binary fan is indeed a limit -/
 def prodBinaryFanIsLimit (X Y : TopCat.{u}) : IsLimit (prodBinaryFan X Y) where
   lift := fun S : BinaryFan X Y => ofHom { toFun s := (S.fst s, S.snd s) }
@@ -237,7 +236,6 @@ protected def binaryCofan (X Y : TopCat.{u}) : BinaryCofan X Y :=
 set_option backward.isDefEq.respectTransparency.types false in
 -- `continuity` can't unfold the category theory language properly.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The constructed binary coproduct cofan in `TopCat` is the coproduct. -/
 def binaryCofanIsColimit (X Y : TopCat.{u}) : IsColimit (TopCat.binaryCofan X Y) := by
   refine Limits.BinaryCofan.isColimitMk (fun s => ofHom
@@ -254,7 +252,6 @@ def binaryCofanIsColimit (X Y : TopCat.{u}) : IsColimit (TopCat.binaryCofan X Y)
     exacts [ConcreteCategory.congr_hom h₁ x, ConcreteCategory.congr_hom h₂ x]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 theorem binaryCofan_isColimit_iff {X Y : TopCat.{u}} (c : BinaryCofan X Y) :
     Nonempty (IsColimit c) ↔
       IsOpenEmbedding c.inl ∧ IsOpenEmbedding c.inr ∧ IsCompl (range c.inl) (range c.inr) := by
diff --git a/mathlib4/Mathlib/Topology/Category/TopCat/Monoidal.lean b/mathlib4/Mathlib/Topology/Category/TopCat/Monoidal.lean
index 377c44aa5..8be64b3ab 100644
--- a/mathlib4/Mathlib/Topology/Category/TopCat/Monoidal.lean
+++ b/mathlib4/Mathlib/Topology/Category/TopCat/Monoidal.lean
@@ -131,13 +131,11 @@ lemma ext {x y : I.{u}} (h : homeomorph x = homeomorph y) : x = y :=
   homeomorph.injective h
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The symmetrization map `TopCat.I ⟶ TopCat.I`. -/
 def symm : I.{u} ⟶ I :=
   ofHom ⟨homeomorph.symm ∘ unitInterval.symm ∘ homeomorph, by fun_prop⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp]
 lemma homeomorph_symm (x : I) :
     homeomorph (symm x) = unitInterval.symm (homeomorph x) := rfl
@@ -146,7 +144,6 @@ instance : OfNat I.{u} 0 := ⟨homeomorph.symm 0⟩
 instance : OfNat I.{u} 1 := ⟨homeomorph.symm 1⟩
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 @[simp] lemma homeomorph_zero : homeomorph (0 : I.{u}) = 0 := by simp [OfNat.ofNat]
 @[simp] lemma homeomorph_one : homeomorph (1 : I.{u}) = 1 := by simp [OfNat.ofNat]
 @[simp] lemma symm_one : I.symm 1 = 0 := by aesop
diff --git a/mathlib4/Mathlib/Topology/Category/TopCat/ULift.lean b/mathlib4/Mathlib/Topology/Category/TopCat/ULift.lean
index 4faaf93f8..26fe7b61a 100644
--- a/mathlib4/Mathlib/Topology/Category/TopCat/ULift.lean
+++ b/mathlib4/Mathlib/Topology/Category/TopCat/ULift.lean
@@ -57,7 +57,6 @@ def uliftFunctorCompForgetIso : uliftFunctor.{v, u} ⋙ forget TopCat.{max u v}
     forget TopCat.{u} ⋙ CategoryTheory.uliftFunctor.{v, u} := Iso.refl _
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The `ULift` functor on categories of topological spaces is fully faithful. -/
 def uliftFunctorFullyFaithful : uliftFunctor.{v, u}.FullyFaithful where
   preimage f := ofHom ⟨ULift.down ∘ f ∘ ULift.up, by fun_prop⟩
diff --git a/mathlib4/Mathlib/Topology/Category/UniformSpace.lean b/mathlib4/Mathlib/Topology/Category/UniformSpace.lean
index baa765d5e..46335ec85 100644
--- a/mathlib4/Mathlib/Topology/Category/UniformSpace.lean
+++ b/mathlib4/Mathlib/Topology/Category/UniformSpace.lean
@@ -165,7 +165,6 @@ instance instFunLike (X Y : CpltSepUniformSpace) :
   coe_injective _ _ h := Subtype.ext h
 
 set_option backward.isDefEq.respectTransparency.types false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- The concrete category instance on `CpltSepUniformSpace`. -/
 instance concreteCategory : ConcreteCategory CpltSepUniformSpace
     ({ f : · → · // UniformContinuous f }) :=
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/CompactlySupported.lean b/mathlib4/Mathlib/Topology/ContinuousMap/CompactlySupported.lean
index b700fa12a..ddb70bfdd 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/CompactlySupported.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/CompactlySupported.lean
@@ -794,7 +794,6 @@ end toNNRealLinear
 
 section toRealPositiveLinear
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- For a positive linear functional `Λ : C_c(α, ℝ≥0) → ℝ≥0`, define a positive `ℝ`-linear map. -/
 noncomputable def toRealPositiveLinear (Λ : C_c(α, ℝ≥0) →ₗ[ℝ≥0] ℝ≥0) : C_c(α, ℝ) →ₚ[ℝ] ℝ :=
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/ContinuousMapZero.lean b/mathlib4/Mathlib/Topology/ContinuousMap/ContinuousMapZero.lean
index 41d4b745b..ce0246b22 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/ContinuousMapZero.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/ContinuousMapZero.lean
@@ -444,7 +444,6 @@ def nonUnitalStarAlgHom_precomp (f : C(X, Y)₀) : C(Y, R)₀ →⋆ₙₐ[R] C(
   map_star' _ := rfl
   map_smul' _ _ := rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 variable (X) in
 /-- The functor `C(X, ·)₀` from non-unital topological star algebras (with non-unital continuous
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/Star.lean b/mathlib4/Mathlib/Topology/ContinuousMap/Star.lean
index c491658af..27143ab13 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/Star.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/Star.lean
@@ -155,7 +155,6 @@ variable (𝕜 : Type*) [CommSemiring 𝕜]
 variable (A : Type*) [TopologicalSpace A] [Semiring A] [IsTopologicalSemiring A] [StarRing A]
 variable [ContinuousStar A] [Algebra 𝕜 A]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- `ContinuousMap.compStarAlgHom'` as a `StarAlgEquiv` when the continuous map `f` is
 actually a homeomorphism. -/
 @[simps]
diff --git a/mathlib4/Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean b/mathlib4/Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean
index ccbcb4bf2..bb86c4ef0 100644
--- a/mathlib4/Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean
+++ b/mathlib4/Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean
@@ -556,7 +556,6 @@ lemma adjoin_id_eq_span_one_add (s : Set 𝕜) :
     StarAlgebra.adjoin_nonUnitalStarSubalgebra_eq_span, mem_sup]
   simp [Set.mem_add]
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma nonUnitalStarAlgebraAdjoin_id_subset_ker_evalStarAlgHom {s : Set 𝕜} (h0 : 0 ∈ s) :
     (adjoin 𝕜 {restrict s (.id 𝕜)} : Set C(s, 𝕜)) ⊆
       RingHom.ker (evalStarAlgHom 𝕜 𝕜 (⟨0, h0⟩ : s)) := by
@@ -594,7 +593,6 @@ lemma ker_evalStarAlgHom_inter_adjoin_id (s : Set 𝕜) (h0 : 0 ∈ s) :
 
 set_option backward.isDefEq.respectTransparency false in
 -- the statement should be in terms of nonunital subalgebras, but we lack API
-set_option backward.isDefEq.respectTransparency.outParams false in
 open RingHom Filter Topology in
 theorem AlgHom.closure_ker_inter {F S K A : Type*} [CommRing K] [Ring A] [Algebra K A]
     [TopologicalSpace K] [T1Space K] [TopologicalSpace A] [ContinuousSub A] [ContinuousSMul K A]
@@ -681,7 +679,6 @@ theorem ContinuousMapZero.induction_on_of_compact {s : Set 𝕜} [Fact (0 ∈ s)
   have := (ContinuousMapZero.adjoin_id_dense s).closure_eq ▸ Set.mem_univ (x := f)
   exact mem_closure_iff_frequently.mp this |>.mp <| .of_forall h
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ContinuousMapZero.nonUnitalStarAlgHom_apply_mul_eq_zero {𝕜 A : Type*}
     [RCLike 𝕜] [NonUnitalSemiring A] [Star A] [TopologicalSpace A] [SeparatelyContinuousMul A]
     [T2Space A] [DistribMulAction 𝕜 A] [IsScalarTower 𝕜 A A] {s : Set 𝕜} [Fact (0 ∈ s)]
@@ -697,7 +694,6 @@ lemma ContinuousMapZero.nonUnitalStarAlgHom_apply_mul_eq_zero {𝕜 A : Type*}
   | smul _ _ h => rw [map_smul, smul_mul_assoc, h, smul_zero]
   | frequently f h => exact h.mem_of_closed <| isClosed_eq (by fun_prop) continuous_zero
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma ContinuousMapZero.mul_nonUnitalStarAlgHom_apply_eq_zero {𝕜 A : Type*}
     [RCLike 𝕜] [NonUnitalSemiring A] [Star A] [TopologicalSpace A] [SeparatelyContinuousMul A]
     [T2Space A] [DistribMulAction 𝕜 A] [SMulCommClass 𝕜 A A] {s : Set 𝕜} [Fact (0 ∈ s)]
diff --git a/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean b/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
index 2924f474d..59b9efc7d 100644
--- a/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
+++ b/mathlib4/Mathlib/Topology/EMetricSpace/BoundedVariation.lean
@@ -718,7 +718,6 @@ lemma eVariationOn_Ioc_eq_Icc_of_continuousWithinAt
   exact eVariationOn_Ioc_eq_Icc_of_continuousWithinAt' h'
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma eVariationOn_Ico_eq_Icc_of_continuousWithinAt'
     [TopologicalSpace α] [OrderTopology α] {f : α → E} {a b : α}
     [h : (𝓝[<] a).NeBot] (h' : ContinuousWithinAt f (Iic a) a) :
@@ -727,7 +726,6 @@ lemma eVariationOn_Ico_eq_Icc_of_continuousWithinAt'
   exact eVariationOn_Ioc_eq_Icc_of_continuousWithinAt' h'
 
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma eVariationOn_Ico_eq_Icc_of_continuousWithinAt
     [TopologicalSpace α] [OrderTopology α] [DenselyOrdered α] {f : α → E} {a b : α}
     (h' : ContinuousWithinAt f (Iic a) a) :
diff --git a/mathlib4/Mathlib/Topology/EMetricSpace/PairReduction.lean b/mathlib4/Mathlib/Topology/EMetricSpace/PairReduction.lean
index db34b9e06..600b99164 100644
--- a/mathlib4/Mathlib/Topology/EMetricSpace/PairReduction.lean
+++ b/mathlib4/Mathlib/Topology/EMetricSpace/PairReduction.lean
@@ -359,7 +359,6 @@ lemma logSizeRadius_le_card_smallBall (hJ : J.Nonempty) (i : ℕ) (ha : 1 < a) :
     simp [h]
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 lemma card_pairSet_le (ha : 1 < a) : #(pairSet J a c) ≤ a * #J := by
   wlog hJ : J.Nonempty
   · simp [Finset.not_nonempty_iff_eq_empty.mp hJ]
diff --git a/mathlib4/Mathlib/Topology/Homotopy/TopCat/Path.lean b/mathlib4/Mathlib/Topology/Homotopy/TopCat/Path.lean
index 09bfd5062..b1e6c94a6 100644
--- a/mathlib4/Mathlib/Topology/Homotopy/TopCat/Path.lean
+++ b/mathlib4/Mathlib/Topology/Homotopy/TopCat/Path.lean
@@ -39,7 +39,6 @@ attribute [simp] Path.hom₀ Path.hom₁
 
 -- Would need `(ULift.{u, 0} ↑unitInterval) = TopCat.I` at instances transparency
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 variable {X} in
 /-- The bijection between `TopCat.Path X x y` and `_root_.Path x y`. -/
 @[simps!]
diff --git a/mathlib4/Mathlib/Topology/Homotopy/TopCat/ZerothHomotopy.lean b/mathlib4/Mathlib/Topology/Homotopy/TopCat/ZerothHomotopy.lean
index b568d0ba0..a0c1a429a 100644
--- a/mathlib4/Mathlib/Topology/Homotopy/TopCat/ZerothHomotopy.lean
+++ b/mathlib4/Mathlib/Topology/Homotopy/TopCat/ZerothHomotopy.lean
@@ -29,7 +29,6 @@ namespace TopCat
 variable {X : TopCat.{u}}
 
 set_option backward.isDefEq.respectTransparency false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 /-- Given `X : TopCat`, this is the bijection between `1`-simplices of the
 singular simplicial set of `X` and the type of morphisms `I ⟶ X`. -/
 noncomputable def toSSetObj₁Equiv :
diff --git a/mathlib4/Mathlib/Topology/Instances/Rat.lean b/mathlib4/Mathlib/Topology/Instances/Rat.lean
index 453f92c82..4184713fb 100644
--- a/mathlib4/Mathlib/Topology/Instances/Rat.lean
+++ b/mathlib4/Mathlib/Topology/Instances/Rat.lean
@@ -121,7 +121,6 @@ lemma nndist_eq (p q : ℚ≥0) : nndist p q = nndist (p : ℚ) (q : ℚ) := rfl
 
 -- Defeq abuse, applying instances about `Subtype` to `ℚ≥0`.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance : IsTopologicalSemiring ℚ≥0 where
   toContinuousAdd := continuousAdd_induced Nonneg.coeRingHom
   toContinuousMul := continuousMul_induced Nonneg.coeRingHom
diff --git a/mathlib4/Mathlib/Topology/Order/Category/AlexDisc.lean b/mathlib4/Mathlib/Topology/Order/Category/AlexDisc.lean
index a5fdf6220..b4d978e1f 100644
--- a/mathlib4/Mathlib/Topology/Order/Category/AlexDisc.lean
+++ b/mathlib4/Mathlib/Topology/Order/Category/AlexDisc.lean
@@ -34,7 +34,6 @@ instance category : Category AlexDisc :=
 
 -- Would need to have a new type synonym for the `FunLike` instance for the induced category.
 set_option backward.isDefEq.respectTransparency.instances false in
-set_option backward.isDefEq.respectTransparency.outParams false in
 instance concreteCategory : ConcreteCategory AlexDisc (C(·, ·)) :=
   inferInstanceAs <| ConcreteCategory (InducedCategory _ toTopCat) _
 
diff --git a/mathlib4/Mathlib/Topology/VectorBundle/Basic.lean b/mathlib4/Mathlib/Topology/VectorBundle/Basic.lean
index bbc3e2a32..d2087abfa 100644
--- a/mathlib4/Mathlib/Topology/VectorBundle/Basic.lean
+++ b/mathlib4/Mathlib/Topology/VectorBundle/Basic.lean
@@ -662,7 +662,6 @@ theorem localTriv_apply {i : ι} (p : Z.TotalSpace) :
     (Z.localTriv i) p = ⟨p.1, Z.coordChange (Z.indexAt p.1) i p.1 p.2⟩ :=
   rfl
 
-set_option backward.isDefEq.respectTransparency.outParams false in
 set_option backward.isDefEq.respectTransparency false in
 /-- The standard local trivializations of a vector bundle constructed from core are linear. -/
 instance localTriv.isLinear (i : ι) : (Z.localTriv i).IsLinear R where

From 658b90a3e52ee47e350959f8873b139e675e08c2 Mon Sep 17 00:00:00 2001
From: "downstream-lean4[bot]" <downstream-lean4[bot]@users.noreply.github.com>
Date: Fri, 14 Aug 2026 16:02:30 +0000
Subject: [PATCH 7/7] downstream: follow upstream PR

---
 lean-toolchain | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lean-toolchain b/lean-toolchain
index 0bcee2854..af91fa0dc 100644
--- a/lean-toolchain
+++ b/lean-toolchain
@@ -1 +1 @@
-leanprover/lean4-pr-releases:pr-release-14536-9dc2a3b
+leanprover/lean4-pr-releases:pr-release-14536-bb2ac20