ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ring.descPochhammer_eq_factorial_smul_choose
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n : ℕ
⊢ (descPochhammer ℤ n).smeval r = n.factorial • choose r n
state_after: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n : ℕ
⊢ (ascPochhammer ℤ n).smeval (r + (1 - ↑n).smeval r) = (ascPochhammer ℕ n).smeval (r - ↑n + 1)
tactic: rw [choose, factorial_nsmul_multichoose_eq_ascPochhammer, descPochhammer_eq_ascPochhammer,
    smeval_comp, add_comm_sub, smeval_add, smeval_X, npow_one]
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n : ℕ
⊢ (ascPochhammer ℤ n).smeval (r + (1 - ↑n).smeval r) = (ascPochhammer ℕ n).smeval (r - ↑n + 1)
state_after: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n : ℕ
h : (1 - ↑n).smeval r = 1 - ↑n
⊢ (ascPochhammer ℤ n).smeval (r + (1 - ↑n).smeval r) = (ascPochhammer ℕ n).smeval (r - ↑n + 1)
tactic: have h : smeval (1 - n : Polynomial ℤ) r = 1 - n := by
    rw [← C_eq_natCast, ← C_1, ← C_sub, smeval_C]
    simp only [npow_zero, zsmul_one, Int.cast_sub, Int.cast_one, Int.cast_natCast]
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n : ℕ
h : (1 - ↑n).smeval r = 1 - ↑n
⊢ (ascPochhammer ℤ n).smeval (r + (1 - ↑n).smeval r) = (ascPochhammer ℕ n).smeval (r - ↑n + 1)
state_after: no goals
tactic: rw [h, ascPochhammer_smeval_cast, add_comm_sub]
Theorem: NonUnitalNonAssocRing.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : NonUnitalNonAssocRing R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : NonUnitalNonAssocRing R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : NonUnitalNonAssocRing R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl
Theorem: Function.one_le_extend
File: Mathlib/Algebra/Order/Pi.lean

Proof steps:
state_before: ι : Type u_1
I : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : I → Type u_6
x y : (i : I) → f✝ i
i : I
inst✝¹ : One γ
inst✝ : LE γ
f : α → β
g : α → γ
e : β → γ
hg : 1 ≤ g
he : 1 ≤ e
_b : β
⊢ 1 _b ≤ extend f g e _b
state_after: no goals
tactic: classical exact one_le_dite (fun _ ↦ hg _) (fun _ ↦ he _)
Theorem: Set.encard_le_one_iff
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ s.encard ≤ 1 ↔ ∀ (a b : α), a ∈ s → b ∈ s → a = b
state_after: α : Type u_1
β : Type u_2
s t : Set α
⊢ (s.Nonempty → ∃ x, s = {x}) ↔ ∀ (a b : α), a ∈ s → b ∈ s → a = b
tactic: rw [encard_le_one_iff_eq, or_iff_not_imp_left, ← Ne, ← nonempty_iff_ne_empty]
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ (s.Nonempty → ∃ x, s = {x}) ↔ ∀ (a b : α), a ∈ s → b ∈ s → a = b
state_after: α : Type u_1
β : Type u_2
s t : Set α
h : s.Nonempty → ∃ x, s = {x}
a b : α
has : a ∈ s
hbs : b ∈ s
⊢ a = b
tactic: refine ⟨fun h a b has hbs ↦ ?_,
    fun h ⟨x, hx⟩ ↦ ⟨x, ((singleton_subset_iff.2 hx).antisymm' (fun y hy ↦ h _ _ hy hx))⟩⟩
state_before: α : Type u_1
β : Type u_2
s t : Set α
h : s.Nonempty → ∃ x, s = {x}
a b : α
has : a ∈ s
hbs : b ∈ s
⊢ a = b
state_after: case intro
α : Type u_1
β : Type u_2
t : Set α
a b x : α
h : {x}.Nonempty → ∃ x_1, {x} = {x_1}
has : a ∈ {x}
hbs : b ∈ {x}
⊢ a = b
tactic: obtain ⟨x, rfl⟩ := h ⟨_, has⟩
state_before: case intro
α : Type u_1
β : Type u_2
t : Set α
a b x : α
h : {x}.Nonempty → ∃ x_1, {x} = {x_1}
has : a ∈ {x}
hbs : b ∈ {x}
⊢ a = b
state_after: no goals
tactic: rw [(has : a = x), (hbs : b = x)]
Theorem: NumberField.mixedEmbedding.normAtPlace_smul
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
⊢ (normAtPlace w) (c • x) = |c| * (normAtPlace w) x
state_after: K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
⊢ (if hw : w.IsReal then ‖(c • x).1 ⟨w, hw⟩‖ else ‖(c • x).2 ⟨w, ⋯⟩‖) =
    |c| * if hw : w.IsReal then ‖x.1 ⟨w, hw⟩‖ else ‖x.2 ⟨w, ⋯⟩‖
tactic: rw [normAtPlace, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk]
state_before: K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
⊢ (if hw : w.IsReal then ‖(c • x).1 ⟨w, hw⟩‖ else ‖(c • x).2 ⟨w, ⋯⟩‖) =
    |c| * if hw : w.IsReal then ‖x.1 ⟨w, hw⟩‖ else ‖x.2 ⟨w, ⋯⟩‖
state_after: case pos
K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
h✝ : w.IsReal
⊢ ‖(c • x).1 ⟨w, h✝⟩‖ = |c| * ‖x.1 ⟨w, h✝⟩‖

case neg
K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
h✝ : ¬w.IsReal
⊢ ‖(c • x).2 ⟨w, ⋯⟩‖ = |c| * ‖x.2 ⟨w, ⋯⟩‖
tactic: split_ifs
Theorem: himp_bihimp
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ⇨ b ⇔ c = (a ⊓ c ⇨ b) ⊓ (a ⊓ b ⇨ c)
state_after: no goals
tactic: rw [bihimp, himp_inf_distrib, himp_himp, himp_himp]
Theorem: ZMod.val_unit'
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n : ZMod 0
⊢ IsUnit n ↔ n.val = 1
state_after: n : ZMod 0
⊢ IsUnit n ↔ Int.natAbs n = 1
tactic: simp only [val]
state_before: n : ZMod 0
⊢ IsUnit n ↔ Int.natAbs n = 1
state_after: no goals
tactic: rw [Int.isUnit_iff, Int.natAbs_eq_iff, Nat.cast_one]
Theorem: legendreSym.quadratic_reciprocity'
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean

Proof steps:
state_before: p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q
state_after: case inl
p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
h : p = q
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q

case inr
p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
h : p ≠ q
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q
tactic: rcases eq_or_ne p q with h | h
Theorem: CategoryTheory.Limits.map_lift_equalizerComparison
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
inst✝¹ : HasEqualizer f g
inst✝ : HasEqualizer (G.map f) (G.map g)
Z : C
h : Z ⟶ X
w : h ≫ f = h ≫ g
⊢ G.map h ≫ G.map f = G.map h ≫ G.map g
state_after: no goals
tactic: simp only [← G.map_comp, w]
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
inst✝¹ : HasEqualizer f g
inst✝ : HasEqualizer (G.map f) (G.map g)
Z : C
h : Z ⟶ X
w : h ≫ f = h ≫ g
⊢ G.map (equalizer.lift h w) ≫ equalizerComparison f g G = equalizer.lift (G.map h) ⋯
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
inst✝¹ : HasEqualizer f g
inst✝ : HasEqualizer (G.map f) (G.map g)
Z : C
h : Z ⟶ X
w : h ≫ f = h ≫ g
⊢ (G.map (equalizer.lift h w) ≫ equalizerComparison f g G) ≫ equalizer.ι (G.map f) (G.map g) =
    equalizer.lift (G.map h) ⋯ ≫ equalizer.ι (G.map f) (G.map g)
tactic: apply equalizer.hom_ext
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
inst✝¹ : HasEqualizer f g
inst✝ : HasEqualizer (G.map f) (G.map g)
Z : C
h : Z ⟶ X
w : h ≫ f = h ≫ g
⊢ (G.map (equalizer.lift h w) ≫ equalizerComparison f g G) ≫ equalizer.ι (G.map f) (G.map g) =
    equalizer.lift (G.map h) ⋯ ≫ equalizer.ι (G.map f) (G.map g)
state_after: no goals
tactic: simp [← G.map_comp]
Theorem: MvPolynomial.IsHomogeneous.C_mul
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n : ℕ
hφ : φ.IsHomogeneous m
r : R
⊢ (C r * φ).IsHomogeneous m
state_after: no goals
tactic: simpa only [zero_add] using (isHomogeneous_C _ _).mul hφ
Theorem: EuclideanGeometry.preimage_inversion_sphere_dist_center
File: Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
⊢ inversion c R ⁻¹' sphere y (dist y c) = insert c ↑(perpBisector c (inversion c R y))
state_after: case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x✝ y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
x : P
⊢ x ∈ inversion c R ⁻¹' sphere y (dist y c) ↔ x ∈ insert c ↑(perpBisector c (inversion c R y))
tactic: ext x
state_before: case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x✝ y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
x : P
⊢ x ∈ inversion c R ⁻¹' sphere y (dist y c) ↔ x ∈ insert c ↑(perpBisector c (inversion c R y))
state_after: case h.inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x✝ y : P
R : ℝ
hR : R ≠ 0
x : P
hy : y ≠ x
⊢ x ∈ inversion x R ⁻¹' sphere y (dist y x) ↔ x ∈ insert x ↑(perpBisector x (inversion x R y))

case h.inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x✝ y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
x : P
hx : x ≠ c
⊢ x ∈ inversion c R ⁻¹' sphere y (dist y c) ↔ x ∈ insert c ↑(perpBisector c (inversion c R y))
tactic: rcases eq_or_ne x c with rfl | hx
state_before: case h.inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x✝ y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
x : P
hx : x ≠ c
⊢ x ∈ inversion c R ⁻¹' sphere y (dist y c) ↔ x ∈ insert c ↑(perpBisector c (inversion c R y))
state_after: no goals
tactic: rw [mem_preimage, mem_sphere, ← inversion_mem_perpBisector_inversion_iff hR] <;> simp [*]
Theorem: Module.mk_finrank_eq_card_basis
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι✝ : Type w
ι' : Type w'
inst✝¹ : StrongRankCondition R
inst✝ : Module.Finite R M
ι : Type w
h : Basis ι R M
⊢ ↑(finrank R M) = #ι
state_after: case intro
R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι✝ : Type w
ι' : Type w'
inst✝¹ : StrongRankCondition R
inst✝ : Module.Finite R M
ι : Type w
h : Basis ι R M
val✝ : Fintype ι
⊢ ↑(finrank R M) = #ι
tactic: cases @nonempty_fintype _ (Module.Finite.finite_basis h)
state_before: case intro
R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι✝ : Type w
ι' : Type w'
inst✝¹ : StrongRankCondition R
inst✝ : Module.Finite R M
ι : Type w
h : Basis ι R M
val✝ : Fintype ι
⊢ ↑(finrank R M) = #ι
state_after: no goals
tactic: rw [Cardinal.mk_fintype, finrank_eq_card_basis h]
Theorem: LinearMap.toMvPolynomial_id
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

Proof steps:
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
ι₁ : Type u_4
ι₂ : Type u_5
inst✝⁷ : CommRing R
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Fintype ι₁
inst✝¹ : Finite ι₂
inst✝ : DecidableEq ι₁
b₁ : Basis ι₁ R M₁
b₂ : Basis ι₂ R M₂
⊢ toMvPolynomial b₁ b₁ id = X
state_after: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
ι₁ : Type u_4
ι₂ : Type u_5
inst✝⁷ : CommRing R
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Fintype ι₁
inst✝¹ : Finite ι₂
inst✝ : DecidableEq ι₁
b₁ : Basis ι₁ R M₁
b₂ : Basis ι₂ R M₂
⊢ (fun i => ((toMatrix b₁ b₁) id).toMvPolynomial i) = X
tactic: unfold toMvPolynomial
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
ι₁ : Type u_4
ι₂ : Type u_5
inst✝⁷ : CommRing R
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Fintype ι₁
inst✝¹ : Finite ι₂
inst✝ : DecidableEq ι₁
b₁ : Basis ι₁ R M₁
b₂ : Basis ι₂ R M₂
⊢ (fun i => ((toMatrix b₁ b₁) id).toMvPolynomial i) = X
state_after: no goals
tactic: simp only [toMatrix_id, Matrix.toMvPolynomial_one]
Theorem: Finset.pairwiseDisjoint_vadd_iff
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Mul α
inst✝¹ : IsLeftCancelMul α
inst✝ : DecidableEq α
s✝ t✝ : Finset α
a : α
s : Set α
t : Finset α
⊢ (s.PairwiseDisjoint fun x => x • t) ↔ Set.InjOn (fun p => p.1 * p.2) (s ×ˢ ↑t)
state_after: no goals
tactic: simp_rw [← pairwiseDisjoint_coe, coe_smul_finset, Set.pairwiseDisjoint_smul_iff]
Theorem: IsSelfAdjoint.algebraMap
File: Mathlib/Algebra/Star/Module.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : StarRing R
inst✝³ : Semiring A
inst✝² : StarMul A
inst✝¹ : Algebra R A
inst✝ : StarModule R A
r : R
hr : IsSelfAdjoint r
⊢ IsSelfAdjoint ((algebraMap R A) r)
state_after: no goals
tactic: simpa using congr(algebraMap R A $(hr.star_eq))
Theorem: LinearEquiv.lift_rank_eq
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

Proof steps:
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M ≃ₗ[R] M'
⊢ lift.{v', v} (Module.rank R M) = lift.{v, v'} (Module.rank R M')
state_after: case a
R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M ≃ₗ[R] M'
⊢ lift.{v', v} (Module.rank R M) ≤ lift.{v, v'} (Module.rank R M')

case a
R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M ≃ₗ[R] M'
⊢ lift.{v, v'} (Module.rank R M') ≤ lift.{v', v} (Module.rank R M)
tactic: apply le_antisymm
Theorem: SetTheory.PGame.inv_eq_of_pos
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: x : PGame
h : 0 < x
⊢ x⁻¹ = x.inv'
state_after: no goals
tactic: classical exact (if_neg h.lf.not_equiv').trans (if_pos h)
Theorem: hasCompactMulSupport_def
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 : α
⊢ HasCompactMulSupport f ↔ IsCompact (closure (mulSupport f))
state_after: no goals
tactic: rfl
Theorem: Filter.iSup_join
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 α
ι : Sort w
f : ι → Filter (Filter α)
x : Set α
⊢ x ∈ ⨆ x, (f x).join ↔ x ∈ (⨆ x, f x).join
state_after: no goals
tactic: simp only [mem_iSup, mem_join]
Theorem: bihimp_bihimp_cancel_right
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ b ⇔ a ⇔ a = b
state_after: no goals
tactic: simp [bihimp_assoc]
Theorem: CategoryTheory.Limits.colimit.pre_map'
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α✝ : F✝ ⟶ G
inst✝ : HasColimitsOfShape K C
F : J ⥤ C
E₁ E₂ : K ⥤ J
α : E₁ ⟶ E₂
⊢ pre F E₁ = colim.map (whiskerRight α F) ≫ pre F E₂
state_after: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α✝ : F✝ ⟶ G
inst✝ : HasColimitsOfShape K C
F : J ⥤ C
E₁ E₂ : K ⥤ J
α : E₁ ⟶ E₂
j✝ : K
⊢ ι (E₁ ⋙ F) j✝ ≫ pre F E₁ = ι (E₁ ⋙ F) j✝ ≫ colim.map (whiskerRight α F) ≫ pre F E₂
tactic: ext1
state_before: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α✝ : F✝ ⟶ G
inst✝ : HasColimitsOfShape K C
F : J ⥤ C
E₁ E₂ : K ⥤ J
α : E₁ ⟶ E₂
j✝ : K
⊢ ι (E₁ ⋙ F) j✝ ≫ pre F E₁ = ι (E₁ ⋙ F) j✝ ≫ colim.map (whiskerRight α F) ≫ pre F E₂
state_after: no goals
tactic: simp [← assoc, assoc]
Theorem: CategoryTheory.Limits.Cone.fromCostructuredArrow_obj_pt
File: Mathlib/CategoryTheory/Limits/ConeCategory.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : CostructuredArrow (const J) F
f : X✝ ⟶ Y✝
j : J
⊢ f.left ≫ ((fun c => { pt := c.left, π := c.hom }) Y✝).π.app j = ((fun c => { pt := c.left, π := c.hom }) X✝).π.app j
state_after: case h.e'_3.h.h.e'_7.h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : CostructuredArrow (const J) F
f : X✝ ⟶ Y✝
j : J
e_1✝ :
  (((fun c => { pt := c.left, π := c.hom }) X✝).pt ⟶ F.obj j) =
    (((const J).obj X✝.left).obj j ⟶ ((fromPUnit F).obj Y✝.right).obj j)
e_6✝ : F = (fromPUnit F).obj Y✝.right
⊢ ((fun c => { pt := c.left, π := c.hom }) X✝).π = X✝.hom ≫ (fromPUnit F).map f.right
tactic: convert congr_fun (congr_arg NatTrans.app f.w) j
state_before: case h.e'_3.h.h.e'_7.h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : CostructuredArrow (const J) F
f : X✝ ⟶ Y✝
j : J
e_1✝ :
  (((fun c => { pt := c.left, π := c.hom }) X✝).pt ⟶ F.obj j) =
    (((const J).obj X✝.left).obj j ⟶ ((fromPUnit F).obj Y✝.right).obj j)
e_6✝ : F = (fromPUnit F).obj Y✝.right
⊢ ((fun c => { pt := c.left, π := c.hom }) X✝).π = X✝.hom ≫ (fromPUnit F).map f.right
state_after: case h.e'_3.h.h.e'_7.h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : CostructuredArrow (const J) F
f : X✝ ⟶ Y✝
j : J
e_1✝ :
  (((fun c => { pt := c.left, π := c.hom }) X✝).pt ⟶ F.obj j) =
    (((const J).obj X✝.left).obj j ⟶ ((fromPUnit F).obj Y✝.right).obj j)
e_6✝ : F = (fromPUnit F).obj Y✝.right
⊢ X✝.hom = X✝.hom ≫ 𝟙 F
tactic: dsimp
state_before: case h.e'_3.h.h.e'_7.h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : CostructuredArrow (const J) F
f : X✝ ⟶ Y✝
j : J
e_1✝ :
  (((fun c => { pt := c.left, π := c.hom }) X✝).pt ⟶ F.obj j) =
    (((const J).obj X✝.left).obj j ⟶ ((fromPUnit F).obj Y✝.right).obj j)
e_6✝ : F = (fromPUnit F).obj Y✝.right
⊢ X✝.hom = X✝.hom ≫ 𝟙 F
state_after: no goals
tactic: simp
Theorem: IsCauSeq.geo_series_const
File: Mathlib/Algebra/Order/CauSeq/BigOperators.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : LinearOrderedField α
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
f g : ℕ → β
a✝ : ℕ → α
inst✝ : Archimedean α
a x : α
hx1 : |x| < 1
⊢ IsCauSeq abs fun m => ∑ n ∈ range m, a * x ^ n
state_after: no goals
tactic: simpa [mul_sum, Pi.mul_def] using (const a).mul (geo_series x hx1)
Theorem: GaussianInt.normSq_le_normSq_of_re_le_of_im_le
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x y : ℂ
hre : |x.re| ≤ |y.re|
him : |x.im| ≤ |y.im|
⊢ normSq x ≤ normSq y
state_after: x y : ℂ
hre : |x.re| ≤ |y.re|
him : |x.im| ≤ |y.im|
⊢ |x.re| * |x.re| + |x.im| * |x.im| ≤ |y.re| * |y.re| + |y.im| * |y.im|
tactic: rw [normSq_apply, normSq_apply, ← _root_.abs_mul_self, _root_.abs_mul, ←
      _root_.abs_mul_self y.re, _root_.abs_mul y.re, ← _root_.abs_mul_self x.im,
      _root_.abs_mul x.im, ← _root_.abs_mul_self y.im, _root_.abs_mul y.im]
state_before: x y : ℂ
hre : |x.re| ≤ |y.re|
him : |x.im| ≤ |y.im|
⊢ |x.re| * |x.re| + |x.im| * |x.im| ≤ |y.re| * |y.re| + |y.im| * |y.im|
state_after: no goals
tactic: exact
      add_le_add (mul_self_le_mul_self (abs_nonneg _) hre) (mul_self_le_mul_self (abs_nonneg _) him)
Theorem: List.foldr_hom₂
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
l : List ι
f : α → β → γ
op₁ : ι → α → α
op₂ : ι → β → β
op₃ : ι → γ → γ
a : α
b : β
h : ∀ (a : α) (b : β) (i : ι), f (op₁ i a) (op₂ i b) = op₃ i (f a b)
⊢ foldr op₃ (f a b) l = f (foldr op₁ a l) (foldr op₂ b l)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
l : List ι
f : α → β → γ
op₁ : ι → α → α
op₂ : ι → β → β
op₃ : ι → γ → γ
b : β
h : ∀ (a : α) (b : β) (i : ι), f (op₁ i a) (op₂ i b) = op₃ i (f a b)
⊢ ∀ (a : α), foldr op₃ (f a b) l = f (foldr op₁ a l) (foldr op₂ b l)
tactic: revert a
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
l : List ι
f : α → β → γ
op₁ : ι → α → α
op₂ : ι → β → β
op₃ : ι → γ → γ
b : β
h : ∀ (a : α) (b : β) (i : ι), f (op₁ i a) (op₂ i b) = op₃ i (f a b)
⊢ ∀ (a : α), foldr op₃ (f a b) l = f (foldr op₁ a l) (foldr op₂ b l)
state_after: no goals
tactic: induction l <;> intros <;> [rfl; simp only [*, foldr]]
Theorem: EReal.toReal_sub
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : EReal
hx : x ≠ ⊤
h'x : x ≠ ⊥
hy : y ≠ ⊤
h'y : y ≠ ⊥
⊢ (x - y).toReal = x.toReal - y.toReal
state_after: case intro
y : EReal
hy : y ≠ ⊤
h'y : y ≠ ⊥
x : ℝ
hx : ↑x ≠ ⊤
h'x : ↑x ≠ ⊥
⊢ (↑x - y).toReal = (↑x).toReal - y.toReal
tactic: lift x to ℝ using ⟨hx, h'x⟩
state_before: case intro
y : EReal
hy : y ≠ ⊤
h'y : y ≠ ⊥
x : ℝ
hx : ↑x ≠ ⊤
h'x : ↑x ≠ ⊥
⊢ (↑x - y).toReal = (↑x).toReal - y.toReal
state_after: case intro.intro
x : ℝ
hx : ↑x ≠ ⊤
h'x : ↑x ≠ ⊥
y : ℝ
hy : ↑y ≠ ⊤
h'y : ↑y ≠ ⊥
⊢ (↑x - ↑y).toReal = (↑x).toReal - (↑y).toReal
tactic: lift y to ℝ using ⟨hy, h'y⟩
state_before: case intro.intro
x : ℝ
hx : ↑x ≠ ⊤
h'x : ↑x ≠ ⊥
y : ℝ
hy : ↑y ≠ ⊤
h'y : ↑y ≠ ⊥
⊢ (↑x - ↑y).toReal = (↑x).toReal - (↑y).toReal
state_after: no goals
tactic: rfl
Theorem: List.rdrop_append_of_le_length
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
l₁ l₂ : List α
k : ℕ
⊢ k ≤ l₂.length → (l₁ ++ l₂).rdrop k = l₁ ++ l₂.rdrop k
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
l₁ l₂ : List α
k : ℕ
hk : k ≤ l₂.length
⊢ (l₁ ++ l₂).rdrop k = l₁ ++ l₂.rdrop k
tactic: intro hk
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
l₁ l₂ : List α
k : ℕ
hk : k ≤ l₂.length
⊢ (l₁ ++ l₂).rdrop k = l₁ ++ l₂.rdrop k
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
l₁ l₂ : List α
k : ℕ
hk : k ≤ l₂.reverse.length
⊢ (l₁ ++ l₂).rdrop k = l₁ ++ l₂.rdrop k
tactic: rw [← length_reverse] at hk
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
l₁ l₂ : List α
k : ℕ
hk : k ≤ l₂.reverse.length
⊢ (l₁ ++ l₂).rdrop k = l₁ ++ l₂.rdrop k
state_after: no goals
tactic: rw [rdrop_eq_reverse_drop_reverse, reverse_append, drop_append_of_le_length hk,
    reverse_append, reverse_reverse, ← rdrop_eq_reverse_drop_reverse]