ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: BoundedContinuousFunction.norm_compContinuous_le
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : SeminormedAddCommGroup β
f✝ g✝ : α →ᵇ β
x : α
C : ℝ
inst✝ : TopologicalSpace γ
f : α →ᵇ β
g : C(γ, α)
⊢ ↑1 * dist f 0 ≤ ‖f‖
state_after: no goals
tactic: rw [NNReal.coe_one, one_mul, dist_zero_right]
Theorem: IsCompactOperator.image_subset_compact_of_isVonNBounded
File: Mathlib/Analysis/Normed/Operator/Compact.lean

Proof steps:
state_before: 𝕜₁ : Type u_1
𝕜₂ : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜₁
inst✝⁷ : SeminormedRing 𝕜₂
σ₁₂ : 𝕜₁ →+* 𝕜₂
M₁ : Type u_3
M₂ : Type u_4
inst✝⁶ : TopologicalSpace M₁
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module 𝕜₁ M₁
inst✝¹ : Module 𝕜₂ M₂
inst✝ : ContinuousConstSMul 𝕜₂ M₂
f : M₁ →ₛₗ[σ₁₂] M₂
hf : IsCompactOperator ⇑f
S : Set M₁
hS : IsVonNBounded 𝕜₁ S
K : Set M₂
hK : IsCompact K
hKf : ⇑f ⁻¹' K ∈ 𝓝 0
r : ℝ
hr : r > 0
hrS : ∀ (c : 𝕜₁), r ≤ ‖c‖ → S ⊆ c • ⇑f ⁻¹' K
c : 𝕜₁
hc : r < ‖c‖
this : c ≠ 0 := ne_zero_of_norm_ne_zero (Ne.symm (LT.lt.ne (LT.lt.trans hr hc)))
⊢ ⇑f '' S ⊆ σ₁₂ c • K
state_after: 𝕜₁ : Type u_1
𝕜₂ : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜₁
inst✝⁷ : SeminormedRing 𝕜₂
σ₁₂ : 𝕜₁ →+* 𝕜₂
M₁ : Type u_3
M₂ : Type u_4
inst✝⁶ : TopologicalSpace M₁
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module 𝕜₁ M₁
inst✝¹ : Module 𝕜₂ M₂
inst✝ : ContinuousConstSMul 𝕜₂ M₂
f : M₁ →ₛₗ[σ₁₂] M₂
hf : IsCompactOperator ⇑f
S : Set M₁
hS : IsVonNBounded 𝕜₁ S
K : Set M₂
hK : IsCompact K
hKf : ⇑f ⁻¹' K ∈ 𝓝 0
r : ℝ
hr : r > 0
hrS : ∀ (c : 𝕜₁), r ≤ ‖c‖ → S ⊆ c • ⇑f ⁻¹' K
c : 𝕜₁
hc : r < ‖c‖
this : c ≠ 0 := ne_zero_of_norm_ne_zero (Ne.symm (LT.lt.ne (LT.lt.trans hr hc)))
⊢ S ⊆ c • ⇑f ⁻¹' K
tactic: rw [image_subset_iff, preimage_smul_setₛₗ _ _ _ f this.isUnit]
state_before: 𝕜₁ : Type u_1
𝕜₂ : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜₁
inst✝⁷ : SeminormedRing 𝕜₂
σ₁₂ : 𝕜₁ →+* 𝕜₂
M₁ : Type u_3
M₂ : Type u_4
inst✝⁶ : TopologicalSpace M₁
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module 𝕜₁ M₁
inst✝¹ : Module 𝕜₂ M₂
inst✝ : ContinuousConstSMul 𝕜₂ M₂
f : M₁ →ₛₗ[σ₁₂] M₂
hf : IsCompactOperator ⇑f
S : Set M₁
hS : IsVonNBounded 𝕜₁ S
K : Set M₂
hK : IsCompact K
hKf : ⇑f ⁻¹' K ∈ 𝓝 0
r : ℝ
hr : r > 0
hrS : ∀ (c : 𝕜₁), r ≤ ‖c‖ → S ⊆ c • ⇑f ⁻¹' K
c : 𝕜₁
hc : r < ‖c‖
this : c ≠ 0 := ne_zero_of_norm_ne_zero (Ne.symm (LT.lt.ne (LT.lt.trans hr hc)))
⊢ S ⊆ c • ⇑f ⁻¹' K
state_after: no goals
tactic: exact hrS c hc.le
Theorem: UpperHalfPlane.IsBoundedAtImInfty.mul
File: Mathlib/Analysis/Complex/UpperHalfPlane/FunctionsBoundedAtInfty.lean

Proof steps:
state_before: f g : ℍ → ℂ
hf : IsBoundedAtImInfty f
hg : IsBoundedAtImInfty g
⊢ IsBoundedAtImInfty (f * g)
state_after: no goals
tactic: simpa only [Pi.one_apply, mul_one, norm_eq_abs] using hf.mul hg
Theorem: WeierstrassCurve.map_Ψ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (W.map f).Ψ n = Polynomial.map (mapRingHom f) (W.Ψ n)
state_after: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (C ((mapRingHom f) (W.preΨ n)) * if Even n then (mapRingHom (mapRingHom f)) W.ψ₂ else 1) =
    (mapRingHom (mapRingHom f)) (C (W.preΨ n) * if Even n then W.ψ₂ else 1)
tactic: simp only [Ψ, map_preΨ, map_ψ₂, ← coe_mapRingHom]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (C ((mapRingHom f) (W.preΨ n)) * if Even n then (mapRingHom (mapRingHom f)) W.ψ₂ else 1) =
    (mapRingHom (mapRingHom f)) (C (W.preΨ n) * if Even n then W.ψ₂ else 1)
state_after: no goals
tactic: map_simp
Theorem: Submodule.sup_set_smul
File: Mathlib/Algebra/Module/Submodule/Pointwise.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s✝ : Set S
N : Submodule R M
s t : Set S
⊢ ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s ⊔ t → n ∈ N → r • n ∈ s • N ⊔ t • N
state_after: case inl
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s✝ : Set S
N : Submodule R M
s t : Set S
r✝ : S
n✝ : M
hr : r✝ ∈ s
hn : n✝ ∈ N
⊢ r✝ • n✝ ∈ s • N ⊔ t • N

case inr
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s✝ : Set S
N : Submodule R M
s t : Set S
r✝ : S
n✝ : M
hr : r✝ ∈ t
hn : n✝ ∈ N
⊢ r✝ • n✝ ∈ s • N ⊔ t • N
tactic: rintro _ _ (hr|hr) hn
Theorem: Filter.iSup_neBot
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
⊢ (⨆ i, f i).NeBot ↔ ∃ i, (f i).NeBot
state_after: no goals
tactic: simp [neBot_iff]
Theorem: DFinsupp.toMultiset_inf
File: Mathlib/Data/DFinsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
f g : Π₀ (_a : α), ℕ
⊢ Multiset.toDFinsupp (toMultiset (f ⊓ g)) = Multiset.toDFinsupp (toMultiset f ∩ toMultiset g)
state_after: no goals
tactic: simp
Theorem: Ordinal.cof_lsub_le
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
⊢ (lsub f).cof ≤ #ι
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
⊢ sInf {a | ∃ ι_1 f_1, lsub f_1 = lsub f ∧ #ι_1 = a} ≤ #ι
tactic: rw [cof_eq_sInf_lsub]
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
⊢ sInf {a | ∃ ι_1 f_1, lsub f_1 = lsub f ∧ #ι_1 = a} ≤ #ι
state_after: no goals
tactic: exact csInf_le' ⟨ι, f, rfl, rfl⟩
Theorem: MeasureTheory.IsFundamentalDomain.measure_zero_of_invariant
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s μ
t : Set α
ht : ∀ (g : G), g • t = t
hts : μ (t ∩ s) = 0
⊢ μ t = 0
state_after: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s μ
t : Set α
ht : ∀ (g : G), g • t = t
hts : μ (t ∩ s) = 0
⊢ ∑' (g : G), μ (g • t ∩ s) = 0
tactic: rw [measure_eq_tsum h]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s μ
t : Set α
ht : ∀ (g : G), g • t = t
hts : μ (t ∩ s) = 0
⊢ ∑' (g : G), μ (g • t ∩ s) = 0
state_after: no goals
tactic: simp [ht, hts]
Theorem: Nat.log_eq_iff
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)
state_after: case inl.intro
b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
hb : 1 < b
hn : n ≠ 0
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)

case inr
b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
hbn : ¬(1 < b ∧ n ≠ 0)
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)
tactic: rcases em (1 < b ∧ n ≠ 0) with (⟨hb, hn⟩ | hbn)
state_before: case inr
b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
hbn : ¬(1 < b ∧ n ≠ 0)
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)
state_after: case inr
b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
hbn : ¬(1 < b ∧ n ≠ 0)
hm : m ≠ 0
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)
tactic: have hm : m ≠ 0 := h.resolve_right hbn
state_before: case inr
b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
hbn : ¬(1 < b ∧ n ≠ 0)
hm : m ≠ 0
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)
state_after: case inr
b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
hbn : b ≤ 1 ∨ n = 0
hm : m ≠ 0
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)
tactic: rw [not_and_or, not_lt, Ne, not_not] at hbn
state_before: case inr
b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
hbn : b ≤ 1 ∨ n = 0
hm : m ≠ 0
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)
state_after: case inr.inl
b m n : ℕ
h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0
hm : m ≠ 0
hb : b ≤ 1
⊢ log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)

case inr.inr
b m : ℕ
hm : m ≠ 0
h : m ≠ 0 ∨ 1 < b ∧ 0 ≠ 0
⊢ log b 0 = m ↔ b ^ m ≤ 0 ∧ 0 < b ^ (m + 1)
tactic: rcases hbn with (hb | rfl)
Theorem: Finset.Ico_union_Ico_eq_Ico
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
hab : a ≤ b
hbc : b ≤ c
⊢ Ico a b ∪ Ico b c = Ico a c
state_after: no goals
tactic: rw [← coe_inj, coe_union, coe_Ico, coe_Ico, coe_Ico, Set.Ico_union_Ico_eq_Ico hab hbc]
Theorem: Finset.orderIsoColex_symm_apply
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Finset ℕ
n : ℕ
⊢ ∀ {a b : ℕ},
    { toFun := fun n => { ofColex := equivBitIndices n }, invFun := fun s => equivBitIndices.symm s.ofColex,
            left_inv := ⋯, right_inv := ⋯ }
          a ≤
        { toFun := fun n => { ofColex := equivBitIndices n }, invFun := fun s => equivBitIndices.symm s.ofColex,
            left_inv := ⋯, right_inv := ⋯ }
          b ↔
      a ≤ b
state_after: no goals
tactic: simp [← (Finset.geomSum_le_geomSum_iff_toColex_le_toColex rfl.le),
    toFinset_bitIndices_twoPowSum]
Theorem: TopCat.GlueData.ofOpenSubsets_toGlueData_t
File: Mathlib/Topology/Gluing.lean

Proof steps:
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ⟨⟨↑↑x, ⋯⟩, ⋯⟩
state_after: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ⟨↑↑x, ⋯⟩
tactic: refine Continuous.subtype_mk ?_ ?_
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ⟨↑↑x, ⋯⟩
state_after: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ↑↑x
tactic: refine Continuous.subtype_mk ?_ ?_
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ↑↑x
state_after: no goals
tactic: continuity
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
⊢ (fun i j => (Opens.map (U i).inclusion).obj (U j)) i i = ⊤
state_after: case h.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ : ↑((Opens.toTopCat (of α)).obj (U i))
⊢ x✝ ∈ ↑((fun i j => (Opens.map (U i).inclusion).obj (U j)) i i) ↔ x✝ ∈ ↑⊤
tactic: ext
state_before: case h.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ : ↑((Opens.toTopCat (of α)).obj (U i))
⊢ x✝ ∈ ↑((fun i j => (Opens.map (U i).inclusion).obj (U j)) i i) ↔ x✝ ∈ ↑⊤
state_after: no goals
tactic: simp
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
⊢ ⇑((fun i j => { toFun := fun x => ⟨⟨↑↑x, ⋯⟩, ⋯⟩, continuous_toFun := ⋯ }) i i) = id
state_after: case h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ :
  ↑((Opens.toTopCat ((fun i => (Opens.toTopCat (of α)).obj (U i)) i)).obj
      ((fun i j => (Opens.map (U i).inclusion).obj (U j)) i i))
⊢ ((fun i j => { toFun := fun x => ⟨⟨↑↑x, ⋯⟩, ⋯⟩, continuous_toFun := ⋯ }) i i) x✝ = id x✝
tactic: ext
state_before: case h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ :
  ↑((Opens.toTopCat ((fun i => (Opens.toTopCat (of α)).obj (U i)) i)).obj
      ((fun i j => (Opens.map (U i).inclusion).obj (U j)) i i))
⊢ ((fun i j => { toFun := fun x => ⟨⟨↑↑x, ⋯⟩, ⋯⟩, continuous_toFun := ⋯ }) i i) x✝ = id x✝
state_after: no goals
tactic: rfl
Theorem: uniq_inv_of_isField
File: Mathlib/Algebra/Field/IsField.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
hf : IsField R
⊢ ∀ (x : R), x ≠ 0 → ∃! y, x * y = 1
state_after: R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∃! y, x * y = 1
tactic: intro x hx
state_before: R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∃! y, x * y = 1
state_after: case hex
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∃ x_1, x * x_1 = 1

case hunique
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∀ (y₁ y₂ : R), x * y₁ = 1 → x * y₂ = 1 → y₁ = y₂
tactic: apply exists_unique_of_exists_of_unique
Theorem: SimpleGraph.map_le_iff_le_comap
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G'✝ : SimpleGraph W
u v : V
f : V ↪ W
G : SimpleGraph V
G' : SimpleGraph W
⊢ G ≤ SimpleGraph.comap (⇑f) G' → SimpleGraph.map f G ≤ G'
state_after: case intro.intro.intro.intro
V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G'✝ : SimpleGraph W
u✝ v✝ : V
f : V ↪ W
G : SimpleGraph V
G' : SimpleGraph W
h : G ≤ SimpleGraph.comap (⇑f) G'
u v : V
ha : G.Adj u v
⊢ G'.Adj (f u) (f v)
tactic: rintro h _ _ ⟨u, v, ha, rfl, rfl⟩
state_before: case intro.intro.intro.intro
V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G'✝ : SimpleGraph W
u✝ v✝ : V
f : V ↪ W
G : SimpleGraph V
G' : SimpleGraph W
h : G ≤ SimpleGraph.comap (⇑f) G'
u v : V
ha : G.Adj u v
⊢ G'.Adj (f u) (f v)
state_after: no goals
tactic: exact h ha
Theorem: mabs_pow
File: Mathlib/Algebra/Order/Group/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b : α
n : ℕ
a : α
⊢ mabs (a ^ n) = mabs a ^ n
state_after: case inl
α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b : α
n : ℕ
a : α
ha : a ≤ 1
⊢ mabs (a ^ n) = mabs a ^ n

case inr
α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b : α
n : ℕ
a : α
ha : 1 ≤ a
⊢ mabs (a ^ n) = mabs a ^ n
tactic: obtain ha | ha := le_total a 1
Theorem: hasCompactMulSupport_comp_left
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
hg : ∀ {x : β}, g x = 1 ↔ x = 1
⊢ HasCompactMulSupport (g ∘ f) ↔ HasCompactMulSupport f
state_after: no goals
tactic: simp_rw [hasCompactMulSupport_def, mulSupport_comp_eq g (@hg) f]
Theorem: MonoidHom.noncommCoprod_comp_inr
File: Mathlib/GroupTheory/NoncommCoprod.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : Monoid P
f : M →* P
g : N →* P
comm : ∀ (m : M) (n : N), Commute (f m) (g n)
x : N
⊢ ((f.noncommCoprod g comm).comp (inr M N)) x = g x
state_after: no goals
tactic: simp
Theorem: Rat.inv_def
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: a : Rat
⊢ a.inv = ↑a.den /. a.num
state_after: a : Rat
⊢ (if h : a.num < 0 then { num := -↑a.den, den := a.num.natAbs, den_nz := ⋯, reduced := ⋯ }
    else if h : a.num > 0 then { num := ↑a.den, den := a.num.natAbs, den_nz := ⋯, reduced := ⋯ } else a) =
    ↑a.den /. a.num
tactic: unfold Rat.inv
state_before: a : Rat
⊢ (if h : a.num < 0 then { num := -↑a.den, den := a.num.natAbs, den_nz := ⋯, reduced := ⋯ }
    else if h : a.num > 0 then { num := ↑a.den, den := a.num.natAbs, den_nz := ⋯, reduced := ⋯ } else a) =
    ↑a.den /. a.num
state_after: case isTrue
a : Rat
h✝ : a.num < 0
⊢ { num := -↑a.den, den := a.num.natAbs, den_nz := ⋯, reduced := ⋯ } = ↑a.den /. a.num

case isFalse
a : Rat
h✝ : ¬a.num < 0
⊢ (if h : a.num > 0 then { num := ↑a.den, den := a.num.natAbs, den_nz := ⋯, reduced := ⋯ } else a) = ↑a.den /. a.num
tactic: split
state_before: case isFalse
a : Rat
h✝ : ¬a.num < 0
⊢ (if h : a.num > 0 then { num := ↑a.den, den := a.num.natAbs, den_nz := ⋯, reduced := ⋯ } else a) = ↑a.den /. a.num
state_after: case isFalse.isTrue
a : Rat
h✝¹ : ¬a.num < 0
h✝ : a.num > 0
⊢ { num := ↑a.den, den := a.num.natAbs, den_nz := ⋯, reduced := ⋯ } = ↑a.den /. a.num

case isFalse.isFalse
a : Rat
h✝¹ : ¬a.num < 0
h✝ : ¬a.num > 0
⊢ a = ↑a.den /. a.num
tactic: split
Theorem: Equiv.Perm.disjoint_prod_right
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
f g h✝ : Perm α
l : List (Perm α)
h : ∀ g ∈ l, f.Disjoint g
⊢ f.Disjoint l.prod
state_after: case nil
α : Type u_1
f g h✝ : Perm α
h : ∀ g ∈ [], f.Disjoint g
⊢ f.Disjoint [].prod

case cons
α : Type u_1
f g✝ h✝ g : Perm α
l : List (Perm α)
ih : (∀ g ∈ l, f.Disjoint g) → f.Disjoint l.prod
h : ∀ g_1 ∈ g :: l, f.Disjoint g_1
⊢ f.Disjoint (g :: l).prod
tactic: induction' l with g l ih
Theorem: List.prod_hom_rel
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝¹ l₁ l₂ : List M
a✝ : M
l✝ : List ι
r : M → N → Prop
f : ι → M
g : ι → N
h₁ : r 1 1
h₂ : ∀ ⦃i : ι⦄ ⦃a : M⦄ ⦃b : N⦄, r a b → r (f i * a) (g i * b)
a : ι
l : List ι
hl : r (map f l).prod (map g l).prod
⊢ r (map f (a :: l)).prod (map g (a :: l)).prod
state_after: no goals
tactic: simp only [map_cons, prod_cons, h₂ hl]
Theorem: dense_compl_of_dimH_lt_finrank
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁶ : EMetricSpace X
inst✝⁵ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s✝ t : Set X
E : Type u_4
F : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
hs : dimH s < ↑(finrank ℝ E)
⊢ Dense sᶜ
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁶ : EMetricSpace X
inst✝⁵ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s✝ t✝ : Set X
E : Type u_4
F : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
hs : dimH s < ↑(finrank ℝ E)
x : E
t : Set E
ht : t ∈ 𝓝 x
he : t ∩ sᶜ = ∅
⊢ ↑(finrank ℝ E) ≤ dimH s
tactic: refine fun x => mem_closure_iff_nhds.2 fun t ht => nonempty_iff_ne_empty.2 fun he => hs.not_le ?_
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁶ : EMetricSpace X
inst✝⁵ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s✝ t✝ : Set X
E : Type u_4
F : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
hs : dimH s < ↑(finrank ℝ E)
x : E
t : Set E
ht : t ∈ 𝓝 x
he : t ∩ sᶜ = ∅
⊢ ↑(finrank ℝ E) ≤ dimH s
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁶ : EMetricSpace X
inst✝⁵ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s✝ t✝ : Set X
E : Type u_4
F : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
hs : dimH s < ↑(finrank ℝ E)
x : E
t : Set E
ht : t ∈ 𝓝 x
he : t ⊆ s
⊢ ↑(finrank ℝ E) ≤ dimH s
tactic: rw [← diff_eq, diff_eq_empty] at he
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁶ : EMetricSpace X
inst✝⁵ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s✝ t✝ : Set X
E : Type u_4
F : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
hs : dimH s < ↑(finrank ℝ E)
x : E
t : Set E
ht : t ∈ 𝓝 x
he : t ⊆ s
⊢ ↑(finrank ℝ E) ≤ dimH s
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁶ : EMetricSpace X
inst✝⁵ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s✝ t✝ : Set X
E : Type u_4
F : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
hs : dimH s < ↑(finrank ℝ E)
x : E
t : Set E
ht : t ∈ 𝓝 x
he : t ⊆ s
⊢ dimH t ≤ dimH s
tactic: rw [← Real.dimH_of_mem_nhds ht]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁶ : EMetricSpace X
inst✝⁵ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s✝ t✝ : Set X
E : Type u_4
F : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
hs : dimH s < ↑(finrank ℝ E)
x : E
t : Set E
ht : t ∈ 𝓝 x
he : t ⊆ s
⊢ dimH t ≤ dimH s
state_after: no goals
tactic: exact dimH_mono he
Theorem: le_map_div_add_map_div
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝⁴ : FunLike F α β
inst✝³ : Group α
inst✝² : AddCommSemigroup β
inst✝¹ : LE β
inst✝ : MulLEAddHomClass F α β
f : F
a b c : α
⊢ f (a / c) ≤ f (a / b) + f (b / c)
state_after: no goals
tactic: simpa only [div_mul_div_cancel'] using map_mul_le_add f (a / b) (b / c)
Theorem: Set.definable_finset_inf
File: Mathlib/ModelTheory/Definability.lean

Proof steps:
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s : Finset ι
⊢ A.Definable L (s.inf f)
state_after: no goals
tactic: classical
    refine Finset.induction definable_univ (fun i s _ h => ?_) s
    rw [Finset.inf_insert]
    exact (hf i).inter h
Theorem: Mathlib.Vector.zipWith_get
File: Mathlib/Data/Vector/Zip.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
f : α → β → γ
x : Vector α n
y : Vector β n
i : Fin n
⊢ (zipWith f x y).get i = f (x.get i) (y.get i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
f : α → β → γ
x : Vector α n
y : Vector β n
i : Fin n
⊢ (List.zipWith f ↑x ↑y).get (Fin.cast ⋯ i) = f ((↑x).get (Fin.cast ⋯ i)) ((↑y).get (Fin.cast ⋯ i))
tactic: dsimp only [Vector.zipWith, Vector.get]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
f : α → β → γ
x : Vector α n
y : Vector β n
i : Fin n
⊢ (List.zipWith f ↑x ↑y).get (Fin.cast ⋯ i) = f ((↑x).get (Fin.cast ⋯ i)) ((↑y).get (Fin.cast ⋯ i))
state_after: no goals
tactic: simp
Theorem: gold_mul_goldConj
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ φ * ψ = -1
state_after: ⊢ (1 + √5) * (1 - √5) = -(2 * 2)
tactic: field_simp
state_before: ⊢ (1 + √5) * (1 - √5) = -(2 * 2)
state_after: ⊢ 1 ^ 2 - √5 ^ 2 = -(2 * 2)
tactic: rw [← sq_sub_sq]
state_before: ⊢ 1 ^ 2 - √5 ^ 2 = -(2 * 2)
state_after: no goals
tactic: norm_num