ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.chainHeight_le_chainHeight_TFAE
File: Mathlib/Order/Height.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
⊢ [s.chainHeight ≤ t.chainHeight, ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length,
      ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length].TFAE
state_after: case tfae_1_iff_3
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
⊢ s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length

α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 : s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length
⊢ [s.chainHeight ≤ t.chainHeight, ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length,
      ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length].TFAE
tactic: tfae_have 1 ↔ 3
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 : s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length
⊢ [s.chainHeight ≤ t.chainHeight, ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length,
      ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length].TFAE
state_after: case tfae_2_iff_3
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 : s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length
⊢ (∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length) ↔
    ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length

α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 : s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length
tfae_2_iff_3 :
  (∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length) ↔
    ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length
⊢ [s.chainHeight ≤ t.chainHeight, ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length,
      ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length].TFAE
tactic: tfae_have 2 ↔ 3
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 : s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length
tfae_2_iff_3 :
  (∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length) ↔
    ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length
⊢ [s.chainHeight ≤ t.chainHeight, ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length,
      ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length].TFAE
state_after: no goals
tactic: tfae_finish
Theorem: HomogeneousLocalization.val_nsmul
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁹ : AddCommMonoid ι
inst✝⁸ : DecidableEq ι
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : Algebra R A
𝒜 : ι → Submodule R A
inst✝⁴ : GradedAlgebra 𝒜
x : Submonoid A
α : Type u_4
inst✝³ : SMul α R
inst✝² : SMul α A
inst✝¹ : IsScalarTower α R A
inst✝ : IsScalarTower α A A
n : ℕ
y : HomogeneousLocalization 𝒜 x
⊢ (n • y).val = n • y.val
state_after: no goals
tactic: rw [val_smul, OreLocalization.nsmul_eq_nsmul]
Theorem: MeasureTheory.Lp.simpleFunc.toSimpleFunc_eq_toFun
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : ↥(simpleFunc E p μ)
⊢ ↑(toSimpleFunc f) =ᶠ[ae μ] ↑↑↑f
state_after: case h.e'_5.h.e'_6
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : ↥(simpleFunc E p μ)
⊢ ↑↑f = AEEqFun.mk ↑(toSimpleFunc f) ⋯
tactic: convert (AEEqFun.coeFn_mk (toSimpleFunc f)
          (toSimpleFunc f).aestronglyMeasurable).symm using 2
state_before: case h.e'_5.h.e'_6
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : ↥(simpleFunc E p μ)
⊢ ↑↑f = AEEqFun.mk ↑(toSimpleFunc f) ⋯
state_after: no goals
tactic: exact (Classical.choose_spec f.2).symm
Theorem: List.nodupKeys_dedupKeys
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
⊢ l.dedupKeys.NodupKeys
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
⊢ (foldr (fun x => kinsert x.fst x.snd) [] l).NodupKeys
tactic: dsimp [dedupKeys]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
⊢ (foldr (fun x => kinsert x.fst x.snd) [] l).NodupKeys
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
l' : List (Sigma β)
hl : [] = l'
⊢ (foldr (fun x => kinsert x.fst x.snd) l' l).NodupKeys
tactic: generalize hl : nil = l'
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
l' : List (Sigma β)
hl : [] = l'
⊢ (foldr (fun x => kinsert x.fst x.snd) l' l).NodupKeys
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
l' : List (Sigma β)
hl : [] = l'
this : l'.NodupKeys
⊢ (foldr (fun x => kinsert x.fst x.snd) l' l).NodupKeys
tactic: have : NodupKeys l' := by
    rw [← hl]
    apply nodup_nil
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
l' : List (Sigma β)
hl : [] = l'
this : l'.NodupKeys
⊢ (foldr (fun x => kinsert x.fst x.snd) l' l).NodupKeys
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
l' : List (Sigma β)
this : l'.NodupKeys
⊢ (foldr (fun x => kinsert x.fst x.snd) l' l).NodupKeys
tactic: clear hl
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l : List (Sigma β)
l' : List (Sigma β)
this : l'.NodupKeys
⊢ (foldr (fun x => kinsert x.fst x.snd) l' l).NodupKeys
state_after: case nil
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l' : List (Sigma β)
this : l'.NodupKeys
⊢ (foldr (fun x => kinsert x.fst x.snd) l' []).NodupKeys

case cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l' : List (Sigma β)
this : l'.NodupKeys
x : Sigma β
xs : List (Sigma β)
l_ih : (foldr (fun x => kinsert x.fst x.snd) l' xs).NodupKeys
⊢ (foldr (fun x => kinsert x.fst x.snd) l' (x :: xs)).NodupKeys
tactic: induction' l with x xs l_ih
Theorem: groupCohomology.twoCocycles_ρ_map_inv_sub_map_inv
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
⊢ (A.ρ g) (↑f (g⁻¹, g)) - ↑f (g, g⁻¹) = ↑f (1, 1) - ↑f (g, 1)
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : ↑f (g * g⁻¹, g) + ↑f (g, g⁻¹) = (A.ρ g) (↑f (g⁻¹, g)) + ↑f (g, g⁻¹ * g)
⊢ (A.ρ g) (↑f (g⁻¹, g)) - ↑f (g, g⁻¹) = ↑f (1, 1) - ↑f (g, 1)
tactic: have := (mem_twoCocycles_iff f.1).1 f.2 g g⁻¹ g
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : ↑f (g * g⁻¹, g) + ↑f (g, g⁻¹) = (A.ρ g) (↑f (g⁻¹, g)) + ↑f (g, g⁻¹ * g)
⊢ (A.ρ g) (↑f (g⁻¹, g)) - ↑f (g, g⁻¹) = ↑f (1, 1) - ↑f (g, 1)
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : ↑f (1, 1) + ↑f (g, g⁻¹) = (A.ρ g) (↑f (g⁻¹, g)) + ↑f (g, 1)
⊢ (A.ρ g) (↑f (g⁻¹, g)) - ↑f (g, g⁻¹) = ↑f (1, 1) - ↑f (g, 1)
tactic: simp only [mul_right_inv, mul_left_inv, twoCocycles_map_one_fst _ g]
    at this
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : ↑f (1, 1) + ↑f (g, g⁻¹) = (A.ρ g) (↑f (g⁻¹, g)) + ↑f (g, 1)
⊢ (A.ρ g) (↑f (g⁻¹, g)) - ↑f (g, g⁻¹) = ↑f (1, 1) - ↑f (g, 1)
state_after: no goals
tactic: exact sub_eq_sub_iff_add_eq_add.2 this.symm
Theorem: CategoryTheory.Limits.Fork.hom_comp_ι
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
s t : Fork f✝ g
f : s ⟶ t
⊢ f.hom ≫ t.ι = s.ι
state_after: case mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
t : Fork f✝ g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f✝ g
f : { pt := pt✝, π := π✝ } ⟶ t
⊢ f.hom ≫ t.ι = ι { pt := pt✝, π := π✝ }
tactic: cases s
state_before: case mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
t : Fork f✝ g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f✝ g
f : { pt := pt✝, π := π✝ } ⟶ t
⊢ f.hom ≫ t.ι = ι { pt := pt✝, π := π✝ }
state_after: case mk.mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
pt✝¹ : C
π✝¹ : (Functor.const WalkingParallelPair).obj pt✝¹ ⟶ parallelPair f✝ g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f✝ g
f : { pt := pt✝¹, π := π✝¹ } ⟶ { pt := pt✝, π := π✝ }
⊢ f.hom ≫ ι { pt := pt✝, π := π✝ } = ι { pt := pt✝¹, π := π✝¹ }
tactic: cases t
state_before: case mk.mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
pt✝¹ : C
π✝¹ : (Functor.const WalkingParallelPair).obj pt✝¹ ⟶ parallelPair f✝ g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f✝ g
f : { pt := pt✝¹, π := π✝¹ } ⟶ { pt := pt✝, π := π✝ }
⊢ f.hom ≫ ι { pt := pt✝, π := π✝ } = ι { pt := pt✝¹, π := π✝¹ }
state_after: case mk.mk.mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
pt✝¹ : C
π✝¹ : (Functor.const WalkingParallelPair).obj pt✝¹ ⟶ parallelPair f g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f g
hom✝ : { pt := pt✝¹, π := π✝¹ }.pt ⟶ { pt := pt✝, π := π✝ }.pt
w✝ : ∀ (j : WalkingParallelPair), hom✝ ≫ { pt := pt✝, π := π✝ }.π.app j = { pt := pt✝¹, π := π✝¹ }.π.app j
⊢ { hom := hom✝, w := w✝ }.hom ≫ ι { pt := pt✝, π := π✝ } = ι { pt := pt✝¹, π := π✝¹ }
tactic: cases f
state_before: case mk.mk.mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
pt✝¹ : C
π✝¹ : (Functor.const WalkingParallelPair).obj pt✝¹ ⟶ parallelPair f g
pt✝ : C
π✝ : (Functor.const WalkingParallelPair).obj pt✝ ⟶ parallelPair f g
hom✝ : { pt := pt✝¹, π := π✝¹ }.pt ⟶ { pt := pt✝, π := π✝ }.pt
w✝ : ∀ (j : WalkingParallelPair), hom✝ ≫ { pt := pt✝, π := π✝ }.π.app j = { pt := pt✝¹, π := π✝¹ }.π.app j
⊢ { hom := hom✝, w := w✝ }.hom ≫ ι { pt := pt✝, π := π✝ } = ι { pt := pt✝¹, π := π✝¹ }
state_after: no goals
tactic: aesop
Theorem: EuclideanGeometry.oangle_right_eq_arctan_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.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
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ ∡ p₂ p₃ p₁ = ↑(Real.arctan (dist p₁ p₂ / dist p₃ p₂))
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ ∡ p₂ p₃ p₁ = ↑(Real.arctan (dist p₁ p₂ / dist p₃ p₂))
tactic: have hs : (∡ p₂ p₃ p₁).sign = 1 := by rw [oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ ∡ p₂ p₃ p₁ = ↑(Real.arctan (dist p₁ p₂ / dist p₃ p₂))
state_after: no goals
tactic: rw [oangle_eq_angle_of_sign_eq_one hs,
    angle_eq_arctan_of_angle_eq_pi_div_two (angle_eq_pi_div_two_of_oangle_eq_pi_div_two h)
      (right_ne_of_oangle_eq_pi_div_two h)]
Theorem: Polynomial.taylor_eval
File: Mathlib/Algebra/Polynomial/Taylor.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommSemiring R
r : R
f : R[X]
s : R
⊢ eval s ((taylor r) f) = eval (s + r) f
state_after: no goals
tactic: simp only [taylor_apply, eval_comp, eval_C, eval_X, eval_add]
Theorem: PresheafOfModules.isSheaf_of_isLimit
File: Mathlib/Algebra/Category/ModuleCat/Sheaf/Limits.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
R : Cᵒᵖ ⥤ RingCat
F : D ⥤ PresheafOfModules R
inst✝¹ : ∀ (X : Cᵒᵖ), Small.{v, max u₂ v} ↑((F ⋙ evaluation R X) ⋙ forget (ModuleCat ↑(R.obj X))).sections
c : Cone F
hc : IsLimit c
hF : ∀ (j : D), Presheaf.IsSheaf J (F.obj j).presheaf
inst✝ : HasLimitsOfShape D AddCommGrp
⊢ Presheaf.IsSheaf J c.pt.presheaf
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
R : Cᵒᵖ ⥤ RingCat
F : D ⥤ PresheafOfModules R
inst✝¹ : ∀ (X : Cᵒᵖ), Small.{v, max u₂ v} ↑((F ⋙ evaluation R X) ⋙ forget (ModuleCat ↑(R.obj X))).sections
c : Cone F
hc : IsLimit c
hF : ∀ (j : D), Presheaf.IsSheaf J (F.obj j).presheaf
inst✝ : HasLimitsOfShape D AddCommGrp
G : D ⥤ Sheaf J AddCommGrp :=
  { obj := fun j => { val := (F.obj j).presheaf, cond := ⋯ },
    map := fun {X Y} φ => { val := (toPresheaf R).map (F.map φ) }, map_id := ⋯, map_comp := ⋯ }
⊢ Presheaf.IsSheaf J c.pt.presheaf
tactic: let G : D ⥤ Sheaf J AddCommGrp.{v} :=
    { obj := fun j => ⟨(F.obj j).presheaf, hF j⟩
      map := fun φ => ⟨(PresheafOfModules.toPresheaf R).map (F.map φ)⟩ }
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
R : Cᵒᵖ ⥤ RingCat
F : D ⥤ PresheafOfModules R
inst✝¹ : ∀ (X : Cᵒᵖ), Small.{v, max u₂ v} ↑((F ⋙ evaluation R X) ⋙ forget (ModuleCat ↑(R.obj X))).sections
c : Cone F
hc : IsLimit c
hF : ∀ (j : D), Presheaf.IsSheaf J (F.obj j).presheaf
inst✝ : HasLimitsOfShape D AddCommGrp
G : D ⥤ Sheaf J AddCommGrp :=
  { obj := fun j => { val := (F.obj j).presheaf, cond := ⋯ },
    map := fun {X Y} φ => { val := (toPresheaf R).map (F.map φ) }, map_id := ⋯, map_comp := ⋯ }
⊢ Presheaf.IsSheaf J c.pt.presheaf
state_after: no goals
tactic: exact Sheaf.isSheaf_of_isLimit G _ (isLimitOfPreserves (toPresheaf R) hc)
Theorem: Equiv.Perm.subtypeCongr.trans
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
⊢ Equiv.trans (ep.subtypeCongr en) (ep'.subtypeCongr en') = subtypeCongr (Equiv.trans ep ep') (Equiv.trans en en')
state_after: case H
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
⊢ (Equiv.trans (ep.subtypeCongr en) (ep'.subtypeCongr en')) x =
    (subtypeCongr (Equiv.trans ep ep') (Equiv.trans en en')) x
tactic: ext x
state_before: case H
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
⊢ (Equiv.trans (ep.subtypeCongr en) (ep'.subtypeCongr en')) x =
    (subtypeCongr (Equiv.trans ep ep') (Equiv.trans en en')) x
state_after: case pos
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
h : p x
⊢ (Equiv.trans (ep.subtypeCongr en) (ep'.subtypeCongr en')) x =
    (subtypeCongr (Equiv.trans ep ep') (Equiv.trans en en')) x

case neg
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
h : ¬p x
⊢ (Equiv.trans (ep.subtypeCongr en) (ep'.subtypeCongr en')) x =
    (subtypeCongr (Equiv.trans ep ep') (Equiv.trans en en')) x
tactic: by_cases h : p x
Theorem: Complex.abs_mul_cos_add_sin_mul_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x : ℂ
⊢ ↑(abs x) * (cos ↑x.arg + sin ↑x.arg * I) = x
state_after: no goals
tactic: rw [← exp_mul_I, abs_mul_exp_arg_mul_I]
Theorem: Multiset.sym2_eq_zero_iff
File: Mathlib/Data/Multiset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Multiset α
xs : List α
⊢ Multiset.sym2 ⟦xs⟧ = 0 ↔ ⟦xs⟧ = 0
state_after: no goals
tactic: simp
Theorem: MvPowerSeries.invOfUnit_mul
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : (constantCoeff σ R) φ = ↑u
⊢ φ.invOfUnit u * φ = 1
state_after: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : (constantCoeff σ R) φ = ↑u
⊢ φ.invOfUnit u ∈ nonZeroDivisors (MvPowerSeries σ R)
tactic: rw [← mul_cancel_right_mem_nonZeroDivisors (r := φ.invOfUnit u), mul_assoc, one_mul,
    mul_invOfUnit _ _ h, mul_one]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : (constantCoeff σ R) φ = ↑u
⊢ φ.invOfUnit u ∈ nonZeroDivisors (MvPowerSeries σ R)
state_after: case hφ
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : (constantCoeff σ R) φ = ↑u
⊢ (constantCoeff σ R) (φ.invOfUnit u) ∈ nonZeroDivisors R
tactic: apply mem_nonZeroDivisors_of_constantCoeff
state_before: case hφ
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : (constantCoeff σ R) φ = ↑u
⊢ (constantCoeff σ R) (φ.invOfUnit u) ∈ nonZeroDivisors R
state_after: no goals
tactic: simp only [constantCoeff_invOfUnit, IsUnit.mem_nonZeroDivisors (Units.isUnit u⁻¹)]
Theorem: Multiset.strongDownwardInduction_eq
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : Multiset α → Sort u_3
n : ℕ
H : (t₁ : Multiset α) → ({t₂ : Multiset α} → card t₂ ≤ n → t₁ < t₂ → p t₂) → card t₁ ≤ n → p t₁
s : Multiset α
⊢ strongDownwardInduction H s = H s fun {t₂} ht _hst => strongDownwardInduction H t₂ ht
state_after: no goals
tactic: rw [strongDownwardInduction]
Theorem: RingHom.isIntegral_stableUnderComposition
File: Mathlib/RingTheory/RingHom/Integral.lean

Proof steps:
state_before: ⊢ StableUnderComposition fun {R S} [CommRing R] [CommRing S] f => f.IsIntegral
state_after: R S T : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
f : R →+* S
g : S →+* T
hf : f.IsIntegral
hg : g.IsIntegral
⊢ (g.comp f).IsIntegral
tactic: introv R hf hg
state_before: R S T : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
f : R →+* S
g : S →+* T
hf : f.IsIntegral
hg : g.IsIntegral
⊢ (g.comp f).IsIntegral
state_after: no goals
tactic: exact hf.trans _ _ hg
Theorem: uniformEquicontinuousOn_iInf_rng
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace α'
F : ι → β → α'
S : Set β
⊢ UniformEquicontinuousOn F S ↔ ∀ (k : κ), UniformEquicontinuousOn F S
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace α'
F : ι → β → α'
S : Set β
⊢ UniformContinuousOn (⇑UniformFun.ofFun ∘ swap F) S ↔ ∀ (k : κ), UniformContinuousOn (⇑UniformFun.ofFun ∘ swap F) S
tactic: simp_rw [uniformEquicontinuousOn_iff_uniformContinuousOn (uα := _)]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace α'
F : ι → β → α'
S : Set β
⊢ UniformContinuousOn (⇑UniformFun.ofFun ∘ swap F) S ↔ ∀ (k : κ), UniformContinuousOn (⇑UniformFun.ofFun ∘ swap F) S
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace α'
F : ι → β → α'
S : Set β
⊢ Tendsto (fun x => ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2)) (𝓤 β ⊓ 𝓟 (S ×ˢ S))
      (𝓤 (ι →ᵤ α')) ↔
    ∀ (k : κ),
      Tendsto (fun x => ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2)) (𝓤 β ⊓ 𝓟 (S ×ˢ S))
        (𝓤 (ι →ᵤ α'))
tactic: unfold UniformContinuousOn
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace α'
F : ι → β → α'
S : Set β
⊢ Tendsto (fun x => ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2)) (𝓤 β ⊓ 𝓟 (S ×ˢ S))
      (𝓤 (ι →ᵤ α')) ↔
    ∀ (k : κ),
      Tendsto (fun x => ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2)) (𝓤 β ⊓ 𝓟 (S ×ˢ S))
        (𝓤 (ι →ᵤ α'))
state_after: no goals
tactic: rw [UniformFun.iInf_eq, iInf_uniformity, tendsto_iInf]
Theorem: Zspan.coe_fract_self
File: Mathlib/Algebra/Module/Zlattice/Basic.lean

Proof steps:
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Fintype ι
inst✝ : Unique ι
k : K
x✝ : ?m.169717
⊢ (?m.169723.repr (fract (Basis.singleton ι K) k)) x✝ = (?m.169723.repr (Int.fract k)) x✝
state_after: no goals
tactic: rw [repr_fract_apply, Basis.singleton_repr, Basis.singleton_repr]
Theorem: MonoidHom.noncommCoprod_comp_inl
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 : M
⊢ ((f.noncommCoprod g comm).comp (inl M N)) x = f x
state_after: no goals
tactic: simp
Theorem: FDRep.char_conj
File: Mathlib/RepresentationTheory/Character.lean

Proof steps:
state_before: k : Type u
inst✝¹ : Field k
G : Type u
inst✝ : Group G
V : FDRep k G
g h : G
⊢ V.character (h * g * h⁻¹) = V.character g
state_after: no goals
tactic: rw [char_mul_comm, inv_mul_cancel_left]