ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Function.Embedding.equiv_of_fintype_self_embedding_to_embedding
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
e : α ↪ α
⊢ e.equivOfFintypeSelfEmbedding.toEmbedding = e
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
e : α ↪ α
x✝ : α
⊢ e.equivOfFintypeSelfEmbedding.toEmbedding x✝ = e x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
e : α ↪ α
x✝ : α
⊢ e.equivOfFintypeSelfEmbedding.toEmbedding x✝ = e x✝
state_after: no goals
tactic: rfl
Theorem: Ordinal.lift_down
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u}
b : Ordinal.{max u v}
h : b ≤ lift.{v, u} a
⊢ b.card ≤ Cardinal.lift.{v, u} a.card
state_after: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u}
b : Ordinal.{max u v}
h : b ≤ lift.{v, u} a
⊢ b.card ≤ (lift.{v, u} a).card
tactic: rw [lift_card]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u}
b : Ordinal.{max u v}
h : b ≤ lift.{v, u} a
⊢ b.card ≤ (lift.{v, u} a).card
state_after: no goals
tactic: exact card_le_card h
Theorem: Set.toFinset_subset_toFinset
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑t
⊢ s.toFinset ⊆ t.toFinset ↔ s ⊆ t
state_after: no goals
tactic: simp [Finset.subset_iff, Set.subset_def]
Theorem: Nat.Partrec.Code.eval_const
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: n m : ℕ
⊢ (Code.const (n + 1)).eval m = Part.some (n + 1)
state_after: no goals
tactic: simp! [eval_const n m]
Theorem: Fin.snoc_last
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
⊢ snoc p x (last n) = x
state_after: no goals
tactic: simp [snoc]
Theorem: Fin.card_Ioo
File: Mathlib/Order/Interval/Finset/Fin.lean

Proof steps:
state_before: n : ℕ
a b : Fin n
⊢ (Ioo a b).card = ↑b - ↑a - 1
state_after: no goals
tactic: rw [← Nat.card_Ioo, ← map_valEmbedding_Ioo, card_map]
Theorem: seminormFromConst_apply_c
File: Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
c : R
f : RingSeminorm R
hf1 : f 1 ≤ 1
hc : f c ≠ 0
hpm : IsPowMul ⇑f
⊢ Tendsto (seminormFromConst_seq c f c) atTop (𝓝 (f c))
state_after: R : Type u_1
inst✝ : CommRing R
c : R
f : RingSeminorm R
hf1 : f 1 ≤ 1
hc : f c ≠ 0
hpm : IsPowMul ⇑f
hseq : seminormFromConst_seq c f c = fun _n => f c
⊢ Tendsto (seminormFromConst_seq c f c) atTop (𝓝 (f c))
tactic: have hseq : seminormFromConst_seq c f c = fun _n ↦ f c := by
      ext n
      simp only [seminormFromConst_seq]
      rw [mul_comm, ← pow_succ, hpm _ le_add_self, pow_succ, mul_comm,  mul_div_assoc,
        div_self (pow_ne_zero n hc), mul_one]
state_before: R : Type u_1
inst✝ : CommRing R
c : R
f : RingSeminorm R
hf1 : f 1 ≤ 1
hc : f c ≠ 0
hpm : IsPowMul ⇑f
hseq : seminormFromConst_seq c f c = fun _n => f c
⊢ Tendsto (seminormFromConst_seq c f c) atTop (𝓝 (f c))
state_after: R : Type u_1
inst✝ : CommRing R
c : R
f : RingSeminorm R
hf1 : f 1 ≤ 1
hc : f c ≠ 0
hpm : IsPowMul ⇑f
hseq : seminormFromConst_seq c f c = fun _n => f c
⊢ Tendsto (fun _n => f c) atTop (𝓝 (f c))
tactic: rw [hseq]
state_before: R : Type u_1
inst✝ : CommRing R
c : R
f : RingSeminorm R
hf1 : f 1 ≤ 1
hc : f c ≠ 0
hpm : IsPowMul ⇑f
hseq : seminormFromConst_seq c f c = fun _n => f c
⊢ Tendsto (fun _n => f c) atTop (𝓝 (f c))
state_after: no goals
tactic: exact tendsto_const_nhds
Theorem: Matroid.Basis.exchange
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
he : e ∈ I \ J
⊢ ∃ f ∈ J \ I, M.Basis (insert f (I \ {e})) X
state_after: case intro.intro
α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
he : e ∈ I \ J
y : α
hy : y ∈ J \ I
h : (M ↾ X).Base (insert y (I \ {e}))
⊢ ∃ f ∈ J \ I, M.Basis (insert f (I \ {e})) X
tactic: obtain ⟨y,hy, h⟩ := hIX.restrict_base.exchange hJX.restrict_base he
state_before: case intro.intro
α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
he : e ∈ I \ J
y : α
hy : y ∈ J \ I
h : (M ↾ X).Base (insert y (I \ {e}))
⊢ ∃ f ∈ J \ I, M.Basis (insert f (I \ {e})) X
state_after: no goals
tactic: exact ⟨y, hy, by rwa [base_restrict_iff] at h⟩
Theorem: Complex.closure_setOf_lt_re
File: Mathlib/Analysis/Complex/ReImTopology.lean

Proof steps:
state_before: a : ℝ
⊢ closure {z | a < z.re} = {z | a ≤ z.re}
state_after: no goals
tactic: simpa only [closure_Ioi] using closure_preimage_re (Ioi a)
Theorem: ProbabilityTheory.abs_truncation_le_abs_self
File: Mathlib/Probability/StrongLaw.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
⊢ |truncation f A x| ≤ |f x|
state_after: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
⊢ |if f x ∈ Set.Ioc (-A) A then f x else 0| ≤ |f x|
tactic: simp only [truncation, indicator, Set.mem_Icc, id, Function.comp_apply]
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
⊢ |if f x ∈ Set.Ioc (-A) A then f x else 0| ≤ |f x|
state_after: case pos
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
h✝ : f x ∈ Set.Ioc (-A) A
⊢ |f x| ≤ |f x|

case neg
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
h✝ : f x ∉ Set.Ioc (-A) A
⊢ |0| ≤ |f x|
tactic: split_ifs
Theorem: CategoryTheory.Limits.IsTerminal.strict_hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictTerminalObjects C
I : C
hI : IsTerminal I
A : C
f g : I ⟶ A
⊢ f = g
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictTerminalObjects C
I : C
hI : IsTerminal I
A : C
f g : I ⟶ A
this : IsIso f
⊢ f = g
tactic: haveI := hI.isIso_from f
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictTerminalObjects C
I : C
hI : IsTerminal I
A : C
f g : I ⟶ A
this : IsIso f
⊢ f = g
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictTerminalObjects C
I : C
hI : IsTerminal I
A : C
f g : I ⟶ A
this✝ : IsIso f
this : IsIso g
⊢ f = g
tactic: haveI := hI.isIso_from g
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictTerminalObjects C
I : C
hI : IsTerminal I
A : C
f g : I ⟶ A
this✝ : IsIso f
this : IsIso g
⊢ f = g
state_after: no goals
tactic: exact eq_of_inv_eq_inv (hI.hom_ext (inv f) (inv g))
Theorem: CategoryTheory.NatIso.isIso_inv_app
File: Mathlib/CategoryTheory/NatIso.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X✝ Y : C
α : F ⟶ G
x✝ : IsIso α
X : C
⊢ (inv α).app X = inv (α.app X)
state_after: case hom_inv_id
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X✝ Y : C
α : F ⟶ G
x✝ : IsIso α
X : C
⊢ α.app X ≫ (inv α).app X = 𝟙 (F.obj X)
tactic: apply IsIso.eq_inv_of_hom_inv_id
state_before: case hom_inv_id
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X✝ Y : C
α : F ⟶ G
x✝ : IsIso α
X : C
⊢ α.app X ≫ (inv α).app X = 𝟙 (F.obj X)
state_after: case hom_inv_id
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X✝ Y : C
α : F ⟶ G
x✝ : IsIso α
X : C
⊢ (α ≫ inv α).app X = 𝟙 (F.obj X)
tactic: rw [← NatTrans.comp_app]
state_before: case hom_inv_id
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X✝ Y : C
α : F ⟶ G
x✝ : IsIso α
X : C
⊢ (α ≫ inv α).app X = 𝟙 (F.obj X)
state_after: no goals
tactic: simp
Theorem: ContinuousMapZero.adjoin_id_dense
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

Proof steps:
state_before: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
⊢ Dense ↑(adjoin 𝕜 {ContinuousMapZero.id h0})
state_after: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
h0' : 0 ∈ s
⊢ Dense ↑(adjoin 𝕜 {ContinuousMapZero.id h0})
tactic: have h0' : 0 ∈ s := h0 ▸ (0 : s).property
state_before: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
h0' : 0 ∈ s
⊢ Dense ↑(adjoin 𝕜 {ContinuousMapZero.id h0})
state_after: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
h0' : 0 ∈ s
⊢ ⇑toContinuousMapHom ⁻¹' ↑(RingHom.ker (ContinuousMap.evalStarAlgHom 𝕜 𝕜 ⟨0, h0'⟩)) = Set.univ
tactic: rw [dense_iff_closure_eq,
    ← closedEmbedding_toContinuousMap.injective.preimage_image (closure _),
    ← closedEmbedding_toContinuousMap.closure_image_eq, ← coe_toContinuousMapHom,
    ← NonUnitalStarSubalgebra.coe_map, NonUnitalStarAlgHom.map_adjoin_singleton,
    toContinuousMapHom_apply, toContinuousMap_id h0,
    ← ContinuousMap.ker_evalStarAlgHom_eq_closure_adjoin_id s h0']
state_before: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
h0' : 0 ∈ s
⊢ ⇑toContinuousMapHom ⁻¹' ↑(RingHom.ker (ContinuousMap.evalStarAlgHom 𝕜 𝕜 ⟨0, h0'⟩)) = Set.univ
state_after: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
h0' : 0 ∈ s
f : C(↑s, 𝕜)₀
⊢ f ∈ ⇑toContinuousMapHom ⁻¹' ↑(RingHom.ker (ContinuousMap.evalStarAlgHom 𝕜 𝕜 ⟨0, h0'⟩))
tactic: apply Set.eq_univ_of_forall fun f ↦ ?_
state_before: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
h0' : 0 ∈ s
f : C(↑s, 𝕜)₀
⊢ f ∈ ⇑toContinuousMapHom ⁻¹' ↑(RingHom.ker (ContinuousMap.evalStarAlgHom 𝕜 𝕜 ⟨0, h0'⟩))
state_after: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
h0' : 0 ∈ s
f : C(↑s, 𝕜)₀
⊢ f ⟨0, h0'⟩ = 0
tactic: simp only [Set.mem_preimage, toContinuousMapHom_apply, SetLike.mem_coe, RingHom.mem_ker,
    ContinuousMap.evalStarAlgHom_apply, ContinuousMap.coe_coe]
state_before: X : Type u_1
inst✝³ : TopologicalSpace X
𝕜 : Type u_2
inst✝² : RCLike 𝕜
s : Set 𝕜
inst✝¹ : Zero ↑s
h0 : ↑0 = 0
inst✝ : CompactSpace ↑s
h0' : 0 ∈ s
f : C(↑s, 𝕜)₀
⊢ f ⟨0, h0'⟩ = 0
state_after: no goals
tactic: rw [show ⟨0, h0'⟩ = (0 : s) by ext; exact h0.symm, _root_.map_zero f]
Theorem: ZMod.mod_four_ne_three_of_sq_eq_neg_sq'
File: Mathlib/NumberTheory/LegendreSymbol/Basic.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
x y : ZMod p
hy : y ≠ 0
hxy : x ^ 2 = -y ^ 2
⊢ (x / y) ^ 2 = -1
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
x y : ZMod p
hy : y ≠ 0
hxy : x ^ 2 / y ^ 2 = -y ^ 2 / y ^ 2
⊢ (x / y) ^ 2 = -1
tactic: apply_fun fun z => z / y ^ 2 at hxy
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
x y : ZMod p
hy : y ≠ 0
hxy : x ^ 2 / y ^ 2 = -y ^ 2 / y ^ 2
⊢ (x / y) ^ 2 = -1
state_after: no goals
tactic: rwa [neg_div, ← div_pow, ← div_pow, div_self hy, one_pow] at hxy
Theorem: List.alternatingProd_reverse
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✝ : CommGroup α
⊢ [].reverse.alternatingProd = [].alternatingProd ^ (-1) ^ ([].length + 1)
state_after: no goals
tactic: simp only [alternatingProd_nil, one_zpow, reverse_nil]
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✝ : CommGroup α
a : α
l : List α
⊢ (a :: l).reverse.alternatingProd = (a :: l).alternatingProd ^ (-1) ^ ((a :: l).length + 1)
state_after: ι : 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✝ : CommGroup α
a : α
l : List α
⊢ (l.alternatingProd ^ (-1) ^ l.length)⁻¹ * a ^ (-1) ^ l.length = (a / l.alternatingProd) ^ (-1) ^ l.length
tactic: simp_rw [reverse_cons, alternatingProd_append, alternatingProd_reverse,
      alternatingProd_singleton, alternatingProd_cons, length_reverse, length, pow_succ',
      Int.neg_mul, one_mul, zpow_neg, inv_inv]
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✝ : CommGroup α
a : α
l : List α
⊢ (l.alternatingProd ^ (-1) ^ l.length)⁻¹ * a ^ (-1) ^ l.length = (a / l.alternatingProd) ^ (-1) ^ l.length
state_after: no goals
tactic: rw [mul_comm, ← div_eq_mul_inv, div_zpow]
Theorem: Nat.cast_mul
File: Mathlib/Data/Nat/Cast/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NonAssocSemiring α
m n : ℕ
⊢ ↑(m * n) = ↑m * ↑n
state_after: no goals
tactic: induction n <;> simp [mul_succ, mul_add, *]
Theorem: Complex.volume_preserving_equiv_pi
File: Mathlib/MeasureTheory/Measure/Lebesgue/Complex.lean

Proof steps:
state_before: ⊢ MeasurePreserving (⇑measurableEquivPi) volume volume
state_after: case h.e'_6

⊢ volume = Measure.map (⇑measurableEquivPi.symm) volume
tactic: convert (measurableEquivPi.symm.measurable.measurePreserving volume).symm
state_before: case h.e'_6

⊢ volume = Measure.map (⇑measurableEquivPi.symm) volume
state_after: case h.e'_6

⊢ ((Pi.basisFun ℝ (Fin 2)).map basisOneI.equivFun.toContinuousLinearEquiv.symm.toLinearEquiv).addHaar = volume
tactic: rw [← addHaarMeasure_eq_volume_pi, ← Basis.parallelepiped_basisFun, ← Basis.addHaar,
    measurableEquivPi, Homeomorph.toMeasurableEquiv_symm_coe,
    ContinuousLinearEquiv.symm_toHomeomorph, ContinuousLinearEquiv.coe_toHomeomorph,
    Basis.map_addHaar, eq_comm]
state_before: case h.e'_6

⊢ ((Pi.basisFun ℝ (Fin 2)).map basisOneI.equivFun.toContinuousLinearEquiv.symm.toLinearEquiv).addHaar = volume
state_after: no goals
tactic: exact (Basis.addHaar_eq_iff _ _).mpr Complex.orthonormalBasisOneI.volume_parallelepiped
Theorem: CategoryTheory.Idempotents.KaroubiHomologicalComplexEquivalence.Functor.obj_X_X
File: Mathlib/CategoryTheory/Idempotents/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.3910, u_1} C
inst✝ : Preadditive C
ι : Type u_2
c : ComplexShape ι
P : Karoubi (HomologicalComplex C c)
n : ι
⊢ P.p.f n ≫ P.p.f n = P.p.f n
state_after: no goals
tactic: simpa only [HomologicalComplex.comp_f] using HomologicalComplex.congr_hom P.idem n
state_before: C : Type u_1
inst✝¹ : Category.{?u.3910, u_1} C
inst✝ : Preadditive C
ι : Type u_2
c : ComplexShape ι
P : Karoubi (HomologicalComplex C c)
i j : ι
hij : ¬c.Rel i j
⊢ (fun i j => { f := P.p.f i ≫ P.X.d i j, comm := ⋯ }) i j = 0
state_after: C : Type u_1
inst✝¹ : Category.{?u.3910, u_1} C
inst✝ : Preadditive C
ι : Type u_2
c : ComplexShape ι
P : Karoubi (HomologicalComplex C c)
i j : ι
hij : ¬c.Rel i j
⊢ P.p.f i ≫ P.X.d i j = 0
tactic: simp only [hom_eq_zero_iff, P.X.shape i j hij, Limits.comp_zero]
state_before: C : Type u_1
inst✝¹ : Category.{?u.3910, u_1} C
inst✝ : Preadditive C
ι : Type u_2
c : ComplexShape ι
P : Karoubi (HomologicalComplex C c)
i j : ι
hij : ¬c.Rel i j
⊢ P.p.f i ≫ P.X.d i j = 0
state_after: no goals
tactic: aesop_cat
Theorem: Set.vadd_inter_ne_empty_iff
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : α
⊢ x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a * b⁻¹ = x
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : α
⊢ (x • s ∩ t).Nonempty ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a * b⁻¹ = x
tactic: rw [← nonempty_iff_ne_empty]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : α
⊢ (x • s ∩ t).Nonempty ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a * b⁻¹ = x
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : α
⊢ (x • s ∩ t).Nonempty → ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a * b⁻¹ = x

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : α
⊢ (∃ a b, (a ∈ t ∧ b ∈ s) ∧ a * b⁻¹ = x) → (x • s ∩ t).Nonempty
tactic: constructor
Theorem: AffineEquiv.sbtw_map_iff
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
f : P ≃ᵃ[R] P'
⊢ Sbtw R (f x) (f y) (f z) ↔ Sbtw R x y z
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
f : P ≃ᵃ[R] P'
⊢ Function.Injective ⇑↑f
tactic: refine Function.Injective.sbtw_map_iff (?_ : Function.Injective f.toAffineMap)
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
f : P ≃ᵃ[R] P'
⊢ Function.Injective ⇑↑f
state_after: no goals
tactic: exact f.injective
Theorem: List.unzip_right
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l : List (α × β)
⊢ l.unzip.2 = map Prod.snd l
state_after: no goals
tactic: simp only [unzip_eq_map]
Theorem: Matroid.Base.ssubset_ground
File: Mathlib/Data/Matroid/Dual.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
I B X : Set α
h : M✶.RkPos
hB : M.Base B
⊢ B ≠ M.E
state_after: α : Type u_1
M : Matroid α
I X : Set α
h : M✶.RkPos
hB : M.Base M.E
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
M : Matroid α
I X : Set α
h : M✶.RkPos
hB : M.Base M.E
⊢ False
state_after: no goals
tactic: exact M.ground_not_base hB
Theorem: MeasureTheory.lintegral_eq_iSup_eapprox_lintegral
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), ⨆ n, ↑(eapprox f n) a ∂μ
state_after: case e_f
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (fun a => f a) = fun a => ⨆ n, ↑(eapprox f n) a
tactic: congr
state_before: case e_f
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (fun a => f a) = fun a => ⨆ n, ↑(eapprox f n) a
state_after: case e_f.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
a : α
⊢ f a = ⨆ n, ↑(eapprox f n) a
tactic: ext a
state_before: case e_f.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
a : α
⊢ f a = ⨆ n, ↑(eapprox f n) a
state_after: no goals
tactic: rw [iSup_eapprox_apply f hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (a : α), ⨆ n, ↑(eapprox f n) a ∂μ = ⨆ n, ∫⁻ (a : α), ↑(eapprox f n) a ∂μ
state_after: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∀ (n : ℕ), Measurable ↑(eapprox f n)

case h_mono
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ Monotone fun n => ↑(eapprox f n)
tactic: apply lintegral_iSup
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ ⨆ n, ∫⁻ (a : α), ↑(eapprox f n) a ∂μ = ⨆ n, (eapprox f n).lintegral μ
state_after: case e_s
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (fun n => ∫⁻ (a : α), ↑(eapprox f n) a ∂μ) = fun n => (eapprox f n).lintegral μ
tactic: congr
state_before: case e_s
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (fun n => ∫⁻ (a : α), ↑(eapprox f n) a ∂μ) = fun n => (eapprox f n).lintegral μ
state_after: case e_s.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
n : ℕ
⊢ ∫⁻ (a : α), ↑(eapprox f n) a ∂μ = (eapprox f n).lintegral μ
tactic: ext n
state_before: case e_s.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
n : ℕ
⊢ ∫⁻ (a : α), ↑(eapprox f n) a ∂μ = (eapprox f n).lintegral μ
state_after: no goals
tactic: rw [(eapprox f n).lintegral_eq_lintegral]
Theorem: CategoryTheory.Limits.PreservesEqualizer.iso_inv_ι
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
X Y Z : C
f g : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = h ≫ g
inst✝² : HasEqualizer f g
inst✝¹ : HasEqualizer (G.map f) (G.map g)
inst✝ : PreservesLimit (parallelPair f g) G
⊢ (iso G f g).inv ≫ G.map (equalizer.ι f g) = equalizer.ι (G.map f) (G.map g)
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
X Y Z : C
f g : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = h ≫ g
inst✝² : HasEqualizer f g
inst✝¹ : HasEqualizer (G.map f) (G.map g)
inst✝ : PreservesLimit (parallelPair f g) G
⊢ 𝟙 (G.obj (equalizer f g)) ≫ G.map (equalizer.ι f g) = (iso G f g).hom ≫ equalizer.ι (G.map f) (G.map g)
tactic: rw [← Iso.cancel_iso_hom_left (PreservesEqualizer.iso G f g), ← Category.assoc, Iso.hom_inv_id]
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
X Y Z : C
f g : X ⟶ Y
h : Z ⟶ X
w : h ≫ f = h ≫ g
inst✝² : HasEqualizer f g
inst✝¹ : HasEqualizer (G.map f) (G.map g)
inst✝ : PreservesLimit (parallelPair f g) G
⊢ 𝟙 (G.obj (equalizer f g)) ≫ G.map (equalizer.ι f g) = (iso G f g).hom ≫ equalizer.ι (G.map f) (G.map g)
state_after: no goals
tactic: simp
Theorem: Polynomial.natDegree_lt_natDegree_iff
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
hp : p ≠ 0
h : p.degree < q.degree
⊢ p.natDegree < q.natDegree
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
hp : p ≠ 0
h : p.degree < q.degree
hq : q ≠ 0
⊢ p.natDegree < q.natDegree
tactic: have hq : q ≠ 0 := ne_zero_of_degree_gt h
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
hp : p ≠ 0
h : p.degree < q.degree
hq : q ≠ 0
⊢ p.natDegree < q.natDegree
state_after: no goals
tactic: rwa [degree_eq_natDegree hp, degree_eq_natDegree hq, Nat.cast_lt] at h
Theorem: LieSubmodule.isCompl_iff_coe_toSubmodule
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsCompl N N' ↔ IsCompl ↑N ↑N'
state_after: no goals
tactic: simp only [isCompl_iff, disjoint_iff_coe_toSubmodule, codisjoint_iff_coe_toSubmodule]