ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieModuleHom.ker_eq_bot
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
N : 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
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
⊢ f.ker = ⊥ ↔ Function.Injective ⇑f
state_after: no goals
tactic: rw [← LieSubmodule.coe_toSubmodule_eq_iff, ker_coeSubmodule, LieSubmodule.bot_coeSubmodule,
    LinearMap.ker_eq_bot, coe_toLinearMap]
Theorem: Set.ncard_congr
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : (a : α) → a ∈ s → β
h₁ : ∀ (a : α) (ha : a ∈ s), f a ha ∈ t
h₂ : ∀ (a b : α) (ha : a ∈ s) (hb : b ∈ s), f a ha = f b hb → a = b
h₃ : ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), f a ha = b
⊢ s.ncard = t.ncard
state_after: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : (a : α) → a ∈ s → β
h₁ : ∀ (a : α) (ha : a ∈ s), f a ha ∈ t
h₂ : ∀ (a b : α) (ha : a ∈ s) (hb : b ∈ s), f a ha = f b hb → a = b
h₃ : ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), f a ha = b
f' : ↑s → ↑t := fun x => ⟨f ↑x ⋯, ⋯⟩
⊢ s.ncard = t.ncard
tactic: set f' : s → t := fun x ↦ ⟨f x.1 x.2, h₁ _ _⟩
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : (a : α) → a ∈ s → β
h₁ : ∀ (a : α) (ha : a ∈ s), f a ha ∈ t
h₂ : ∀ (a b : α) (ha : a ∈ s) (hb : b ∈ s), f a ha = f b hb → a = b
h₃ : ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), f a ha = b
f' : ↑s → ↑t := fun x => ⟨f ↑x ⋯, ⋯⟩
hbij : Function.Bijective f'
⊢ s.ncard = t.ncard
state_after: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : (a : α) → a ∈ s → β
h₁ : ∀ (a : α) (ha : a ∈ s), f a ha ∈ t
h₂ : ∀ (a b : α) (ha : a ∈ s) (hb : b ∈ s), f a ha = f b hb → a = b
h₃ : ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), f a ha = b
f' : ↑s → ↑t := fun x => ⟨f ↑x ⋯, ⋯⟩
hbij : Function.Bijective f'
⊢ Nat.card ↑s = Nat.card ↑t
tactic: simp_rw [← Nat.card_coe_set_eq]
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : (a : α) → a ∈ s → β
h₁ : ∀ (a : α) (ha : a ∈ s), f a ha ∈ t
h₂ : ∀ (a b : α) (ha : a ∈ s) (hb : b ∈ s), f a ha = f b hb → a = b
h₃ : ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), f a ha = b
f' : ↑s → ↑t := fun x => ⟨f ↑x ⋯, ⋯⟩
hbij : Function.Bijective f'
⊢ Nat.card ↑s = Nat.card ↑t
state_after: no goals
tactic: exact Nat.card_congr (Equiv.ofBijective f' hbij)
Theorem: SemistandardYoungTableau.ext
File: Mathlib/Combinatorics/Young/SemistandardTableau.lean

Proof steps:
state_before: μ : YoungDiagram
T T' : SemistandardYoungTableau μ
h : ∀ (i j : ℕ), T i j = T' i j
x✝ : ℕ
⊢ T x✝ = T' x✝
state_after: case h
μ : YoungDiagram
T T' : SemistandardYoungTableau μ
h : ∀ (i j : ℕ), T i j = T' i j
x✝¹ x✝ : ℕ
⊢ T x✝¹ x✝ = T' x✝¹ x✝
tactic: funext
state_before: case h
μ : YoungDiagram
T T' : SemistandardYoungTableau μ
h : ∀ (i j : ℕ), T i j = T' i j
x✝¹ x✝ : ℕ
⊢ T x✝¹ x✝ = T' x✝¹ x✝
state_after: no goals
tactic: apply h
Theorem: IsIntegrallyClosedIn.integralClosure_eq_bot_iff
File: Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
iic : IsIntegrallyClosedIn R A
hRA : Function.Injective ⇑(algebraMap R A)
⊢ integralClosure R A = ⊥ ↔ IsIntegrallyClosedIn R A
state_after: R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
iic : IsIntegrallyClosedIn R A
hRA : Function.Injective ⇑(algebraMap R A)
⊢ integralClosure R A ≤ ⊥ ↔ IsIntegrallyClosedIn R A
tactic: refine eq_bot_iff.trans ?_
state_before: R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
iic : IsIntegrallyClosedIn R A
hRA : Function.Injective ⇑(algebraMap R A)
⊢ integralClosure R A ≤ ⊥ ↔ IsIntegrallyClosedIn R A
state_after: case mp
R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
iic : IsIntegrallyClosedIn R A
hRA : Function.Injective ⇑(algebraMap R A)
⊢ integralClosure R A ≤ ⊥ → IsIntegrallyClosedIn R A

case mpr
R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
iic : IsIntegrallyClosedIn R A
hRA : Function.Injective ⇑(algebraMap R A)
⊢ IsIntegrallyClosedIn R A → integralClosure R A ≤ ⊥
tactic: constructor
Theorem: Equiv.sumPiEquivProdPi_symm_preimage_univ_pi
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
π : ι ⊕ ι' → Type u_4
t : (i : ι ⊕ ι') → Set (π i)
⊢ ⇑(sumPiEquivProdPi π).symm ⁻¹' univ.pi t = (univ.pi fun i => t (Sum.inl i)) ×ˢ univ.pi fun i => t (Sum.inr i)
state_after: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
π : ι ⊕ ι' → Type u_4
t : (i : ι ⊕ ι') → Set (π i)
x✝ : ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i'))
⊢ x✝ ∈ ⇑(sumPiEquivProdPi π).symm ⁻¹' univ.pi t ↔
    x✝ ∈ (univ.pi fun i => t (Sum.inl i)) ×ˢ univ.pi fun i => t (Sum.inr i)
tactic: ext
state_before: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
π : ι ⊕ ι' → Type u_4
t : (i : ι ⊕ ι') → Set (π i)
x✝ : ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i'))
⊢ x✝ ∈ ⇑(sumPiEquivProdPi π).symm ⁻¹' univ.pi t ↔
    x✝ ∈ (univ.pi fun i => t (Sum.inl i)) ×ˢ univ.pi fun i => t (Sum.inr i)
state_after: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
π : ι ⊕ ι' → Type u_4
t : (i : ι ⊕ ι') → Set (π i)
x✝ : ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i'))
⊢ (∀ (i : ι ⊕ ι'), Sum.rec x✝.1 x✝.2 i ∈ t i) ↔ (∀ (i : ι), x✝.1 i ∈ t (Sum.inl i)) ∧ ∀ (i : ι'), x✝.2 i ∈ t (Sum.inr i)
tactic: simp_rw [mem_preimage, mem_prod, mem_univ_pi, sumPiEquivProdPi_symm_apply]
state_before: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
π : ι ⊕ ι' → Type u_4
t : (i : ι ⊕ ι') → Set (π i)
x✝ : ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i'))
⊢ (∀ (i : ι ⊕ ι'), Sum.rec x✝.1 x✝.2 i ∈ t i) ↔ (∀ (i : ι), x✝.1 i ∈ t (Sum.inl i)) ∧ ∀ (i : ι'), x✝.2 i ∈ t (Sum.inr i)
state_after: case h.mp
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
π : ι ⊕ ι' → Type u_4
t : (i : ι ⊕ ι') → Set (π i)
x✝ : ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i'))
⊢ (∀ (i : ι ⊕ ι'), Sum.rec x✝.1 x✝.2 i ∈ t i) → (∀ (i : ι), x✝.1 i ∈ t (Sum.inl i)) ∧ ∀ (i : ι'), x✝.2 i ∈ t (Sum.inr i)

case h.mpr
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
π : ι ⊕ ι' → Type u_4
t : (i : ι ⊕ ι') → Set (π i)
x✝ : ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i'))
⊢ ((∀ (i : ι), x✝.1 i ∈ t (Sum.inl i)) ∧ ∀ (i : ι'), x✝.2 i ∈ t (Sum.inr i)) → ∀ (i : ι ⊕ ι'), Sum.rec x✝.1 x✝.2 i ∈ t i
tactic: constructor
Theorem: Set.singleton_prod_singleton
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ {a} ×ˢ {b} = {(a, b)}
state_after: no goals
tactic: simp
Theorem: linearMap_toMatrix_mul_basis_toMatrix
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹³ : CommSemiring R
inst✝¹² : AddCommMonoid M
inst✝¹¹ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝¹⁰ : CommRing R₂
inst✝⁹ : AddCommGroup M₂
inst✝⁸ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁵ : Fintype ι'
inst✝⁴ : Finite κ
inst✝³ : Fintype ι
inst✝² : Finite κ'
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
⊢ (toLin b c') ((toMatrix b' c') f * b'.toMatrix ⇑b) = (toLin b c') ((toMatrix b c') f)
state_after: no goals
tactic: rw [toLin_toMatrix, toLin_mul b b' c', toLin_toMatrix, b'.toLin_toMatrix, LinearMap.comp_id]
Theorem: HasSum.norm_le_of_bounded
File: Mathlib/Analysis/Normed/Group/InfiniteSum.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedAddCommGroup E
inst✝ : SeminormedAddCommGroup F
f : ι → E
g : ι → ℝ
a : E
b : ℝ
hf : HasSum f a
hg : HasSum g b
h : ∀ (i : ι), ‖f i‖ ≤ g i
⊢ ‖a‖ ≤ b
state_after: no goals
tactic: classical exact le_of_tendsto_of_tendsto' hf.norm hg fun _s ↦ norm_sum_le_of_le _ fun i _hi ↦ h i
Theorem: Set.pi_eq_empty_iff'
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : ∀ (i : ι), Nonempty (α i)
⊢ s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅
state_after: no goals
tactic: simp [pi_eq_empty_iff]
Theorem: CategoryTheory.Groupoid.Free.congr_reverse_comp
File: Mathlib/CategoryTheory/Groupoid/FreeGroupoid.lean

Proof steps:
state_before: V : Type u
inst✝ : Quiver V
X Y : Paths (Quiver.Symmetrify V)
p : X ⟶ Y
⊢ Quot.mk (Quotient.CompClosure redStep) (Quiver.Path.reverse p ≫ p) = Quot.mk (Quotient.CompClosure redStep) (𝟙 Y)
state_after: V : Type u
inst✝ : Quiver V
X Y : Paths (Quiver.Symmetrify V)
p : X ⟶ Y
⊢ Quot.mk (Quotient.CompClosure redStep) (Quiver.Path.reverse p ≫ (Quiver.Path.reverse p).reverse) =
    Quot.mk (Quotient.CompClosure redStep) (𝟙 Y)
tactic: nth_rw 2 [← Quiver.Path.reverse_reverse p]
state_before: V : Type u
inst✝ : Quiver V
X Y : Paths (Quiver.Symmetrify V)
p : X ⟶ Y
⊢ Quot.mk (Quotient.CompClosure redStep) (Quiver.Path.reverse p ≫ (Quiver.Path.reverse p).reverse) =
    Quot.mk (Quotient.CompClosure redStep) (𝟙 Y)
state_after: no goals
tactic: apply congr_comp_reverse
Theorem: HahnModule.smul_add
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁶ : PartialOrder Γ
inst✝⁵ : PartialOrder Γ'
inst✝⁴ : VAdd Γ Γ'
inst✝³ : IsOrderedCancelVAdd Γ Γ'
inst✝² : AddCommMonoid V
inst✝¹ : Zero R
inst✝ : DistribSMul R V
x : HahnSeries Γ R
y z : HahnModule Γ' R V
⊢ x • (y + z) = x • y + x • z
state_after: case h.h
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁶ : PartialOrder Γ
inst✝⁵ : PartialOrder Γ'
inst✝⁴ : VAdd Γ Γ'
inst✝³ : IsOrderedCancelVAdd Γ Γ'
inst✝² : AddCommMonoid V
inst✝¹ : Zero R
inst✝ : DistribSMul R V
x : HahnSeries Γ R
y z : HahnModule Γ' R V
k : Γ'
⊢ ((of R).symm (x • (y + z))).coeff k = ((of R).symm (x • y + x • z)).coeff k
tactic: ext k
state_before: case h.h
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁶ : PartialOrder Γ
inst✝⁵ : PartialOrder Γ'
inst✝⁴ : VAdd Γ Γ'
inst✝³ : IsOrderedCancelVAdd Γ Γ'
inst✝² : AddCommMonoid V
inst✝¹ : Zero R
inst✝ : DistribSMul R V
x : HahnSeries Γ R
y z : HahnModule Γ' R V
k : Γ'
⊢ ((of R).symm (x • (y + z))).coeff k = ((of R).symm (x • y + x • z)).coeff k
state_after: case h.h
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁶ : PartialOrder Γ
inst✝⁵ : PartialOrder Γ'
inst✝⁴ : VAdd Γ Γ'
inst✝³ : IsOrderedCancelVAdd Γ Γ'
inst✝² : AddCommMonoid V
inst✝¹ : Zero R
inst✝ : DistribSMul R V
x : HahnSeries Γ R
y z : HahnModule Γ' R V
k : Γ'
hwf : (((of R).symm y).support ∪ ((of R).symm z).support).IsPWO
⊢ ((of R).symm (x • (y + z))).coeff k = ((of R).symm (x • y + x • z)).coeff k
tactic: have hwf := ((of R).symm y).isPWO_support.union ((of R).symm z).isPWO_support
state_before: case h.h
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁶ : PartialOrder Γ
inst✝⁵ : PartialOrder Γ'
inst✝⁴ : VAdd Γ Γ'
inst✝³ : IsOrderedCancelVAdd Γ Γ'
inst✝² : AddCommMonoid V
inst✝¹ : Zero R
inst✝ : DistribSMul R V
x : HahnSeries Γ R
y z : HahnModule Γ' R V
k : Γ'
hwf : (((of R).symm y).support ∪ ((of R).symm z).support).IsPWO
⊢ ((of R).symm (x • (y + z))).coeff k = ((of R).symm (x • y + x • z)).coeff k
state_after: case h.h
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁶ : PartialOrder Γ
inst✝⁵ : PartialOrder Γ'
inst✝⁴ : VAdd Γ Γ'
inst✝³ : IsOrderedCancelVAdd Γ Γ'
inst✝² : AddCommMonoid V
inst✝¹ : Zero R
inst✝ : DistribSMul R V
x : HahnSeries Γ R
y z : HahnModule Γ' R V
k : Γ'
hwf : (((of R).symm y).support ∪ ((of R).symm z).support).IsPWO
⊢ ∑ ij ∈ VAddAntidiagonal ⋯ hwf k, x.coeff ij.1 • ((of R).symm y + (of R).symm z).coeff ij.2 =
    ((of R).symm (x • y + x • z)).coeff k

case h.h
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁶ : PartialOrder Γ
inst✝⁵ : PartialOrder Γ'
inst✝⁴ : VAdd Γ Γ'
inst✝³ : IsOrderedCancelVAdd Γ Γ'
inst✝² : AddCommMonoid V
inst✝¹ : Zero R
inst✝ : DistribSMul R V
x : HahnSeries Γ R
y z : HahnModule Γ' R V
k : Γ'
hwf : (((of R).symm y).support ∪ ((of R).symm z).support).IsPWO
⊢ ((of R).symm (y + z)).support ⊆ ((of R).symm y).support ∪ ((of R).symm z).support
tactic: rw [smul_coeff_right hwf, of_symm_add]
Theorem: DiscreteValuationRing.addVal_def
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
r : R
u : Rˣ
ϖ : R
hϖ : Irreducible ϖ
n : ℕ
hr : r = ↑u * ϖ ^ n
⊢ (addVal R) r = ↑n
state_after: no goals
tactic: rw [addVal, addValuation_apply, hr, eq_of_associated_left
      (associated_of_irreducible R hϖ (Classical.choose_spec (exists_prime R)).irreducible),
    eq_of_associated_right (Associated.symm ⟨u, mul_comm _ _⟩),
    multiplicity_pow_self_of_prime (irreducible_iff_prime.1 hϖ)]
Theorem: Multiset.sup_add
File: Mathlib/Data/Multiset/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s₁ s₂ : Multiset α
⊢ (s₁ + s₂).sup = fold (fun x x_1 => x ⊔ x_1) (⊥ ⊔ ⊥) (s₁ + s₂)
state_after: no goals
tactic: simp [sup]
Theorem: CategoryTheory.ShortComplex.opcycles_ext
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : S.HasRightHomology
A : C
f₁ f₂ : S.opcycles ⟶ A
h : S.pOpcycles ≫ f₁ = S.pOpcycles ≫ f₂
⊢ f₁ = f₂
state_after: no goals
tactic: simpa only [opcycles_ext_iff]
Theorem: ite_lt_one
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a b : α
inst✝ : LT α
ha : a < 1
hb : b < 1
⊢ (if p then a else b) < 1
state_after: no goals
tactic: split <;> assumption
Theorem: Filter.tendsto_cocompact_mul_left
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : b * a = 1
⊢ Tendsto (fun x => a * x) (cocompact M) (cocompact M)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : b * a = 1
⊢ Tendsto ((fun b_1 => b * b_1) ∘ fun x => a * x) (cocompact M) (cocompact M)
tactic: refine Filter.Tendsto.of_tendsto_comp ?_ (Filter.comap_cocompact_le (continuous_mul_left b))
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : b * a = 1
⊢ Tendsto ((fun b_1 => b * b_1) ∘ fun x => a * x) (cocompact M) (cocompact M)
state_after: case h.e'_3
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : b * a = 1
⊢ ((fun b_1 => b * b_1) ∘ fun x => a * x) = id
tactic: convert Filter.tendsto_id
state_before: case h.e'_3
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : b * a = 1
⊢ ((fun b_1 => b * b_1) ∘ fun x => a * x) = id
state_after: case h.e'_3.h
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : b * a = 1
x : M
⊢ ((fun b_1 => b * b_1) ∘ fun x => a * x) x = id x
tactic: ext x
state_before: case h.e'_3.h
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : b * a = 1
x : M
⊢ ((fun b_1 => b * b_1) ∘ fun x => a * x) x = id x
state_after: no goals
tactic: simp [← mul_assoc, ha]
Theorem: TopCat.pullbackIsoProdSubtype_hom_apply
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ f ((pullback.fst f g) x, (pullback.snd f g) x).1 = g ((pullback.fst f g) x, (pullback.snd f g) x).2
state_after: no goals
tactic: simpa using ConcreteCategory.congr_hom pullback.condition x
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (pullbackIsoProdSubtype f g).hom x = ⟨((pullback.fst f g) x, (pullback.snd f g) x), ⋯⟩
state_after: case a
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ ↑((pullbackIsoProdSubtype f g).hom x) = ↑⟨((pullback.fst f g) x, (pullback.snd f g) x), ⋯⟩
tactic: apply Subtype.ext
state_before: case a
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ ↑((pullbackIsoProdSubtype f g).hom x) = ↑⟨((pullback.fst f g) x, (pullback.snd f g) x), ⋯⟩
state_after: case a.a
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (↑((pullbackIsoProdSubtype f g).hom x)).1 = (↑⟨((pullback.fst f g) x, (pullback.snd f g) x), ⋯⟩).1

case a.a
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (↑((pullbackIsoProdSubtype f g).hom x)).2 = (↑⟨((pullback.fst f g) x, (pullback.snd f g) x), ⋯⟩).2
tactic: apply Prod.ext
state_before: case a.a
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (↑((pullbackIsoProdSubtype f g).hom x)).1 = (↑⟨((pullback.fst f g) x, (pullback.snd f g) x), ⋯⟩).1

case a.a
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : ConcreteCategory.forget.obj (pullback f g)
⊢ (↑((pullbackIsoProdSubtype f g).hom x)).2 = (↑⟨((pullback.fst f g) x, (pullback.snd f g) x), ⋯⟩).2
state_after: no goals
tactic: exacts [ConcreteCategory.congr_hom (pullbackIsoProdSubtype_hom_fst f g) x,
    ConcreteCategory.congr_hom (pullbackIsoProdSubtype_hom_snd f g) x]
Theorem: Multiset.prod_le_pow_card
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s✝ t : Multiset α
a : α
s : Multiset α
n : α
h : ∀ x ∈ s, x ≤ n
⊢ s.prod ≤ n ^ card s
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a n : α
a✝ : List α
h : ∀ x ∈ ⟦a✝⟧, x ≤ n
⊢ prod ⟦a✝⟧ ≤ n ^ card ⟦a✝⟧
tactic: induction s using Quotient.inductionOn
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a n : α
a✝ : List α
h : ∀ x ∈ ⟦a✝⟧, x ≤ n
⊢ prod ⟦a✝⟧ ≤ n ^ card ⟦a✝⟧
state_after: no goals
tactic: simpa using List.prod_le_pow_card _ _ h
Theorem: Finset.filter_inter_filter_neg_eq
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s t : Finset α
⊢ filter p s ∩ filter (fun a => ¬p a) t = ∅
state_after: no goals
tactic: simpa using (disjoint_filter_filter_neg s t p).eq_bot
Theorem: Set.range_sigma_eq_iUnion_range
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ✝ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
γ : α → Type u_11
f : Sigma γ → β
⊢ ∀ (x : β), x ∈ range f ↔ x ∈ ⋃ a, range fun b => f ⟨a, b⟩
state_after: no goals
tactic: simp
Theorem: SimpleGraph.IsSRGWith.card_neighborFinset_union_eq
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

Proof steps:
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card + Fintype.card ↑(G.commonNeighbors v w) =
    2 * k - Fintype.card ↑(G.commonNeighbors v w) + Fintype.card ↑(G.commonNeighbors v w)
tactic: apply Nat.add_right_cancel (m := Fintype.card (G.commonNeighbors v w))
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card + Fintype.card ↑(G.commonNeighbors v w) =
    2 * k - Fintype.card ↑(G.commonNeighbors v w) + Fintype.card ↑(G.commonNeighbors v w)
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card + (G.commonNeighbors v w).toFinset.card = 2 * k

V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ Fintype.card ↑(G.commonNeighbors v w) ≤ 2 * k
tactic: rw [Nat.sub_add_cancel, ← Set.toFinset_card]
Theorem: FiniteDimensional.finrank_fin_fun
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹³ : Ring R
inst✝¹² : CommRing S
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R M
inst✝⁷ : Module R M'
inst✝⁶ : Module R M₁
inst✝⁵ : StrongRankCondition R
inst✝⁴ : Module.Free R M
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module R (φ i)
inst✝¹ : ∀ (i : η), Module.Free R (φ i)
inst✝ : Fintype η
n : ℕ
⊢ finrank R (Fin n → R) = n
state_after: no goals
tactic: simp
Theorem: Subgroup.map_le_map_iff_of_injective
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ f : G →* N
hf : Injective ⇑f
H K : Subgroup G
⊢ map f H ≤ map f K ↔ H ≤ K
state_after: no goals
tactic: rw [map_le_iff_le_comap, comap_map_eq_self_of_injective hf]
Theorem: Matroid.indep_iff_not_dep
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
⊢ M.Indep I ↔ ¬M.Dep I ∧ I ⊆ M.E
state_after: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
⊢ M.Indep I ↔ (I ⊆ M.E → M.Indep I) ∧ I ⊆ M.E
tactic: rw [dep_iff, not_and, not_imp_not]
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
⊢ M.Indep I ↔ (I ⊆ M.E → M.Indep I) ∧ I ⊆ M.E
state_after: no goals
tactic: exact ⟨fun h ↦ ⟨fun _ ↦ h, h.subset_ground⟩, fun h ↦ h.1 h.2⟩