ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Equiv.Perm.map_finRange_perm
File: Mathlib/Data/List/FinRange.lean

Proof steps:
state_before: n : ℕ
σ : Perm (Fin n)
⊢ map (⇑σ) (finRange n) ~ finRange n
state_after: n : ℕ
σ : Perm (Fin n)
⊢ ∀ (a : Fin n), a ∈ map (⇑σ) (finRange n) ↔ a ∈ finRange n
tactic: rw [perm_ext_iff_of_nodup ((nodup_finRange n).map σ.injective) <| nodup_finRange n]
state_before: n : ℕ
σ : Perm (Fin n)
⊢ ∀ (a : Fin n), a ∈ map (⇑σ) (finRange n) ↔ a ∈ finRange n
state_after: no goals
tactic: simpa [mem_map, mem_finRange, true_and_iff, iff_true_iff] using σ.surjective
Theorem: CategoryTheory.Limits.Pi.whiskerEquiv_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝² : Category.{v, u} C
J : Type u_1
K : Type u_2
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasProduct f
inst✝ : HasProduct g
k : K
⊢ g (e (e.symm k)) = g k
state_after: no goals
tactic: simp
Theorem: Multiset.cons_eq_cons
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
a b : α
as bs : Multiset α
⊢ a ::ₘ as = b ::ₘ bs ↔ a = b ∧ as = bs ∨ a ≠ b ∧ ∃ cs, as = b ::ₘ cs ∧ bs = a ::ₘ cs
state_after: α : Type u_1
β : Type v
γ : Type u_2
a b : α
as bs : Multiset α
this : DecidableEq α
⊢ a ::ₘ as = b ::ₘ bs ↔ a = b ∧ as = bs ∨ a ≠ b ∧ ∃ cs, as = b ::ₘ cs ∧ bs = a ::ₘ cs
tactic: haveI : DecidableEq α := Classical.decEq α
state_before: α : Type u_1
β : Type v
γ : Type u_2
a b : α
as bs : Multiset α
this : DecidableEq α
⊢ a ::ₘ as = b ::ₘ bs ↔ a = b ∧ as = bs ∨ a ≠ b ∧ ∃ cs, as = b ::ₘ cs ∧ bs = a ::ₘ cs
state_after: case mp
α : Type u_1
β : Type v
γ : Type u_2
a b : α
as bs : Multiset α
this : DecidableEq α
⊢ a ::ₘ as = b ::ₘ bs → a = b ∧ as = bs ∨ a ≠ b ∧ ∃ cs, as = b ::ₘ cs ∧ bs = a ::ₘ cs

case mpr
α : Type u_1
β : Type v
γ : Type u_2
a b : α
as bs : Multiset α
this : DecidableEq α
⊢ (a = b ∧ as = bs ∨ a ≠ b ∧ ∃ cs, as = b ::ₘ cs ∧ bs = a ::ₘ cs) → a ::ₘ as = b ::ₘ bs
tactic: constructor
Theorem: CategoryTheory.Presheaf.isSheaf_iff_isSheaf_comp
File: Mathlib/CategoryTheory/Sites/Sheaf.lean

Proof steps:
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁵ : Category.{v₂, u₂} A
A' : Type u₂
inst✝⁴ : Category.{max v₁ u₁, u₂} A'
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
P : Cᵒᵖ ⥤ A
P' : Cᵒᵖ ⥤ A'
s : A ⥤ B
inst✝² : HasLimitsOfSize.{v₁, max v₁ u₁, v₂, u₂} A
inst✝¹ : PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s
inst✝ : s.ReflectsIsomorphisms
⊢ IsSheaf J P ↔ IsSheaf J (P ⋙ s)
state_after: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁵ : Category.{v₂, u₂} A
A' : Type u₂
inst✝⁴ : Category.{max v₁ u₁, u₂} A'
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
P : Cᵒᵖ ⥤ A
P' : Cᵒᵖ ⥤ A'
s : A ⥤ B
inst✝² : HasLimitsOfSize.{v₁, max v₁ u₁, v₂, u₂} A
inst✝¹ : PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s
inst✝ : s.ReflectsIsomorphisms
this : ReflectsLimitsOfSize.{v₁, max u₁ v₁, v₂, v₃, u₂, u₃} s := reflectsLimitsOfReflectsIsomorphisms
⊢ IsSheaf J P ↔ IsSheaf J (P ⋙ s)
tactic: letI : ReflectsLimitsOfSize s := reflectsLimitsOfReflectsIsomorphisms
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁵ : Category.{v₂, u₂} A
A' : Type u₂
inst✝⁴ : Category.{max v₁ u₁, u₂} A'
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
P : Cᵒᵖ ⥤ A
P' : Cᵒᵖ ⥤ A'
s : A ⥤ B
inst✝² : HasLimitsOfSize.{v₁, max v₁ u₁, v₂, u₂} A
inst✝¹ : PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s
inst✝ : s.ReflectsIsomorphisms
this : ReflectsLimitsOfSize.{v₁, max u₁ v₁, v₂, v₃, u₂, u₃} s := reflectsLimitsOfReflectsIsomorphisms
⊢ IsSheaf J P ↔ IsSheaf J (P ⋙ s)
state_after: no goals
tactic: exact ⟨isSheaf_comp_of_isSheaf J P s, isSheaf_of_isSheaf_comp J P s⟩
Theorem: Ordinal.sup_succ_le_lsub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ succ (sup f) ≤ lsub f ↔ ∃ i, f i = sup f
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
h : succ (sup f) ≤ lsub f
⊢ ∃ i, f i = sup f

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ (∃ i, f i = sup f) → succ (sup f) ≤ lsub f
tactic: refine ⟨fun h => ?_, ?_⟩
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ (∃ i, f i = sup f) → succ (sup f) ≤ lsub f
state_after: case refine_2.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
w✝ : ι
hf : f w✝ = sup f
⊢ succ (sup f) ≤ lsub f
tactic: rintro ⟨_, hf⟩
state_before: case refine_2.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
w✝ : ι
hf : f w✝ = sup f
⊢ succ (sup f) ≤ lsub f
state_after: case refine_2.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
w✝ : ι
hf : f w✝ = sup f
⊢ f w✝ < lsub f
tactic: rw [succ_le_iff, ← hf]
state_before: case refine_2.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
w✝ : ι
hf : f w✝ = sup f
⊢ f w✝ < lsub f
state_after: no goals
tactic: exact lt_lsub _ _
Theorem: CategoryTheory.isCoseparating_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
𝒢 : Set Cᵒᵖ
⊢ IsCoseparating 𝒢.unop ↔ IsSeparating 𝒢
state_after: no goals
tactic: rw [← isSeparating_op_iff, Set.unop_op]
Theorem: CategoryTheory.Limits.Types.limitCone_π_app
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
j j' : J
f : j ⟶ j'
⊢ ((Functor.const J).obj ↑F.sections).map f ≫ (fun j u => ↑u j) j' = (fun j u => ↑u j) j ≫ F.map f
state_after: case h
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
j j' : J
f : j ⟶ j'
x : ((Functor.const J).obj ↑F.sections).obj j
⊢ (((Functor.const J).obj ↑F.sections).map f ≫ (fun j u => ↑u j) j') x = ((fun j u => ↑u j) j ≫ F.map f) x
tactic: funext x
state_before: case h
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
j j' : J
f : j ⟶ j'
x : ((Functor.const J).obj ↑F.sections).obj j
⊢ (((Functor.const J).obj ↑F.sections).map f ≫ (fun j u => ↑u j) j') x = ((fun j u => ↑u j) j ≫ F.map f) x
state_after: no goals
tactic: simp
Theorem: String.utf8GetAux?_of_valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: cs cs' : List Char
i p : Nat
hp : i + utf8Len cs = p
⊢ utf8GetAux? (cs ++ cs') { byteIdx := i } { byteIdx := p } = cs'.head?
state_after: no goals
tactic: match cs, cs' with
  | [], [] => rfl
  | [], c::cs' => simp [← hp, utf8GetAux?]
  | c::cs, cs' =>
    simp only [utf8GetAux?, List.append_eq]
    rw [if_neg]
    case hnc => simp [← hp, Pos.ext_iff]; exact ne_self_add_add_csize
    refine utf8GetAux?_of_valid cs cs' ?_
    simpa [Nat.add_assoc, Nat.add_comm] using hp
Theorem: Nat.floor_zero
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ ⌊0⌋₊ = 0
state_after: no goals
tactic: rw [← Nat.cast_zero, floor_natCast]
Theorem: CategoryTheory.balanced_opposite
File: Mathlib/CategoryTheory/Balanced.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Balanced C
X✝ Y✝ : Cᵒᵖ
f : X✝ ⟶ Y✝
fmono : Mono f
fepi : Epi f
⊢ IsIso f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Balanced C
X✝ Y✝ : Cᵒᵖ
f : X✝ ⟶ Y✝
fmono : Mono f
fepi : Epi f
⊢ IsIso f.unop.op
tactic: rw [← Quiver.Hom.op_unop f]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Balanced C
X✝ Y✝ : Cᵒᵖ
f : X✝ ⟶ Y✝
fmono : Mono f
fepi : Epi f
⊢ IsIso f.unop.op
state_after: no goals
tactic: exact isIso_of_op _
Theorem: FractionalIdeal.canonicalEquiv_self
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g : P →ₐ[R] P'
⊢ canonicalEquiv S P P = RingEquiv.refl (FractionalIdeal S P)
state_after: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g : P →ₐ[R] P'
⊢ (canonicalEquiv S P P).trans (canonicalEquiv S P P) = RingEquiv.refl (FractionalIdeal S P)
tactic: rw [← canonicalEquiv_trans_canonicalEquiv S P P]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g : P →ₐ[R] P'
⊢ (canonicalEquiv S P P).trans (canonicalEquiv S P P) = RingEquiv.refl (FractionalIdeal S P)
state_after: case h.e'_2.h.e'_10
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g : P →ₐ[R] P'
⊢ canonicalEquiv S P P = (canonicalEquiv S P P).symm
tactic: convert (canonicalEquiv S P P).symm_trans_self
state_before: case h.e'_2.h.e'_10
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g : P →ₐ[R] P'
⊢ canonicalEquiv S P P = (canonicalEquiv S P P).symm
state_after: no goals
tactic: exact (canonicalEquiv_symm S P P).symm
Theorem: pi_dvd_iff
File: Mathlib/Algebra/Divisibility/Prod.lean

Proof steps:
state_before: ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
x y : (i : ι) → G i
⊢ x ∣ y ↔ ∀ (i : ι), x i ∣ y i
state_after: ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
x y : (i : ι) → G i
⊢ (∃ c, ∀ (a : ι), y a = (x * c) a) ↔ ∃ f, ∀ (x_1 : ι), y x_1 = x x_1 * f x_1
tactic: simp_rw [dvd_def, Function.funext_iff, Classical.skolem]
state_before: ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
x y : (i : ι) → G i
⊢ (∃ c, ∀ (a : ι), y a = (x * c) a) ↔ ∃ f, ∀ (x_1 : ι), y x_1 = x x_1 * f x_1
state_after: no goals
tactic: rfl
Theorem: Ring.inverse_eq_inv
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b c d : G₀
m n : ℕ
a : G₀
⊢ inverse a = a⁻¹
state_after: case inl
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
⊢ inverse 0 = 0⁻¹

case inr
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b c d : G₀
m n : ℕ
a : G₀
ha : a ≠ 0
⊢ inverse a = a⁻¹
tactic: obtain rfl | ha := eq_or_ne a 0
Theorem: cross_anticomm
File: Mathlib/LinearAlgebra/CrossProduct.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
v w : Fin 3 → R
⊢ -(crossProduct v) w = (crossProduct w) v
state_after: no goals
tactic: simp [cross_apply, mul_comm]
Theorem: CategoryTheory.Functor.splitMonoBiprodComparison'_retraction
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

Proof steps:
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
X Y : C
inst✝² : HasBinaryBiproduct X Y
inst✝¹ : HasBinaryBiproduct (F.obj X) (F.obj Y)
inst✝ : F.PreservesZeroMorphisms
⊢ F.biprodComparison' X Y ≫ F.biprodComparison X Y = 𝟙 (F.obj X ⊞ F.obj Y)
state_after: no goals
tactic: aesop
Theorem: AddCommute.left_comm
File: Mathlib/Algebra/Group/Commute/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
S : Type u_3
inst✝ : Semigroup S
a b c✝ : S
h : Commute a b
c : S
⊢ a * (b * c) = b * (a * c)
state_after: no goals
tactic: simp only [← mul_assoc, h.eq]
Theorem: MeasureTheory.exists_null_pairwise_disjoint_diff
File: Mathlib/MeasureTheory/Measure/AEDisjoint.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
m : MeasurableSpace α
μ : Measure α
s✝ t u v : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Pairwise (AEDisjoint μ on s)
⊢ ∃ t, (∀ (i : ι), MeasurableSet (t i)) ∧ (∀ (i : ι), μ (t i) = 0) ∧ Pairwise (Disjoint on fun i => s i \ t i)
state_after: case refine_1
ι : Type u_1
α : Type u_2
m : MeasurableSpace α
μ : Measure α
s✝ t u v : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Pairwise (AEDisjoint μ on s)
i : ι
⊢ μ ((fun i => toMeasurable μ (s i ∩ ⋃ j ∈ {i}ᶜ, s j)) i) = 0

case refine_2
ι : Type u_1
α : Type u_2
m : MeasurableSpace α
μ : Measure α
s✝ t u v : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Pairwise (AEDisjoint μ on s)
⊢ Pairwise (Disjoint on fun i => s i \ (fun i => toMeasurable μ (s i ∩ ⋃ j ∈ {i}ᶜ, s j)) i)
tactic: refine ⟨fun i => toMeasurable μ (s i ∩ ⋃ j ∈ ({i}ᶜ : Set ι), s j), fun i =>
    measurableSet_toMeasurable _ _, fun i => ?_, ?_⟩
Theorem: AddSubmonoid.LocalizationMap.add_mk'_eq_mk'_of_add
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x₁ x₂ : M
y : ↥S
⊢ f.toMap x₁ * f.mk' x₂ y = f.mk' (x₁ * x₂) y
state_after: no goals
tactic: rw [← mk'_one, ← mk'_mul, one_mul]
Theorem: FDRep.char_mul_comm
File: Mathlib/RepresentationTheory/Character.lean

Proof steps:
state_before: k : Type u
inst✝¹ : Field k
G : Type u
inst✝ : Monoid G
V : FDRep k G
g h : G
⊢ V.character (h * g) = V.character (g * h)
state_after: no goals
tactic: simp only [trace_mul_comm, character, map_mul]
Theorem: Multiset.card_coe
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Fintype.card m.ToType = card m
state_after: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Fintype.card { x // x ∈ m.toEnumFinset } = card m
tactic: rw [Fintype.card_congr m.coeEquiv]
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Fintype.card { x // x ∈ m.toEnumFinset } = card m
state_after: no goals
tactic: simp only [Fintype.card_coe, card_toEnumFinset]
Theorem: PartialEquiv.pi_refl
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
ι : Type u_5
αi : ι → Type u_6
βi : ι → Type u_7
γi : ι → Type u_8
⊢ (PartialEquiv.pi fun i => PartialEquiv.refl (αi i)) = PartialEquiv.refl ((i : ι) → αi i)
state_after: no goals
tactic: ext <;> simp
Theorem: Filter.Germ.min_def
File: Mathlib/Order/Filter/FilterProduct.lean

Proof steps:
state_before: α : Type u
β : Type v
φ : Ultrafilter α
K : LinearOrder β
x y : (↑φ).Germ β
a b : α → β
⊢ min ↑a ↑b = map₂ min ↑a ↑b
state_after: case inl
α : Type u
β : Type v
φ : Ultrafilter α
K : LinearOrder β
x y : (↑φ).Germ β
a b : α → β
h : ↑a ≤ ↑b
⊢ min ↑a ↑b = map₂ min ↑a ↑b

case inr
α : Type u
β : Type v
φ : Ultrafilter α
K : LinearOrder β
x y : (↑φ).Germ β
a b : α → β
h : ↑b ≤ ↑a
⊢ min ↑a ↑b = map₂ min ↑a ↑b
tactic: rcases le_total (a : β*) b with h | h
Theorem: Filter.tendsto_mul_const_atBot_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => f x * r) l atBot ↔ Tendsto f l atTop
state_after: no goals
tactic: simpa only [mul_comm] using tendsto_const_mul_atBot_of_neg hr
Theorem: Set.Intersecting.disjoint_map_compl
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

Proof steps:
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
⊢ Disjoint s (map { toFun := compl, inj' := ⋯ } s)
state_after: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
⊢ ∀ ⦃a : α⦄, a ∈ s → a ∉ map { toFun := compl, inj' := ⋯ } s
tactic: rw [Finset.disjoint_left]
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
⊢ ∀ ⦃a : α⦄, a ∈ s → a ∉ map { toFun := compl, inj' := ⋯ } s
state_after: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
x : α
hx : x ∈ s
hxc : x ∈ map { toFun := compl, inj' := ⋯ } s
⊢ False
tactic: rintro x hx hxc
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
x : α
hx : x ∈ s
hxc : x ∈ map { toFun := compl, inj' := ⋯ } s
⊢ False
state_after: case intro.intro
α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
x : α
hx' : x ∈ s
hx : { toFun := compl, inj' := ⋯ } x ∈ s
hxc : { toFun := compl, inj' := ⋯ } x ∈ map { toFun := compl, inj' := ⋯ } s
⊢ False
tactic: obtain ⟨x, hx', rfl⟩ := mem_map.mp hxc
state_before: case intro.intro
α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
x : α
hx' : x ∈ s
hx : { toFun := compl, inj' := ⋯ } x ∈ s
hxc : { toFun := compl, inj' := ⋯ } x ∈ map { toFun := compl, inj' := ⋯ } s
⊢ False
state_after: no goals
tactic: exact hs.not_compl_mem hx' hx
Theorem: finrank_span_singleton
File: Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ finrank K ↥(span K {v}) = 1
state_after: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ finrank K ↥(span K {v}) ≤ 1

case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ 1 ≤ finrank K ↥(span K {v})
tactic: apply le_antisymm
Theorem: Filter.Germ.isConstant_comp
File: Mathlib/Order/Filter/Germ/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l✝ : Filter α
f✝ g✝ h✝ : α → β
l : Filter α
f : α → β
g : β → γ
h : (↑f).IsConstant
⊢ (↑(g ∘ f)).IsConstant
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l✝ : Filter α
f✝ g✝ h : α → β
l : Filter α
f : α → β
g : β → γ
b : β
hb : f =ᶠ[l] fun x => b
⊢ (↑(g ∘ f)).IsConstant
tactic: obtain ⟨b, hb⟩ := h
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l✝ : Filter α
f✝ g✝ h : α → β
l : Filter α
f : α → β
g : β → γ
b : β
hb : f =ᶠ[l] fun x => b
⊢ (↑(g ∘ f)).IsConstant
state_after: no goals
tactic: exact ⟨g b, hb.fun_comp g⟩
Theorem: Real.add_one_lt_exp
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x : ℝ
hx : x ≠ 0
⊢ x + 1 < rexp x
state_after: case inl
x : ℝ
hx✝ : x ≠ 0
hx : 0 < x
⊢ x + 1 < rexp x

case inr
x : ℝ
hx✝ : x ≠ 0
hx : x < 0
⊢ x + 1 < rexp x
tactic: obtain hx | hx := hx.symm.lt_or_lt
state_before: case inr
x : ℝ
hx✝ : x ≠ 0
hx : x < 0
⊢ x + 1 < rexp x
state_after: case inr.inl
x : ℝ
hx✝ : x ≠ 0
hx : x < 0
h' : 1 ≤ -x
⊢ x + 1 < rexp x

case inr.inr
x : ℝ
hx✝ : x ≠ 0
hx : x < 0
h' : -x < 1
⊢ x + 1 < rexp x
tactic: obtain h' | h' := le_or_lt 1 (-x)
state_before: case inr.inr
x : ℝ
hx✝ : x ≠ 0
hx : x < 0
h' : -x < 1
⊢ x + 1 < rexp x
state_after: case inr.inr
x : ℝ
hx✝ : x ≠ 0
hx : x < 0
h' : -x < 1
hx' : 0 < x + 1
⊢ x + 1 < rexp x
tactic: have hx' : 0 < x + 1 := by linarith
state_before: case inr.inr
x : ℝ
hx✝ : x ≠ 0
hx : x < 0
h' : -x < 1
hx' : 0 < x + 1
⊢ x + 1 < rexp x
state_after: no goals
tactic: simpa [add_comm, exp_neg, inv_lt_inv (exp_pos _) hx']
    using exp_bound_div_one_sub_of_interval' (neg_pos.2 hx) h'
Theorem: _private.Mathlib.RingTheory.Presentation.0.Algebra.Presentation.span_range_relation_eq_ker_baseChange
File: Mathlib/RingTheory/Presentation.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
P✝ : Presentation R S
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Presentation R S
⊢ Ideal.span (Set.range fun i => (MvPolynomial.map (algebraMap R T)) (P.relation i)) =
    RingHom.ker (aeval P.baseChange.val)
state_after: case a
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
P✝ : Presentation R S
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Presentation R S
⊢ Ideal.span (Set.range fun i => (MvPolynomial.map (algebraMap R T)) (P.relation i)) ≤
    RingHom.ker (aeval P.baseChange.val)

case a
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
P✝ : Presentation R S
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Presentation R S
⊢ RingHom.ker (aeval P.baseChange.val) ≤
    Ideal.span (Set.range fun i => (MvPolynomial.map (algebraMap R T)) (P.relation i))
tactic: apply le_antisymm
Theorem: Set.pairwise_iff_exists_forall
File: Mathlib/Data/Set/Pairwise/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r✝ p q : α → α → Prop
f✝ g : ι → α
s✝ t u : Set α
a b : α
inst✝¹ : Nonempty ι
s : Set α
f : α → ι
r : ι → ι → Prop
inst✝ : IsEquiv ι r
⊢ s.Pairwise (r on f) ↔ ∃ z, ∀ x ∈ s, r (f x) z
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r✝ p q : α → α → Prop
f✝ g : ι → α
s t u : Set α
a b : α
inst✝¹ : Nonempty ι
f : α → ι
r : ι → ι → Prop
inst✝ : IsEquiv ι r
⊢ ∅.Pairwise (r on f) ↔ ∃ z, ∀ x ∈ ∅, r (f x) z

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r✝ p q : α → α → Prop
f✝ g : ι → α
s✝ t u : Set α
a b : α
inst✝¹ : Nonempty ι
s : Set α
f : α → ι
r : ι → ι → Prop
inst✝ : IsEquiv ι r
hne : s.Nonempty
⊢ s.Pairwise (r on f) ↔ ∃ z, ∀ x ∈ s, r (f x) z
tactic: rcases s.eq_empty_or_nonempty with (rfl | hne)
Theorem: Ordinal.blsub_type
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
r : α → α → Prop
inst✝ : IsWellOrder α r
f : (a : Ordinal.{u}) → a < type r → Ordinal.{max u v}
o : Ordinal.{max u v}
⊢ (type r).blsub f ≤ o ↔ (lsub fun a => f (typein r a) ⋯) ≤ o
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
r : α → α → Prop
inst✝ : IsWellOrder α r
f : (a : Ordinal.{u}) → a < type r → Ordinal.{max u v}
o : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (h : i < type r), f i h < o) ↔ ∀ (i : α), f (typein r i) ⋯ < o
tactic: rw [blsub_le_iff, lsub_le_iff]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
r : α → α → Prop
inst✝ : IsWellOrder α r
f : (a : Ordinal.{u}) → a < type r → Ordinal.{max u v}
o : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (h : i < type r), f i h < o) ↔ ∀ (i : α), f (typein r i) ⋯ < o
state_after: no goals
tactic: exact ⟨fun H b => H _ _, fun H i h => by simpa only [typein_enum] using H (enum r i h)⟩