ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.mem_primeFactorsList_mul
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
⊢ p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∨ p ∈ b.primeFactorsList
state_after: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
⊢ Prime p ∧ p ∣ a * b ↔ Prime p ∧ (p ∣ a ∨ p ∣ b)
tactic: rw [mem_primeFactorsList (mul_ne_zero ha hb), mem_primeFactorsList ha, mem_primeFactorsList hb,
    ← and_or_left]
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
⊢ Prime p ∧ p ∣ a * b ↔ Prime p ∧ (p ∣ a ∨ p ∣ b)
state_after: no goals
tactic: simpa only [and_congr_right_iff] using Prime.dvd_mul
Theorem: Finset.prod_Ico_eq_div
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
δ : Type u_3
inst✝ : CommGroup δ
f : ℕ → δ
m n : ℕ
h : m ≤ n
⊢ ∏ k ∈ Ico m n, f k = (∏ k ∈ range n, f k) / ∏ k ∈ range m, f k
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using prod_Ico_eq_mul_inv f h
Theorem: MeasurableEquiv.quasiMeasurePreserving_symm
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ✝ : Measure α
ν : Measure β
μ : Measure α
e : α ≃ᵐ β
⊢ Measure.map (⇑e.symm) (Measure.map (⇑e) μ) ≪ μ
state_after: no goals
tactic: rw [Measure.map_map, e.symm_comp_self, Measure.map_id] <;> measurability
Theorem: mul_invOf_self_assoc'
File: Mathlib/Algebra/Group/Invertible/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a b : α
x✝ : Invertible a
⊢ a * (⅟a * b) = b
state_after: no goals
tactic: rw [← mul_assoc, mul_invOf_self, one_mul]
Theorem: MeasureTheory.FiniteMeasure.testAgainstNN_eq_mass_mul
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝¹ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝ : TopologicalSpace Ω
f : Ω →ᵇ ℝ≥0
⊢ μ.testAgainstNN f = μ.mass * μ.normalize.toFiniteMeasure.testAgainstNN f
state_after: Ω : Type u_1
inst✝¹ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝ : TopologicalSpace Ω
f : Ω →ᵇ ℝ≥0
⊢ (μ.mass • μ.normalize.toFiniteMeasure).testAgainstNN f = μ.mass * μ.normalize.toFiniteMeasure.testAgainstNN f
tactic: nth_rw 1 [μ.self_eq_mass_smul_normalize]
state_before: Ω : Type u_1
inst✝¹ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝ : TopologicalSpace Ω
f : Ω →ᵇ ℝ≥0
⊢ (μ.mass • μ.normalize.toFiniteMeasure).testAgainstNN f = μ.mass * μ.normalize.toFiniteMeasure.testAgainstNN f
state_after: no goals
tactic: rw [μ.normalize.toFiniteMeasure.smul_testAgainstNN_apply μ.mass f, smul_eq_mul]
Theorem: LieModule.trace_toEnd_weightSpace
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : LieAlgebra.IsNilpotent R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
χ : L → R
x : L
⊢ (trace R ↥↑(weightSpace M χ)) ((toEnd R L ↥↑(weightSpace M χ)) x) = finrank R ↥↑(weightSpace M χ) • χ x
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : LieAlgebra.IsNilpotent R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
χ : L → R
x : L
⊢ _root_.IsNilpotent ((toEnd R L ↥↑(weightSpace M χ)) x - χ x • LinearMap.id)
tactic: suffices _root_.IsNilpotent ((toEnd R L (weightSpace M χ) x) - χ x • LinearMap.id) by
    replace this := (isNilpotent_trace_of_isNilpotent this).eq_zero
    rwa [map_sub, map_smul, trace_id, sub_eq_zero, smul_eq_mul, mul_comm,
      ← nsmul_eq_mul] at this
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : LieAlgebra.IsNilpotent R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
χ : L → R
x : L
⊢ _root_.IsNilpotent ((toEnd R L ↥↑(weightSpace M χ)) x - χ x • LinearMap.id)
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : LieAlgebra.IsNilpotent R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
χ : L → R
x : L
⊢ _root_.IsNilpotent ((toEnd R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x))
tactic: rw [← Module.algebraMap_end_eq_smul_id]
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : LieAlgebra.IsNilpotent R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
χ : L → R
x : L
⊢ _root_.IsNilpotent ((toEnd R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x))
state_after: no goals
tactic: exact isNilpotent_toEnd_sub_algebraMap M χ x
Theorem: LightProfinite.lightToProfinite_map_proj_eq
File: Mathlib/Topology/Category/LightProfinite/AsLimit.lean

Proof steps:
state_before: S : LightProfinite
n : ℕ
⊢ lightToProfinite.map (S.proj n) =
    (lightToProfinite.obj S).asLimitCone.π.app
      ((sequentialFunctor (DiscreteQuotient ↑(lightToProfinite.obj S).toTop)).obj (Opposite.op n))
state_after: S : LightProfinite
n : ℕ
⊢ S.proj n =
    (Profinite.asLimitCone (CompHausLike.of (fun X => TotallyDisconnectedSpace ↑X) ↑S.toTop)).π.app
      ((sequentialFunctor (DiscreteQuotient ↑S.toTop)).obj (Opposite.op n))
tactic: simp? says simp only [toCompHausLike_obj, Functor.comp_obj,
      FintypeCat.toLightProfinite_obj_toTop_α, toCompHausLike_map, coe_of]
state_before: S : LightProfinite
n : ℕ
⊢ S.proj n =
    (Profinite.asLimitCone (CompHausLike.of (fun X => TotallyDisconnectedSpace ↑X) ↑S.toTop)).π.app
      ((sequentialFunctor (DiscreteQuotient ↑S.toTop)).obj (Opposite.op n))
state_after: S : LightProfinite
n : ℕ
c : Cone (S.diagram ⋙ lightToProfinite) := S.toLightDiagram.cone
⊢ S.proj n =
    (Profinite.asLimitCone (CompHausLike.of (fun X => TotallyDisconnectedSpace ↑X) ↑S.toTop)).π.app
      ((sequentialFunctor (DiscreteQuotient ↑S.toTop)).obj (Opposite.op n))
tactic: let c : Cone (S.diagram ⋙ lightToProfinite) := S.toLightDiagram.cone
state_before: S : LightProfinite
n : ℕ
c : Cone (S.diagram ⋙ lightToProfinite) := S.toLightDiagram.cone
⊢ S.proj n =
    (Profinite.asLimitCone (CompHausLike.of (fun X => TotallyDisconnectedSpace ↑X) ↑S.toTop)).π.app
      ((sequentialFunctor (DiscreteQuotient ↑S.toTop)).obj (Opposite.op n))
state_after: S : LightProfinite
n : ℕ
c : Cone (S.diagram ⋙ lightToProfinite) := S.toLightDiagram.cone
hc : IsLimit c := S.toLightDiagram.isLimit
⊢ S.proj n =
    (Profinite.asLimitCone (CompHausLike.of (fun X => TotallyDisconnectedSpace ↑X) ↑S.toTop)).π.app
      ((sequentialFunctor (DiscreteQuotient ↑S.toTop)).obj (Opposite.op n))
tactic: let hc : IsLimit c := S.toLightDiagram.isLimit
state_before: S : LightProfinite
n : ℕ
c : Cone (S.diagram ⋙ lightToProfinite) := S.toLightDiagram.cone
hc : IsLimit c := S.toLightDiagram.isLimit
⊢ S.proj n =
    (Profinite.asLimitCone (CompHausLike.of (fun X => TotallyDisconnectedSpace ↑X) ↑S.toTop)).π.app
      ((sequentialFunctor (DiscreteQuotient ↑S.toTop)).obj (Opposite.op n))
state_after: no goals
tactic: exact map_liftedLimit hc _
Theorem: MeasureTheory.MeasurePreserving.restrict_image_emb
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
f : α → β
hf : MeasurePreserving f μa μb
h₂ : MeasurableEmbedding f
s : Set α
⊢ MeasurePreserving f (μa.restrict s) (μb.restrict (f '' s))
state_after: no goals
tactic: simpa only [Set.preimage_image_eq _ h₂.injective] using hf.restrict_preimage_emb h₂ (f '' s)
Theorem: Irrational.neg
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
h : Irrational x
⊢ Irrational (- -x)
state_after: no goals
tactic: rwa [neg_neg]
Theorem: Filter.limsup_eq_iInf_iSup_of_nat'
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
u : ℕ → α
⊢ limsup u atTop = ⨅ n, ⨆ i, u (i + n)
state_after: no goals
tactic: simp only [limsup_eq_iInf_iSup_of_nat, iSup_ge_eq_iSup_nat_add]
Theorem: CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi_hom_comp_pi
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
j : ι
⊢ (limitIsoPi ι X).hom ≫ Pi.π (fun x => X) j = WidePullback.π (fun x => terminal.from X) j
state_after: no goals
tactic: rw [← wideCospan.limitIsoPi_inv_comp_pi, Iso.hom_inv_id_assoc]
Theorem: Nat.pos_of_mem_divisors
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n m : ℕ
h : m ∈ n.divisors
⊢ 0 < m
state_after: case zero
n : ℕ
h : 0 ∈ n.divisors
⊢ 0 < 0

case succ
n n✝ : ℕ
h : n✝ + 1 ∈ n.divisors
⊢ 0 < n✝ + 1
tactic: cases m
state_before: case succ
n n✝ : ℕ
h : n✝ + 1 ∈ n.divisors
⊢ 0 < n✝ + 1
state_after: no goals
tactic: apply Nat.succ_pos
Theorem: vadd_zero_add
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M✝ : Type u_1
N✝ : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
M : Type u_11
N : Type u_12
inst✝² : MulOneClass N
inst✝¹ : SMul M N
inst✝ : IsScalarTower M N N
x : M
y : N
⊢ x • 1 * y = x • y
state_after: no goals
tactic: rw [smul_mul_assoc, one_mul]
Theorem: CancelDenoms.neg_subst
File: Mathlib/Tactic/CancelDenoms/Core.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Ring α
n e t : α
h1 : n * e = t
⊢ n * -e = -t
state_after: no goals
tactic: simp [*]
Theorem: mul_lt_iff_lt_one_right'
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : LT α
inst✝¹ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
⊢ a * b < b ↔ a * b < 1 * b
state_after: no goals
tactic: rw [one_mul]
Theorem: MeasureTheory.SignedMeasure.rnDeriv_neg
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : s.HaveLebesgueDecomposition μ
⊢ (-s).rnDeriv μ =ᶠ[ae μ] -s.rnDeriv μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : s.HaveLebesgueDecomposition μ
⊢ μ.withDensityᵥ ((-s).rnDeriv μ) = μ.withDensityᵥ (-s.rnDeriv μ)
tactic: refine
    Integrable.ae_eq_of_withDensityᵥ_eq (integrable_rnDeriv _ _) (integrable_rnDeriv _ _).neg ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : s.HaveLebesgueDecomposition μ
⊢ μ.withDensityᵥ ((-s).rnDeriv μ) = μ.withDensityᵥ (-s.rnDeriv μ)
state_after: no goals
tactic: rw [withDensityᵥ_neg, ← add_right_inj ((-s).singularPart μ),
    singularPart_add_withDensity_rnDeriv_eq, singularPart_neg, ← neg_add,
    singularPart_add_withDensity_rnDeriv_eq]
Theorem: Set.BijOn.forall
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b✝ : β
p : β → Prop
hf : BijOn f s t
h : ∀ a ∈ s, p (f a)
b : β
hb : b ∈ t
⊢ p b
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
p : β → Prop
hf : BijOn f s t
h : ∀ a ∈ s, p (f a)
a : α
ha : a ∈ s
hb : f a ∈ t
⊢ p (f a)
tactic: obtain ⟨a, ha, rfl⟩ := hf.surjOn hb
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
p : β → Prop
hf : BijOn f s t
h : ∀ a ∈ s, p (f a)
a : α
ha : a ∈ s
hb : f a ∈ t
⊢ p (f a)
state_after: no goals
tactic: exact h _ ha
Theorem: MeasurableSpace.map_const
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
b : β
s : Set β
x✝ : MeasurableSet s
⊢ MeasurableSet s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
b : β
s : Set β
x✝ : MeasurableSet s
⊢ MeasurableSet ((fun _a => b) ⁻¹' s)
tactic: rw [map_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
b : β
s : Set β
x✝ : MeasurableSet s
⊢ MeasurableSet ((fun _a => b) ⁻¹' s)
state_after: no goals
tactic: by_cases h : b ∈ s <;> simp [h]
Theorem: Polynomial.coeff_multiset_prod_of_natDegree_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
n : ℕ
hl : ∀ p ∈ t, p.natDegree ≤ n
⊢ t.prod.coeff (Multiset.card t * n) = (Multiset.map (fun p => p.coeff n) t).prod
state_after: case h
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
n : ℕ
a✝ : List R[X]
hl : ∀ p ∈ ⟦a✝⟧, p.natDegree ≤ n
⊢ (prod ⟦a✝⟧).coeff (Multiset.card ⟦a✝⟧ * n) = (Multiset.map (fun p => p.coeff n) ⟦a✝⟧).prod
tactic: induction t using Quotient.inductionOn
state_before: case h
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
n : ℕ
a✝ : List R[X]
hl : ∀ p ∈ ⟦a✝⟧, p.natDegree ≤ n
⊢ (prod ⟦a✝⟧).coeff (Multiset.card ⟦a✝⟧ * n) = (Multiset.map (fun p => p.coeff n) ⟦a✝⟧).prod
state_after: no goals
tactic: simpa using coeff_list_prod_of_natDegree_le _ _ hl
Theorem: mem_coeSubmodule_conductor
File: Mathlib/NumberTheory/KummerDedekind.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
x✝ : S
L : Type u_3
inst✝⁴ : CommRing L
inst✝³ : Algebra S L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R S L
inst✝ : NoZeroSMulDivisors S L
x : S
y : L
⊢ y ∈ coeSubmodule L (conductor R x) ↔ ∀ (z : S), y * (algebraMap S L) z ∈ adjoin R {(algebraMap S L) x}
state_after: case inl
R : Type u_1
S : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
x✝ : S
L : Type u_3
inst✝⁴ : CommRing L
inst✝³ : Algebra S L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R S L
inst✝ : NoZeroSMulDivisors S L
x : S
y : L
h✝ : Subsingleton L
⊢ y ∈ coeSubmodule L (conductor R x) ↔ ∀ (z : S), y * (algebraMap S L) z ∈ adjoin R {(algebraMap S L) x}

case inr
R : Type u_1
S : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
x✝ : S
L : Type u_3
inst✝⁴ : CommRing L
inst✝³ : Algebra S L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R S L
inst✝ : NoZeroSMulDivisors S L
x : S
y : L
h✝ : Nontrivial L
⊢ y ∈ coeSubmodule L (conductor R x) ↔ ∀ (z : S), y * (algebraMap S L) z ∈ adjoin R {(algebraMap S L) x}
tactic: cases subsingleton_or_nontrivial L
state_before: case inr
R : Type u_1
S : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
x✝ : S
L : Type u_3
inst✝⁴ : CommRing L
inst✝³ : Algebra S L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R S L
inst✝ : NoZeroSMulDivisors S L
x : S
y : L
h✝ : Nontrivial L
⊢ y ∈ coeSubmodule L (conductor R x) ↔ ∀ (z : S), y * (algebraMap S L) z ∈ adjoin R {(algebraMap S L) x}
state_after: R : Type u_1
S : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
x✝ : S
L : Type u_3
inst✝⁴ : CommRing L
inst✝³ : Algebra S L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R S L
inst✝ : NoZeroSMulDivisors S L
x : S
y : L
h✝ : Nontrivial L
⊢ y ∈ coeSubmodule L (conductor R x) ↔
    ∀ (z : S), y * (algebraMap S L) z ∈ Subalgebra.map (IsScalarTower.toAlgHom R S L) (adjoin R {x})

R : Type u_1
S : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
x✝ : S
L : Type u_3
inst✝⁴ : CommRing L
inst✝³ : Algebra S L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R S L
inst✝ : NoZeroSMulDivisors S L
x : S
y : L
h✝ : Nontrivial L
⊢ (∀ (z : S), y * (algebraMap S L) z ∈ Subalgebra.map (IsScalarTower.toAlgHom R S L) (adjoin R {x})) ↔
    ∀ (z : S), y * (algebraMap S L) z ∈ adjoin R {(algebraMap S L) x}
tactic: trans ∀ z, y * (algebraMap S L) z ∈ (Algebra.adjoin R {x}).map (IsScalarTower.toAlgHom R S L)
Theorem: zsmul_one
File: Mathlib/Data/Int/Cast/Lemmas.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : AddGroupWithOne α
n : ℤ
⊢ n • 1 = ↑n
state_after: no goals
tactic: cases n <;> simp
Theorem: Function.Antiperiodic.sub_int_mul_eq
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Ring α
inst✝ : Ring β
h : Antiperiodic f c
n : ℤ
⊢ f (x - ↑n * c) = ↑↑n.negOnePow * f x
state_after: no goals
tactic: simpa only [zsmul_eq_mul] using h.sub_zsmul_eq n
Theorem: CategoryTheory.MonoidalCategory.hom_inv_whiskerRight'
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝¹ : MonoidalCategory C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
Z : C
⊢ f ▷ Z ≫ inv f ▷ Z = 𝟙 (X ⊗ Z)
state_after: no goals
tactic: rw [← comp_whiskerRight, IsIso.hom_inv_id, id_whiskerRight]
Theorem: Orientation.abs_volumeForm_apply_of_orthonormal
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n : ℕ
_i : Fact (finrank ℝ E = n)
o : Orientation ℝ E (Fin n)
v : OrthonormalBasis (Fin n) ℝ E
⊢ |o.volumeForm ⇑v| = 1
state_after: no goals
tactic: simpa [o.volumeForm_robust' v v] using congr_arg abs v.toBasis.det_self
Theorem: Ring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : Ring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : Ring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : Ring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl
Theorem: Basis.mapCoeffs_repr
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
R' : Type u_10
inst✝¹ : Semiring R'
inst✝ : Module R' M
f : R ≃+* R'
h : ∀ (c : R) (x : M), f c • x = c • x
⊢ Basis ι R' M
state_after: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
R' : Type u_10
inst✝¹ : Semiring R'
inst✝ : Module R' M
f : R ≃+* R'
h : ∀ (c : R) (x : M), f c • x = c • x
this : Module R' R := Module.compHom R ↑f.symm
⊢ Basis ι R' M
tactic: letI : Module R' R := Module.compHom R (↑f.symm : R' →+* R)
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
R' : Type u_10
inst✝¹ : Semiring R'
inst✝ : Module R' M
f : R ≃+* R'
h : ∀ (c : R) (x : M), f c • x = c • x
this✝ : Module R' R := Module.compHom R ↑f.symm
this : IsScalarTower R' R M
⊢ Basis ι R' M
state_after: no goals
tactic: exact ofRepr <| (b.repr.restrictScalars R').trans <|
    Finsupp.mapRange.linearEquiv (Module.compHom.toLinearEquiv f.symm).symm
Theorem: MeasureTheory.locallyIntegrableOn_univ
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
⊢ LocallyIntegrableOn f univ μ ↔ LocallyIntegrable f μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
⊢ (∀ (x : X), IntegrableAtFilter f (𝓝 x) μ) ↔ LocallyIntegrable f μ
tactic: simp only [LocallyIntegrableOn, nhdsWithin_univ, mem_univ, true_imp_iff]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
⊢ (∀ (x : X), IntegrableAtFilter f (𝓝 x) μ) ↔ LocallyIntegrable f μ
state_after: no goals
tactic: rfl
Theorem: ENNReal.ofReal_toReal_eq_iff
File: Mathlib/Data/ENNReal/Basic.lean

Proof steps:
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ENNReal.ofReal a.toReal = a
⊢ a ≠ ⊤
state_after: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ENNReal.ofReal a.toReal = a
⊢ ENNReal.ofReal a.toReal ≠ ⊤
tactic: rw [← h]
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ENNReal.ofReal a.toReal = a
⊢ ENNReal.ofReal a.toReal ≠ ⊤
state_after: no goals
tactic: exact ofReal_ne_top