ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicGeometry.exists_eq_pow_mul_of_isCompact_of_isQuasiSeparated
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean

Proof steps:
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : X.Opens
hU : IsCompact U.carrier
hU' : IsQuasiSeparated U.carrier
f : ↑Γ(X, U)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (y |_ X.basicOpen f) ⋯ = (f |_ X.basicOpen f) ⋯ ^ n * x
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : X.Opens
hU : IsCompact U.carrier
hU' : IsQuasiSeparated U.carrier
f : ↑Γ(X, U)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
tactic: delta TopCat.Presheaf.restrictOpen TopCat.Presheaf.restrict
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : X.Opens
hU : IsCompact U.carrier
hU' : IsQuasiSeparated U.carrier
f : ↑Γ(X, U)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : X.Opens
hU : IsCompact U.carrier
⊢ IsQuasiSeparated U.carrier →
    ∀ (f : ↑Γ(X, U)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
tactic: revert hU' f x
state_before: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : X.Opens
hU : IsCompact U.carrier
⊢ IsQuasiSeparated U.carrier →
    ∀ (f : ↑Γ(X, U)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case refine_1
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : X.Opens
hU : IsCompact U.carrier
⊢ IsQuasiSeparated ⊥.carrier →
    ∀ (f : ↑Γ(X, ⊥)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

case refine_2
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : X.Opens
hU : IsCompact U.carrier
⊢ ∀ (S : X.Opens),
    IsCompact S.carrier →
      ∀ (U : ↑X.affineOpens),
        (IsQuasiSeparated S.carrier →
            ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
              ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x) →
          IsQuasiSeparated (S ⊔ ↑U).carrier →
            ∀ (f : ↑Γ(X, S ⊔ ↑U)) (x : ↑Γ(X, X.basicOpen f)),
              ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
tactic: refine compact_open_induction_on U hU ?_ ?_
Theorem: CategoryTheory.WithTerminal.mapComp_hom_app
File: Mathlib/CategoryTheory/WithTerminal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
E : Type u_2
inst✝¹ : Category.{?u.59505, u_1} D
inst✝ : Category.{?u.59509, u_2} E
F : C ⥤ D
G : D ⥤ E
⊢ ∀ {X Y : WithTerminal C} (f : X ⟶ Y),
    (map (F ⋙ G)).map f ≫
        ((fun X =>
              match X with
              | of x => Iso.refl ((map (F ⋙ G)).obj (of x))
              | star => Iso.refl ((map (F ⋙ G)).obj star))
            Y).hom =
      ((fun X =>
              match X with
              | of x => Iso.refl ((map (F ⋙ G)).obj (of x))
              | star => Iso.refl ((map (F ⋙ G)).obj star))
            X).hom ≫
        (map F ⋙ map G).map f
state_after: no goals
tactic: aesop_cat
Theorem: QuotientAddGroup.quotientKerEquivOfRightInverse_apply
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
φ : G →* H
ψ : H → G
hφ : Function.RightInverse ψ ⇑φ
x : G ⧸ φ.ker
⊢ (kerLift φ) ((mk ∘ ψ) ((kerLift φ) x)) = (kerLift φ) x
state_after: no goals
tactic: rw [Function.comp_apply, kerLift_mk', hφ]
Theorem: Composition.length_pos_of_pos
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c : Composition n
h : 0 < n
⊢ 0 < c.length
state_after: case h
n : ℕ
c : Composition n
h : 0 < n
⊢ 0 < c.blocks.sum
tactic: apply length_pos_of_sum_pos
state_before: case h
n : ℕ
c : Composition n
h : 0 < n
⊢ 0 < c.blocks.sum
state_after: case h.e'_4
n : ℕ
c : Composition n
h : 0 < n
⊢ c.blocks.sum = n
tactic: convert h
state_before: case h.e'_4
n : ℕ
c : Composition n
h : 0 < n
⊢ c.blocks.sum = n
state_after: no goals
tactic: exact c.blocks_sum
Theorem: OrderIso.preimage_Ioc
File: Mathlib/Order/Interval/Set/OrderIso.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
a b : β
⊢ ⇑e ⁻¹' Ioc a b = Ioc (e.symm a) (e.symm b)
state_after: no goals
tactic: simp [← Ioi_inter_Iic]
Theorem: CategoryTheory.monoidalOfHasFiniteProducts.associator_hom_snd_snd
File: Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y Z : C
⊢ (α_ X Y Z).hom ≫ prod.snd ≫ prod.snd = prod.snd
state_after: no goals
tactic: simp [associator_hom]
Theorem: MeasureTheory.Measure.haar.prehaar_pos
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
h1K : IsCompact K
h2K : (interior K).Nonempty
⊢ 0 < prehaar (↑K₀) U { carrier := K, isCompact' := h1K }
state_after: case ha
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
h1K : IsCompact K
h2K : (interior K).Nonempty
⊢ 0 < index (↑{ carrier := K, isCompact' := h1K }) U

case hb
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
h1K : IsCompact K
h2K : (interior K).Nonempty
⊢ 0 < index (↑K₀) U
tactic: apply div_pos <;> norm_cast
Theorem: Fin.prod_univ_four
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 4 → β
⊢ ∏ i : Fin 4, f i = f 0 * f 1 * f 2 * f 3
state_after: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 4 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (last 3) = f 0 * f 1 * f 2 * f 3
tactic: rw [prod_univ_castSucc, prod_univ_three]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 4 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (last 3) = f 0 * f 1 * f 2 * f 3
state_after: no goals
tactic: rfl
Theorem: AddCircle.coe_add_period
File: Mathlib/Topology/Instances/AddCircle.lean

Proof steps:
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedAddCommGroup 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p x : 𝕜
⊢ ↑(x + p) = ↑x
state_after: no goals
tactic: rw [coe_add, ← eq_sub_iff_add_eq', sub_self, coe_period]
Theorem: Matroid.indep_or_dep
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ M.Indep X ∨ M.Dep X
state_after: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ M.Indep X ∨ ¬M.Indep X
tactic: rw [Dep, and_iff_left hX]
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ M.Indep X ∨ ¬M.Indep X
state_after: no goals
tactic: apply em
Theorem: QPF.supp_eq
File: Mathlib/Data/QPF/Univariate/Basic.lean

Proof steps:
state_before: F : Type u → Type u
q : QPF F
α : Type u
x : F α
⊢ supp x = {u | ∀ (a : (P F).A) (f : (P F).B a → α), abs ⟨a, f⟩ = x → u ∈ f '' univ}
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
x : F α
x✝ : α
⊢ x✝ ∈ supp x ↔ x✝ ∈ {u | ∀ (a : (P F).A) (f : (P F).B a → α), abs ⟨a, f⟩ = x → u ∈ f '' univ}
tactic: ext
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
x : F α
x✝ : α
⊢ x✝ ∈ supp x ↔ x✝ ∈ {u | ∀ (a : (P F).A) (f : (P F).B a → α), abs ⟨a, f⟩ = x → u ∈ f '' univ}
state_after: no goals
tactic: apply mem_supp
Theorem: mul_lt_mul_iff_of_le_of_le
File: Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
⊢ a₁ * b₁ < a₂ * b₂ ↔ a₁ < a₂ ∨ b₁ < b₂
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
h : a₁ < a₂ ∨ b₁ < b₂
⊢ a₁ * b₁ < a₂ * b₂
tactic: refine ⟨lt_or_lt_of_mul_lt_mul, fun h => ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
h : a₁ < a₂ ∨ b₁ < b₂
⊢ a₁ * b₁ < a₂ * b₂
state_after: case inl
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
ha' : a₁ < a₂
⊢ a₁ * b₁ < a₂ * b₂

case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
hb' : b₁ < b₂
⊢ a₁ * b₁ < a₂ * b₂
tactic: cases' h with ha' hb'
Theorem: Mathlib.Meta.NormNum.isNat_pow
File: Mathlib/Tactic/NormNum/Pow.lean

Proof steps:
state_before: a b c : ℕ
α : Type u_1
inst✝ : Semiring α
n✝¹ n✝ : ℕ
⊢ ↑n✝¹ ^ ↑n✝ = ↑(n✝¹.pow n✝)
state_after: no goals
tactic: simp
Theorem: _private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.c_nonneg
File: Mathlib/NumberTheory/NumberField/House.lean

Proof steps:
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : DecidableEq (K →+* ℂ)
⊢ 0 ≤ NumberField.house.c K
state_after: K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : DecidableEq (K →+* ℂ)
⊢ 0 ≤ ↑(finrank ℚ K) ∧ 0 ≤ ‖(basisMatrix K)ᵀ⁻¹‖ ∨ ↑(finrank ℚ K) ≤ 0 ∧ ‖(basisMatrix K)ᵀ⁻¹‖ ≤ 0
tactic: rw [c, mul_nonneg_iff]
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : DecidableEq (K →+* ℂ)
⊢ 0 ≤ ↑(finrank ℚ K) ∧ 0 ≤ ‖(basisMatrix K)ᵀ⁻¹‖ ∨ ↑(finrank ℚ K) ≤ 0 ∧ ‖(basisMatrix K)ᵀ⁻¹‖ ≤ 0
state_after: case h
K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : DecidableEq (K →+* ℂ)
⊢ 0 ≤ ↑(finrank ℚ K) ∧ 0 ≤ ‖(basisMatrix K)ᵀ⁻¹‖
tactic: left
state_before: case h
K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : DecidableEq (K →+* ℂ)
⊢ 0 ≤ ↑(finrank ℚ K) ∧ 0 ≤ ‖(basisMatrix K)ᵀ⁻¹‖
state_after: no goals
tactic: exact ⟨by simp only [Nat.cast_nonneg], norm_nonneg ((basisMatrix K).transpose)⁻¹⟩
Theorem: MeasureTheory.L1.integral_neg
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(Lp E 1 μ)
⊢ integral (-f) = -integral f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(Lp E 1 μ)
⊢ integralCLM (-f) = -integralCLM f
tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(Lp E 1 μ)
⊢ integralCLM (-f) = -integralCLM f
state_after: no goals
tactic: exact map_neg integralCLM f
Theorem: RingQuot.ringQuotToIdealQuotient_apply
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝⁵ : Semiring R
S : Type uS
inst✝⁴ : CommSemiring S
T : Type uT
A : Type uA
inst✝³ : Semiring A
inst✝² : Algebra S A
r✝ : R → R → Prop
inst✝¹ : Semiring T
B : Type uR
inst✝ : CommRing B
r : B → B → Prop
x : B
⊢ (ringQuotToIdealQuotient r) ((mkRingHom r) x) = (Ideal.Quotient.mk (Ideal.ofRel r)) x
state_after: R : Type uR
inst✝⁵ : Semiring R
S : Type uS
inst✝⁴ : CommSemiring S
T : Type uT
A : Type uA
inst✝³ : Semiring A
inst✝² : Algebra S A
r✝ : R → R → Prop
inst✝¹ : Semiring T
B : Type uR
inst✝ : CommRing B
r : B → B → Prop
x : B
⊢ ({
          toFun := fun f =>
            { toFun := fun x => Quot.lift ⇑↑f ⋯ x.toQuot, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ },
          invFun := fun F =>
            ⟨F.comp
                { toFun := fun x => { toQuot := Quot.mk (Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
                  map_add' := ⋯ },
              ⋯⟩,
          left_inv := ⋯, right_inv := ⋯ }
        ⟨Ideal.Quotient.mk (Ideal.ofRel r), ⋯⟩)
      ({ toFun := fun x => { toQuot := Quot.mk (Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
          map_add' := ⋯ }
        x) =
    (Ideal.Quotient.mk (Ideal.ofRel r)) x
tactic: simp_rw [ringQuotToIdealQuotient, lift_def, preLift_def, mkRingHom_def]
state_before: R : Type uR
inst✝⁵ : Semiring R
S : Type uS
inst✝⁴ : CommSemiring S
T : Type uT
A : Type uA
inst✝³ : Semiring A
inst✝² : Algebra S A
r✝ : R → R → Prop
inst✝¹ : Semiring T
B : Type uR
inst✝ : CommRing B
r : B → B → Prop
x : B
⊢ ({
          toFun := fun f =>
            { toFun := fun x => Quot.lift ⇑↑f ⋯ x.toQuot, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ },
          invFun := fun F =>
            ⟨F.comp
                { toFun := fun x => { toQuot := Quot.mk (Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
                  map_add' := ⋯ },
              ⋯⟩,
          left_inv := ⋯, right_inv := ⋯ }
        ⟨Ideal.Quotient.mk (Ideal.ofRel r), ⋯⟩)
      ({ toFun := fun x => { toQuot := Quot.mk (Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
          map_add' := ⋯ }
        x) =
    (Ideal.Quotient.mk (Ideal.ofRel r)) x
state_after: no goals
tactic: rfl
Theorem: powCardSubgroup_coe
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
G : Type u_6
inst✝¹ : Group G
inst✝ : Fintype G
S : Set G
hS : S.Nonempty
⊢ 1 ∈ S ^ card G
state_after: case intro
G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
G : Type u_6
inst✝¹ : Group G
inst✝ : Fintype G
S : Set G
a : G
ha : a ∈ S
⊢ 1 ∈ S ^ card G
tactic: obtain ⟨a, ha⟩ := hS
state_before: case intro
G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
G : Type u_6
inst✝¹ : Group G
inst✝ : Fintype G
S : Set G
a : G
ha : a ∈ S
⊢ 1 ∈ S ^ card G
state_after: case intro
G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
G : Type u_6
inst✝¹ : Group G
inst✝ : Fintype G
S : Set G
a : G
ha : a ∈ S
⊢ ?m.411653 ^ card G ∈ S ^ card G

G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
G : Type u_6
inst✝¹ : Group G
inst✝ : Fintype G
S : Set G
a : G
ha : a ∈ S
⊢ G
tactic: rw [← pow_card_eq_one]
state_before: case intro
G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
G : Type u_6
inst✝¹ : Group G
inst✝ : Fintype G
S : Set G
a : G
ha : a ∈ S
⊢ ?m.411653 ^ card G ∈ S ^ card G

G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
G : Type u_6
inst✝¹ : Group G
inst✝ : Fintype G
S : Set G
a : G
ha : a ∈ S
⊢ G
state_after: no goals
tactic: exact Set.pow_mem_pow ha (Fintype.card G)
state_before: G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
G : Type u_6
inst✝¹ : Group G
inst✝ : Fintype G
S : Set G
hS : S.Nonempty
one_mem : 1 ∈ S ^ card G
⊢ S ^ card G * S ^ card G = S ^ card G
state_after: no goals
tactic: classical
    apply (Set.eq_of_subset_of_card_le (Set.subset_mul_left _ one_mem) (ge_of_eq _)).symm
    simp_rw [← pow_add,
        Group.card_pow_eq_card_pow_card_univ S (Fintype.card G + Fintype.card G) le_add_self]
Theorem: Int.associated_iff_natAbs
File: Mathlib/Algebra/GCDMonoid/Nat.lean

Proof steps:
state_before: a b : ℤ
⊢ Associated a b ↔ a.natAbs = b.natAbs
state_after: a b : ℤ
⊢ Associated a.natAbs b.natAbs ↔ a.natAbs = b.natAbs
tactic: rw [← dvd_dvd_iff_associated, ← Int.natAbs_dvd_natAbs, ← Int.natAbs_dvd_natAbs,
    dvd_dvd_iff_associated]
state_before: a b : ℤ
⊢ Associated a.natAbs b.natAbs ↔ a.natAbs = b.natAbs
state_after: no goals
tactic: exact associated_iff_eq
Theorem: MeasureTheory.ProbabilityMeasure.limsup_measure_closed_le_of_tendsto
File: Mathlib/MeasureTheory/Measure/Portmanteau.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
L : Filter ι
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
inst✝ : HasOuterApproxClosed Ω
μ : ProbabilityMeasure Ω
μs : ι → ProbabilityMeasure Ω
μs_lim : Tendsto μs L (𝓝 μ)
F : Set Ω
F_closed : IsClosed F
⊢ limsup (fun i => ↑(μs i) F) L ≤ ↑μ F
state_after: no goals
tactic: apply FiniteMeasure.limsup_measure_closed_le_of_tendsto
    ((ProbabilityMeasure.tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds L).mp μs_lim) F_closed
Theorem: IsLowerSet.erase
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
hs : IsLowerSet s
has : ∀ b ∈ s, a ≤ b → b = a
⊢ ∀ b ∈ s, ∀ c ∈ {a}, c ≤ b → b ∈ {a}
state_after: no goals
tactic: simpa using has
Theorem: HasSum.update
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
⊢ HasProd (Function.update f b a) (a / f b * a₁)
state_after: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
tactic: convert (hasProd_ite_eq b (a / f b)).mul hf with b'
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : b' = b
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : ¬b' = b
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
tactic: by_cases h : b' = b
Theorem: NNReal.rpow_add_rpow_le_add
File: Mathlib/Analysis/MeanInequalitiesPow.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ (a ^ p + b ^ p) ^ (1 / p) ≤ a + b
state_after: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ (a ^ p + b ^ p) ^ p⁻¹ ≤ a + b
tactic: rw [one_div]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ (a ^ p + b ^ p) ^ p⁻¹ ≤ a + b
state_after: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p⁻¹⁻¹
tactic: rw [← @NNReal.le_rpow_inv_iff _ _ p⁻¹ (by simp [lt_of_lt_of_le zero_lt_one hp1])]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p⁻¹⁻¹
state_after: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
tactic: rw [inv_inv]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
state_after: no goals
tactic: exact add_rpow_le_rpow_add _ _ hp1
Theorem: inner_re_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re ⟪x, y⟫_𝕜 = re ⟪y, x⟫_𝕜
state_after: no goals
tactic: rw [← inner_conj_symm, conj_re]
Theorem: FractionalIdeal.coe_ideal_span_singleton_mul_inv
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : R₁
hx : x ≠ 0
⊢ ↑(Ideal.span {x}) * (↑(Ideal.span {x}))⁻¹ = 1
state_after: no goals
tactic: rw [coeIdeal_span_singleton,
    spanSingleton_mul_inv K <|
      (map_ne_zero_iff _ <| NoZeroSMulDivisors.algebraMap_injective R₁ K).mpr hx]
Theorem: Polynomial.eq_one_of_monic_natDegree_zero
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hf : p.Monic
hfd : p.natDegree = 0
⊢ p = 1
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hf : p.coeff 0 = 1
hfd : p.natDegree = 0
⊢ p = 1
tactic: rw [Monic.def, leadingCoeff, hfd] at hf
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hf : p.coeff 0 = 1
hfd : p.natDegree = 0
⊢ p = 1
state_after: no goals
tactic: rw [eq_C_of_natDegree_eq_zero hfd, hf, map_one]
Theorem: Cardinal.prod_eq_two_power
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal.{v}
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift.{u, v} (c i) ≤ lift.{v, u} #ι
⊢ prod c = 2 ^ lift.{v, u} #ι
state_after: ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal.{v}
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift.{u, v} (c i) ≤ lift.{v, u} #ι
⊢ (prod fun i => lift.{u, v} (c i)) = lift.{v, u} (2 ^ #ι)
tactic: rw [← lift_id'.{u, v} (prod.{u, v} c), lift_prod, ← lift_two_power]
state_before: ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal.{v}
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift.{u, v} (c i) ≤ lift.{v, u} #ι
⊢ (prod fun i => lift.{u, v} (c i)) = lift.{v, u} (2 ^ #ι)
state_after: case a
ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal.{v}
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift.{u, v} (c i) ≤ lift.{v, u} #ι
⊢ (prod fun i => lift.{u, v} (c i)) ≤ lift.{v, u} (2 ^ #ι)

case a
ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal.{v}
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift.{u, v} (c i) ≤ lift.{v, u} #ι
⊢ lift.{v, u} (2 ^ #ι) ≤ prod fun i => lift.{u, v} (c i)
tactic: apply le_antisymm