ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.toLinearEquivRight'OfInv_symm_apply
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝³ : Fintype m
inst✝² : DecidableEq m
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n R
M' : Matrix n m R
hMM' : M * M' = 1
hM'M : M' * M = 1
x : n → R
⊢ (toLinearMapRight' M) ({ toFun := ⇑(toLinearMapRight' M'), map_add' := ⋯, map_smul' := ⋯ }.toFun x) = x
state_after: no goals
tactic: rw [← Matrix.toLinearMapRight'_mul_apply, hM'M, Matrix.toLinearMapRight'_one, id_apply]
state_before: R : Type u_1
inst✝⁴ : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝³ : Fintype m
inst✝² : DecidableEq m
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n R
M' : Matrix n m R
hMM' : M * M' = 1
hM'M : M' * M = 1
x : m → R
⊢ { toFun := ⇑(toLinearMapRight' M'), map_add' := ⋯, map_smul' := ⋯ }.toFun ((toLinearMapRight' M) x) = x
state_after: R : Type u_1
inst✝⁴ : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝³ : Fintype m
inst✝² : DecidableEq m
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n R
M' : Matrix n m R
hMM' : M * M' = 1
hM'M : M' * M = 1
x : m → R
⊢ (toLinearMapRight' M') ((toLinearMapRight' M) x) = x
tactic: dsimp only
state_before: R : Type u_1
inst✝⁴ : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝³ : Fintype m
inst✝² : DecidableEq m
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n R
M' : Matrix n m R
hMM' : M * M' = 1
hM'M : M' * M = 1
x : m → R
⊢ (toLinearMapRight' M') ((toLinearMapRight' M) x) = x
state_after: no goals
tactic: rw [← Matrix.toLinearMapRight'_mul_apply, hMM', Matrix.toLinearMapRight'_one, id_apply]
Theorem: AddSemiconjBy.zsmul_right
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ ↑n) (y ^ ↑n)
state_after: no goals
tactic: simp [zpow_natCast, h.pow_right n]
state_before: G : Type u_1
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ Int.negSucc n) (y ^ Int.negSucc n)
state_after: G : Type u_1
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ (n + 1)) (y ^ (n + 1))
tactic: simp only [zpow_negSucc, inv_right_iff]
state_before: G : Type u_1
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ (n + 1)) (y ^ (n + 1))
state_after: no goals
tactic: apply pow_right h
Theorem: Filter.pi_inf_principal_univ_pi_eq_bot
File: Mathlib/Order/Filter/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
⊢ pi f ⊓ 𝓟 (univ.pi s) = ⊥ ↔ ∃ i, f i ⊓ 𝓟 (s i) = ⊥
state_after: case mp
ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
⊢ pi f ⊓ 𝓟 (univ.pi s) = ⊥ → ∃ i, f i ⊓ 𝓟 (s i) = ⊥

case mpr
ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
⊢ (∃ i, f i ⊓ 𝓟 (s i) = ⊥) → pi f ⊓ 𝓟 (univ.pi s) = ⊥
tactic: constructor
Theorem: tendsto_inv_nhdsWithin_Iio_inv
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : TopologicalSpace α
f : α → G
s : Set α
x : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto Inv.inv (𝓝[<] a⁻¹) (𝓝[>] a)
state_after: no goals
tactic: simpa only [inv_inv] using @tendsto_inv_nhdsWithin_Iio _ _ _ _ a⁻¹
Theorem: ae_eq_of_integral_smooth_smul_eq
File: Mathlib/Analysis/Distribution/AEEqOfIntegralContDiff.lean

Proof steps:
state_before: E : Type u_1
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : FiniteDimensional ℝ E
F : Type u_2
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : CompleteSpace F
H : Type u_3
inst✝⁷ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_4
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
inst✝⁴ : SmoothManifoldWithCorners I M
inst✝³ : MeasurableSpace M
inst✝² : BorelSpace M
inst✝¹ : SigmaCompactSpace M
inst✝ : T2Space M
f f' : M → F
μ : Measure M
hf : LocallyIntegrable f μ
hf' : LocallyIntegrable f' μ
h : ∀ (g : M → ℝ), Smooth I 𝓘(ℝ, ℝ) g → HasCompactSupport g → ∫ (x : M), g x • f x ∂μ = ∫ (x : M), g x • f' x ∂μ
this : ∀ᵐ (x : M) ∂μ, (f - f') x = 0
⊢ ∀ᵐ (x : M) ∂μ, f x = f' x
state_after: case h
E : Type u_1
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : FiniteDimensional ℝ E
F : Type u_2
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : CompleteSpace F
H : Type u_3
inst✝⁷ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_4
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
inst✝⁴ : SmoothManifoldWithCorners I M
inst✝³ : MeasurableSpace M
inst✝² : BorelSpace M
inst✝¹ : SigmaCompactSpace M
inst✝ : T2Space M
f f' : M → F
μ : Measure M
hf : LocallyIntegrable f μ
hf' : LocallyIntegrable f' μ
h : ∀ (g : M → ℝ), Smooth I 𝓘(ℝ, ℝ) g → HasCompactSupport g → ∫ (x : M), g x • f x ∂μ = ∫ (x : M), g x • f' x ∂μ
this : ∀ᵐ (x : M) ∂μ, (f - f') x = 0
x : M
hx : (f - f') x = 0
⊢ f x = f' x
tactic: filter_upwards [this] with x hx
state_before: case h
E : Type u_1
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : FiniteDimensional ℝ E
F : Type u_2
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : CompleteSpace F
H : Type u_3
inst✝⁷ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_4
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
inst✝⁴ : SmoothManifoldWithCorners I M
inst✝³ : MeasurableSpace M
inst✝² : BorelSpace M
inst✝¹ : SigmaCompactSpace M
inst✝ : T2Space M
f f' : M → F
μ : Measure M
hf : LocallyIntegrable f μ
hf' : LocallyIntegrable f' μ
h : ∀ (g : M → ℝ), Smooth I 𝓘(ℝ, ℝ) g → HasCompactSupport g → ∫ (x : M), g x • f x ∂μ = ∫ (x : M), g x • f' x ∂μ
this : ∀ᵐ (x : M) ∂μ, (f - f') x = 0
x : M
hx : (f - f') x = 0
⊢ f x = f' x
state_after: no goals
tactic: simpa [sub_eq_zero] using hx
Theorem: IsUnit.dvd
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a b u : α
hu : IsUnit u
⊢ u ∣ a
state_after: case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ ↑u ∣ a
tactic: rcases hu with ⟨u, rfl⟩
state_before: case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ ↑u ∣ a
state_after: no goals
tactic: apply Units.coe_dvd
Theorem: AlgebraicGeometry.Scheme.OpenCover.gluedCover_f
File: Mathlib/AlgebraicGeometry/Gluing.lean

Proof steps:
state_before: X : Scheme
𝒰 : X.OpenCover
x : 𝒰.J
⊢ (fun x y => (pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom) x x =
    𝟙
      ((fun x =>
          match x with
          | (x, y) => pullback (𝒰.map x) (𝒰.map y))
        (x, x))
state_after: no goals
tactic: simp
state_before: X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ (fun x y z => 𝒰.gluedCoverT' x y z) x y z ≫
      pullback.snd ((fun x y => pullback.fst (𝒰.map x) (𝒰.map y)) y z)
        ((fun x y => pullback.fst (𝒰.map x) (𝒰.map y)) y x) =
    pullback.fst ((fun x y => pullback.fst (𝒰.map x) (𝒰.map y)) x y)
        ((fun x y => pullback.fst (𝒰.map x) (𝒰.map y)) x z) ≫
      (fun x y => (pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom) x y
state_after: no goals
tactic: apply pullback.hom_ext <;> simp
Theorem: Set.preimage_inl_range_inr
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
⊢ Sum.inl ⁻¹' range Sum.inr = ∅
state_after: no goals
tactic: rw [← image_univ, preimage_inl_image_inr]
Theorem: Finset.norm_prod_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : SeminormedRing α✝
α : Type u_5
inst✝¹ : NormedCommRing α
inst✝ : NormOneClass α
s : Finset ι
f : ι → α
⊢ ‖∏ i ∈ s, f i‖ ≤ ∏ i ∈ s, ‖f i‖
state_after: case mk.mk
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : SeminormedRing α✝
α : Type u_5
inst✝¹ : NormedCommRing α
inst✝ : NormOneClass α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
⊢ ‖∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖
tactic: rcases s with ⟨⟨l⟩, hl⟩
state_before: case mk.mk
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : SeminormedRing α✝
α : Type u_5
inst✝¹ : NormedCommRing α
inst✝ : NormOneClass α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
⊢ ‖∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖
state_after: no goals
tactic: simpa using (l.map f).norm_prod_le
Theorem: Nat.succ_iterate
File: Mathlib/Data/Nat/SuccPred.lean

Proof steps:
state_before: m n✝ a n : ℕ
⊢ succ^[n + 1] a = a + (n + 1)
state_after: m n✝ a n : ℕ
⊢ (succ ∘ succ^[n]) a = (a + n).succ
tactic: rw [Function.iterate_succ', add_succ]
state_before: m n✝ a n : ℕ
⊢ (succ ∘ succ^[n]) a = (a + n).succ
state_after: no goals
tactic: exact congr_arg _ (succ_iterate a n)
Theorem: CategoryTheory.Subobject.factors_add
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
wf : P.Factors f
wg : P.Factors g
⊢ (P.factorThru f wf + P.factorThru g wg) ≫ (representative.obj P).arrow = f + g
state_after: no goals
tactic: simp
Theorem: LSeriesSummable_zero
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: s : ℂ
⊢ LSeriesSummable 0 s
state_after: no goals
tactic: simp only [LSeriesSummable, funext (term_def 0 s), Pi.zero_apply, zero_div, ite_self,
    summable_zero]
Theorem: MeasureTheory.Measure.rnDeriv_smul_left_of_ne_top'
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ ν μ : Measure α
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hr : r ≠ ⊤
⊢ (r • ν).rnDeriv μ =ᶠ[ae μ] r • ν.rnDeriv μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ ν μ : Measure α
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hr : r ≠ ⊤
h : (r.toNNReal • ν).rnDeriv μ =ᶠ[ae μ] r.toNNReal • ν.rnDeriv μ
⊢ (r • ν).rnDeriv μ =ᶠ[ae μ] r • ν.rnDeriv μ
tactic: have h : (r.toNNReal • ν).rnDeriv μ =ᵐ[μ] r.toNNReal • ν.rnDeriv μ :=
    rnDeriv_smul_left' ν μ r.toNNReal
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ ν μ : Measure α
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hr : r ≠ ⊤
h : (r.toNNReal • ν).rnDeriv μ =ᶠ[ae μ] r.toNNReal • ν.rnDeriv μ
⊢ (r • ν).rnDeriv μ =ᶠ[ae μ] r • ν.rnDeriv μ
state_after: no goals
tactic: simpa [ENNReal.smul_def, ENNReal.coe_toNNReal hr] using h
Theorem: spectrum.zero_mem_iff
File: Mathlib/Algebra/Algebra/Spectrum.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
⊢ 0 ∈ σ a ↔ ¬IsUnit a
state_after: no goals
tactic: rw [mem_iff, map_zero, zero_sub, IsUnit.neg_iff]
Theorem: MeasureTheory.L2.mem_L1_inner
File: Mathlib/MeasureTheory/Function/L2Space.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : ↥(Lp E 2 μ)
⊢ AEEqFun.mk (fun x => ⟪↑↑f x, ↑↑g x⟫_𝕜) ⋯ ∈ Lp 𝕜 1 μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : ↥(Lp E 2 μ)
⊢ eLpNorm (fun x => ⟪↑↑f x, ↑↑g x⟫_𝕜) 1 μ < ⊤
tactic: simp_rw [mem_Lp_iff_eLpNorm_lt_top, eLpNorm_aeeqFun]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : ↥(Lp E 2 μ)
⊢ eLpNorm (fun x => ⟪↑↑f x, ↑↑g x⟫_𝕜) 1 μ < ⊤
state_after: no goals
tactic: exact eLpNorm_inner_lt_top f g
Theorem: CoalgebraCat.comonEquivalence_functor
File: Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
X✝ Y✝ : CoalgebraCat R
x✝ : X✝ ⟶ Y✝
⊢ (𝟭 (CoalgebraCat R)).map x✝ ≫ ((fun x => Iso.refl ((𝟭 (CoalgebraCat R)).obj x)) Y✝).hom =
    ((fun x => Iso.refl ((𝟭 (CoalgebraCat R)).obj x)) X✝).hom ≫ (toComon R ⋙ ofComon R).map x✝
state_after: no goals
tactic: rfl
state_before: R : Type u
inst✝ : CommRing R
X✝ Y✝ : Comon_ (ModuleCat R)
x✝ : X✝ ⟶ Y✝
⊢ (ofComon R ⋙ toComon R).map x✝ ≫ ((fun x => Iso.refl ((ofComon R ⋙ toComon R).obj x)) Y✝).hom =
    ((fun x => Iso.refl ((ofComon R ⋙ toComon R).obj x)) X✝).hom ≫ (𝟭 (Comon_ (ModuleCat R))).map x✝
state_after: no goals
tactic: rfl
Theorem: Finset.Ioc_insert_left
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a ≤ b
⊢ insert a (Ioc a b) = Icc a b
state_after: no goals
tactic: rw [← coe_inj, coe_insert, coe_Ioc, coe_Icc, Set.insert_eq, Set.union_comm, Set.Ioc_union_left h]
Theorem: Ordering.then_eq_lt
File: .lake/packages/batteries/Batteries/Classes/Order.lean

Proof steps:
state_before: o₁ o₂ : Ordering
⊢ o₁.then o₂ = lt ↔ o₁ = lt ∨ o₁ = eq ∧ o₂ = lt
state_after: no goals
tactic: cases o₁ <;> cases o₂ <;> decide
Theorem: symmDiff_sup_inf
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ b ⊔ a ⊓ b = a ⊔ b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ⊔ b ≤ a ∆ b ⊔ a ⊓ b
tactic: refine le_antisymm (sup_le symmDiff_le_sup inf_le_sup) ?_
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ⊔ b ≤ a ∆ b ⊔ a ⊓ b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ⊔ b ≤ (a \ b ⊔ b \ a ⊔ a) ⊓ (a \ b ⊔ b \ a ⊔ b)
tactic: rw [sup_inf_left, symmDiff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ⊔ b ≤ (a \ b ⊔ b \ a ⊔ a) ⊓ (a \ b ⊔ b \ a ⊔ b)
state_after: case refine_1
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ≤ a \ b ⊔ b \ a ⊔ b

case refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ b ≤ a \ b ⊔ b \ a ⊔ a
tactic: refine sup_le (le_inf le_sup_right ?_) (le_inf ?_ le_sup_right)
Theorem: Equiv.existsUnique_congr_right
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
e : α ≃ β
⊢ ∀ (a : α),
    ((fun a => q (e a)) a ∧ ∀ (y : α), (fun a => q (e a)) y → y = a) ↔
      (fun b => q b) (e a) ∧ ∀ (y : β), (fun b => q b) y → y = e a
state_after: no goals
tactic: simpa using fun _ _ ↦ e.forall_congr (by simp)
Theorem: MeasureTheory.quasiMeasurePreserving_sub_left_of_right_invariant
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulRightInvariant
g : G
⊢ QuasiMeasurePreserving (fun h => g / h) μ μ
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulRightInvariant
g : G
⊢ QuasiMeasurePreserving (fun h => g / h) μ.inv.inv μ.inv.inv
tactic: rw [← μ.inv_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulRightInvariant
g : G
⊢ QuasiMeasurePreserving (fun h => g / h) μ.inv.inv μ.inv.inv
state_after: no goals
tactic: exact
    (quasiMeasurePreserving_div_left μ.inv g).mono (inv_absolutelyContinuous μ.inv)
      (absolutelyContinuous_inv μ.inv)
Theorem: Multiset.sup_ndunion
File: Mathlib/Data/Multiset/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ (s₁.ndunion s₂).sup = s₁.sup ⊔ s₂.sup
state_after: α : Type u_1
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁.ndunion s₂ ↔ a ∈ s₁ + s₂
tactic: rw [← sup_dedup, dedup_ext.2, sup_dedup, sup_add]
state_before: α : Type u_1
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁.ndunion s₂ ↔ a ∈ s₁ + s₂
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.PreservesPushout.inl_iso_inv
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
W X Y Z : C
h : X ⟶ Z
k : Y ⟶ Z
f : W ⟶ X
g : W ⟶ Y
comm : f ≫ h = g ≫ k
inst✝² : PreservesColimit (span f g) G
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
⊢ G.map (pushout.inl f g) ≫ (iso G f g).inv = pushout.inl (G.map f) (G.map g)
state_after: no goals
tactic: simp [PreservesPushout.iso, Iso.comp_inv_eq]
Theorem: FormalMultilinearSeries.apply_eq_pow_smul_coeff
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

Proof steps:
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
n : ℕ
z z₀ : 𝕜
y : Fin n → 𝕜
⊢ ((p n) fun x => z) = z ^ n • p.coeff n
state_after: no goals
tactic: simp
Theorem: exists_Icc_mem_subset_of_mem_nhdsWithin_Ici
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
s : Set α
hs : s ∈ 𝓝[≥] a
⊢ ∃ b, a ≤ b ∧ Icc a b ∈ 𝓝[≥] a ∧ Icc a b ⊆ s
state_after: case inl
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
s : Set α
hs : s ∈ 𝓝[≥] a
ha : IsMax a
⊢ ∃ b, a ≤ b ∧ Icc a b ∈ 𝓝[≥] a ∧ Icc a b ⊆ s

case inr
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
s : Set α
hs : s ∈ 𝓝[≥] a
ha : ∃ b, a < b
⊢ ∃ b, a ≤ b ∧ Icc a b ∈ 𝓝[≥] a ∧ Icc a b ⊆ s
tactic: rcases (em (IsMax a)).imp_right not_isMax_iff.mp with (ha | ha)
Theorem: acc_principal_iff_cluster
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
x : X
C : Set X
⊢ AccPt x (𝓟 C) ↔ ClusterPt x (𝓟 (C \ {x}))
state_after: no goals
tactic: rw [acc_iff_cluster, inf_principal, inter_comm, diff_eq]
Theorem: CategoryTheory.Pretriangulated.isoTriangleOfIso₁₂_hom_hom₁
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
⊢ T₁ ≅ T₂
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
h : ∃ e', e'.hom.hom₁ = (Arrow.isoMk e₁ e₂ ⋯).hom.left ∧ e'.hom.hom₂ = (Arrow.isoMk e₁ e₂ ⋯).hom.right
⊢ T₁ ≅ T₂
tactic: have h := exists_iso_of_arrow_iso T₁ T₂ hT₁ hT₂ (Arrow.isoMk e₁ e₂ comm.symm)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
h : ∃ e', e'.hom.hom₁ = (Arrow.isoMk e₁ e₂ ⋯).hom.left ∧ e'.hom.hom₂ = (Arrow.isoMk e₁ e₂ ⋯).hom.right
⊢ T₁ ≅ T₂
state_after: no goals
tactic: exact Triangle.isoMk _ _ e₁ e₂ (Triangle.π₃.mapIso h.choose) comm (by
    have eq := h.choose_spec.2
    dsimp at eq ⊢
    conv_rhs => rw [← eq, ← TriangleMorphism.comm₂]) (by
    have eq := h.choose_spec.1
    dsimp at eq ⊢
    conv_lhs => rw [← eq, TriangleMorphism.comm₃])
Theorem: FermatLastTheoremWith.mono
File: Mathlib/NumberTheory/FLT/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n : ℕ
hmn : m ∣ n
hm : FermatLastTheoremWith α m
⊢ FermatLastTheoremWith α n
state_after: α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n : ℕ
hmn : m ∣ n
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
⊢ a ^ n + b ^ n ≠ c ^ n
tactic: rintro a b c ha hb hc
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n : ℕ
hmn : m ∣ n
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
⊢ a ^ n + b ^ n ≠ c ^ n
state_after: case intro
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m : ℕ
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
k : ℕ
⊢ a ^ (m * k) + b ^ (m * k) ≠ c ^ (m * k)
tactic: obtain ⟨k, rfl⟩ := hmn
state_before: case intro
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m : ℕ
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
k : ℕ
⊢ a ^ (m * k) + b ^ (m * k) ≠ c ^ (m * k)
state_after: case intro
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m : ℕ
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
k : ℕ
⊢ (a ^ k) ^ m + (b ^ k) ^ m ≠ (c ^ k) ^ m
tactic: simp_rw [pow_mul']
state_before: case intro
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m : ℕ
hm : FermatLastTheoremWith α m
a b c : α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
k : ℕ
⊢ (a ^ k) ^ m + (b ^ k) ^ m ≠ (c ^ k) ^ m
state_after: no goals
tactic: refine hm _ _ _ ?_ ?_ ?_ <;> exact pow_ne_zero _ ‹_›
Theorem: AddMonoidHom.comp_sub
File: Mathlib/Algebra/Group/Hom/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
⊢ f.comp (g / h) = f.comp g / f.comp h
state_after: case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
x✝ : M
⊢ (f.comp (g / h)) x✝ = (f.comp g / f.comp h) x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
x✝ : M
⊢ (f.comp (g / h)) x✝ = (f.comp g / f.comp h) x✝
state_after: no goals
tactic: simp only [Function.comp_apply, div_apply, map_div, coe_comp]
Theorem: Int.dvd_of_dvd_mul_right_of_gcd_one
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd b = 1
⊢ a ∣ c
state_after: a b c : ℤ
habc : a ∣ c * b
hab : a.gcd b = 1
⊢ a ∣ c
tactic: rw [mul_comm] at habc
state_before: a b c : ℤ
habc : a ∣ c * b
hab : a.gcd b = 1
⊢ a ∣ c
state_after: no goals
tactic: exact dvd_of_dvd_mul_left_of_gcd_one habc hab