ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Equiv.Perm.isConj_iff_cycleType_eq
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : IsConj σ τ
⊢ σ.cycleType = τ.cycleType
state_after: case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ π : Perm α
h : IsConj σ (π * σ * π⁻¹)
⊢ σ.cycleType = (π * σ * π⁻¹).cycleType
tactic: obtain ⟨π, rfl⟩ := isConj_iff.1 h
state_before: case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ π : Perm α
h : IsConj σ (π * σ * π⁻¹)
⊢ σ.cycleType = (π * σ * π⁻¹).cycleType
state_after: no goals
tactic: rw [cycleType_conj]
Theorem: AdicCompletion.map_ext''
File: Mathlib/RingTheory/AdicCompletion/Functoriality.lean

Proof steps:
state_before: R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[R] N
h : f ∘ₗ mk I M = g ∘ₗ mk I M
⊢ f = g
state_after: case h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[R] N
h : f ∘ₗ mk I M = g ∘ₗ mk I M
x : AdicCompletion I M
⊢ f x = g x
tactic: ext x
state_before: case h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[R] N
h : f ∘ₗ mk I M = g ∘ₗ mk I M
x : AdicCompletion I M
⊢ f x = g x
state_after: no goals
tactic: apply induction_on I M x (fun a ↦ LinearMap.ext_iff.mp h a)
Theorem: MeasureTheory.integrable_prod_iff
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
f : α × β → E
h1f : AEStronglyMeasurable f (μ.prod ν)
⊢ Integrable f (μ.prod ν) ↔
    (∀ᵐ (x : α) ∂μ, Integrable (fun y => f (x, y)) ν) ∧ Integrable (fun x => ∫ (y : β), ‖f (x, y)‖ ∂ν) μ
state_after: no goals
tactic: simp [Integrable, h1f, hasFiniteIntegral_prod_iff', h1f.norm.integral_prod_right',
    h1f.prod_mk_left]
Theorem: AlgHomClass.unitization_injective
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

Proof steps:
state_before: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
⊢ Function.Injective ⇑f
state_after: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
r : R
hr : r ≠ 0
hr' : (algebraMap R A) r ∈ s
⊢ False
tactic: refine AlgHomClass.unitization_injective' s (fun r hr hr' ↦ ?_) f hf
state_before: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
r : R
hr : r ≠ 0
hr' : (algebraMap R A) r ∈ s
⊢ False
state_after: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
r : R
hr : r ≠ 0
hr' : r • 1 ∈ s
⊢ False
tactic: rw [Algebra.algebraMap_eq_smul_one] at hr'
state_before: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
r : R
hr : r ≠ 0
hr' : r • 1 ∈ s
⊢ False
state_after: no goals
tactic: exact h1 <| inv_smul_smul₀ hr (1 : A) ▸ SMulMemClass.smul_mem r⁻¹ hr'
Theorem: PartialEquiv.trans_refl_restr
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 β γ
s : Set β
⊢ (e.trans ((PartialEquiv.refl β).restr s)).source = (e.restr (↑e ⁻¹' s)).source
state_after: no goals
tactic: simp [trans_source]
Theorem: isCompact_iff_isCompact_univ
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ IsCompact s ↔ IsCompact univ
state_after: no goals
tactic: rw [Subtype.isCompact_iff, image_univ, Subtype.range_coe]
Theorem: Matroid.flat_iff_isClosed
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
⊢ M.Flat F ↔ ∃ (h : F ⊆ M.E), M.subtypeClosure.IsClosed ⟨F, h⟩
state_after: no goals
tactic: simpa [subtypeClosure] using Flat.subset_ground
Theorem: CompositionSeries.eq_of_head_eq_head_of_last_eq_last_of_length_eq_zero
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hs₁0 : s₁.length = 0
⊢ s₁ = s₂
state_after: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hs₁0 : s₁.length = 0
this : ∀ (x : X), x ∈ s₁ ↔ x = last s₁
⊢ s₁ = s₂
tactic: have : ∀ x, x ∈ s₁ ↔ x = s₁.last := fun x =>
    ⟨fun hx =>  subsingleton_of_length_eq_zero hs₁0 hx s₁.last_mem, fun hx => hx.symm ▸ s₁.last_mem⟩
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hs₁0 : s₁.length = 0
this : ∀ (x : X), x ∈ s₁ ↔ x = last s₁
⊢ s₁ = s₂
state_after: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hs₁0 : s₁.length = 0
this✝ : ∀ (x : X), x ∈ s₁ ↔ x = last s₁
this : ∀ (x : X), x ∈ s₂ ↔ x = last s₂
⊢ s₁ = s₂
tactic: have : ∀ x, x ∈ s₂ ↔ x = s₂.last := fun x =>
    ⟨fun hx =>
      subsingleton_of_length_eq_zero
        (length_eq_zero_of_head_eq_head_of_last_eq_last_of_length_eq_zero hb ht
          hs₁0) hx s₂.last_mem,
      fun hx => hx.symm ▸ s₂.last_mem⟩
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hs₁0 : s₁.length = 0
this✝ : ∀ (x : X), x ∈ s₁ ↔ x = last s₁
this : ∀ (x : X), x ∈ s₂ ↔ x = last s₂
⊢ s₁ = s₂
state_after: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hs₁0 : s₁.length = 0
this✝ : ∀ (x : X), x ∈ s₁ ↔ x = last s₁
this : ∀ (x : X), x ∈ s₂ ↔ x = last s₂
x✝ : X
⊢ x✝ ∈ s₁ ↔ x✝ ∈ s₂
tactic: ext
state_before: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hs₁0 : s₁.length = 0
this✝ : ∀ (x : X), x ∈ s₁ ↔ x = last s₁
this : ∀ (x : X), x ∈ s₂ ↔ x = last s₂
x✝ : X
⊢ x✝ ∈ s₁ ↔ x✝ ∈ s₂
state_after: no goals
tactic: simp [*]
Theorem: String.extract.go₁_append_right
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: t : List Char
i : Nat
e : Pos
⊢ go₁ ([] ++ t) { byteIdx := i } { byteIdx := utf8Len [] + i } e = go₂ t { byteIdx := utf8Len [] + i } e
state_after: no goals
tactic: cases t <;> simp [go₁, go₂]
state_before: c : Char
cs t : List Char
i : Nat
e : Pos
⊢ go₁ (c :: cs ++ t) { byteIdx := i } { byteIdx := utf8Len (c :: cs) + i } e =
    go₂ t { byteIdx := utf8Len (c :: cs) + i } e
state_after: c : Char
cs t : List Char
i : Nat
e : Pos
⊢ go₁ (cs ++ t) { byteIdx := i + c.utf8Size } { byteIdx := utf8Len cs + c.utf8Size + i } e =
    go₂ t { byteIdx := utf8Len cs + c.utf8Size + i } e
tactic: simp only [go₁, utf8Len_cons, Pos.ext_iff, ne_add_csize_add_self, ↓reduceIte, List.append_eq,
    Pos.addChar_eq]
state_before: c : Char
cs t : List Char
i : Nat
e : Pos
⊢ go₁ (cs ++ t) { byteIdx := i + c.utf8Size } { byteIdx := utf8Len cs + c.utf8Size + i } e =
    go₂ t { byteIdx := utf8Len cs + c.utf8Size + i } e
state_after: case a
c : Char
cs t : List Char
i : Nat
e : Pos
⊢ utf8Len cs + c.utf8Size + i = utf8Len cs + (i + c.utf8Size)
tactic: apply go₁_append_right
state_before: case a
c : Char
cs t : List Char
i : Nat
e : Pos
⊢ utf8Len cs + c.utf8Size + i = utf8Len cs + (i + c.utf8Size)
state_after: no goals
tactic: rw [Nat.add_right_comm, Nat.add_assoc]
Theorem: Trivialization.mk_coordChange
File: Mathlib/Topology/FiberBundle/Trivialization.lean

Proof steps:
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace F E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ (b, e₁.coordChange e₂ b x) = ↑e₂ (↑e₁.symm (b, x))
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace F E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ (b, e₁.coordChange e₂ b x).1 = (↑e₂ (↑e₁.symm (b, x))).1
tactic: refine Prod.ext ?_ rfl
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace F E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ (b, e₁.coordChange e₂ b x).1 = (↑e₂ (↑e₁.symm (b, x))).1
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace F E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ proj (↑e₁.symm (b, x)) ∈ e₁.baseSet

ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace F E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ proj (↑e₁.symm (b, x)) ∈ e₂.baseSet
tactic: rw [e₂.coe_fst', ← e₁.coe_fst', e₁.apply_symm_apply' h₁]
Theorem: UniformFun.precomp_uniformContinuous
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ UniformContinuous fun g => ofFun (toFun g ∘ f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ ∀ ib ∈ 𝓤 β,
    ∃ ia ∈ 𝓤 β, ∀ x ∈ UniformFun.gen α β ia, (ofFun (toFun x.1 ∘ f), ofFun (toFun x.2 ∘ f)) ∈ UniformFun.gen γ β ib
tactic: rw [UniformContinuous,
      (UniformFun.hasBasis_uniformity α β).tendsto_iff (UniformFun.hasBasis_uniformity γ β)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ ∀ ib ∈ 𝓤 β,
    ∃ ia ∈ 𝓤 β, ∀ x ∈ UniformFun.gen α β ia, (ofFun (toFun x.1 ∘ f), ofFun (toFun x.2 ∘ f)) ∈ UniformFun.gen γ β ib
state_after: no goals
tactic: exact fun U hU => ⟨U, hU, fun uv huv x => huv (f x)⟩
Theorem: Finset.disjoint_sup_right
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s : Finset ι
t : Finset κ
f : ι → α
g : κ → α
a : α
⊢ _root_.Disjoint a (s.sup f) ↔ ∀ ⦃i : ι⦄, i ∈ s → _root_.Disjoint a (f i)
state_after: no goals
tactic: simp only [disjoint_iff, sup_inf_distrib_left, Finset.sup_eq_bot_iff]
Theorem: MeasureTheory.univ_mem_measurableCylinders
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_2
α✝ : ι → Type ?u.38171
inst✝¹ : (i : ι) → MeasurableSpace (α✝ i)
s t : Set ((i : ι) → α✝ i)
α : ι → Type u_1
inst✝ : (i : ι) → MeasurableSpace (α i)
⊢ univ ∈ measurableCylinders α
state_after: ι : Type u_2
α✝ : ι → Type ?u.38171
inst✝¹ : (i : ι) → MeasurableSpace (α✝ i)
s t : Set ((i : ι) → α✝ i)
α : ι → Type u_1
inst✝ : (i : ι) → MeasurableSpace (α i)
⊢ ∅ᶜ ∈ measurableCylinders α
tactic: rw [← compl_empty]
state_before: ι : Type u_2
α✝ : ι → Type ?u.38171
inst✝¹ : (i : ι) → MeasurableSpace (α✝ i)
s t : Set ((i : ι) → α✝ i)
α : ι → Type u_1
inst✝ : (i : ι) → MeasurableSpace (α i)
⊢ ∅ᶜ ∈ measurableCylinders α
state_after: no goals
tactic: exact compl_mem_measurableCylinders (empty_mem_measurableCylinders α)
Theorem: Mathlib.Tactic.Ring.smul_nat
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a✝ a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c✝ c₁ c₂ : R
a b c : ℕ
x✝ : a * b = c
⊢ a • b = c
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a✝ a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R
a b : ℕ
⊢ a • b = a * b
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a✝ a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R
a b : ℕ
⊢ a • b = a * b
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.biproduct.map_eq
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J : Type
inst✝² : Fintype J
f✝ : J → C
inst✝¹ : HasBiproduct f✝
inst✝ : HasFiniteBiproducts C
f g : J → C
h : (j : J) → f j ⟶ g j
⊢ map h = ∑ j : J, π f j ≫ h j ≫ ι g j
state_after: case w.w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J : Type
inst✝² : Fintype J
f✝ : J → C
inst✝¹ : HasBiproduct f✝
inst✝ : HasFiniteBiproducts C
f g : J → C
h : (j : J) → f j ⟶ g j
j✝¹ j✝ : J
⊢ ι f j✝ ≫ map h ≫ π g j✝¹ = ι f j✝ ≫ (∑ j : J, π f j ≫ h j ≫ ι g j) ≫ π g j✝¹
tactic: ext
state_before: case w.w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J : Type
inst✝² : Fintype J
f✝ : J → C
inst✝¹ : HasBiproduct f✝
inst✝ : HasFiniteBiproducts C
f g : J → C
h : (j : J) → f j ⟶ g j
j✝¹ j✝ : J
⊢ ι f j✝ ≫ map h ≫ π g j✝¹ = ι f j✝ ≫ (∑ j : J, π f j ≫ h j ≫ ι g j) ≫ π g j✝¹
state_after: no goals
tactic: simp [biproduct.ι_π, biproduct.ι_π_assoc, comp_sum, sum_comp, comp_dite, dite_comp]
Theorem: Function.LeftInverse.filter_comap
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInverse g f
F : Filter α
⊢ comap f (comap g F) = F
state_after: no goals
tactic: rw [comap_comap, hfg.comp_eq_id, comap_id]
Theorem: Ideal.le_of_pow_le_prime
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
⊢ I ≤ P
state_after: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
hP0 : P = ⊥
⊢ I ≤ P

case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
hP0 : ¬P = ⊥
⊢ I ≤ P
tactic: by_cases hP0 : P = ⊥
state_before: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : I ^ n ≤ P
hP0 : ¬P = ⊥
⊢ I ≤ P
state_after: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : P ∣ I ^ n
hP0 : ¬P = ⊥
⊢ P ∣ I
tactic: rw [← Ideal.dvd_iff_le] at h ⊢
state_before: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I P : Ideal R
hP : P.IsPrime
n : ℕ
h : P ∣ I ^ n
hP0 : ¬P = ⊥
⊢ P ∣ I
state_after: no goals
tactic: exact ((Ideal.prime_iff_isPrime hP0).mpr hP).dvd_of_dvd_pow h
Theorem: Filter.prod_eq_bot
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
⊢ f ×ˢ g = ⊥ ↔ f = ⊥ ∨ g = ⊥
state_after: no goals
tactic: simp_rw [← empty_mem_iff_bot, mem_prod_iff, subset_empty_iff, prod_eq_empty_iff, ← exists_prop,
    Subtype.exists', exists_or, exists_const, Subtype.exists, exists_prop, exists_eq_right]
Theorem: Bool.le_and
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ∀ {x y z : Bool}, x ≤ y → x ≤ z → x ≤ (y && z)
state_after: no goals
tactic: decide
Theorem: Set.image_const_add_Ici
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Ici b = Ici (a + b)
state_after: no goals
tactic: simp only [add_comm a, image_add_const_Ici]
Theorem: Polynomial.not_isField
File: Mathlib/Algebra/Polynomial/Div.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
⊢ ¬IsField R[X]
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
⊢ ¬IsField R[X]
tactic: nontriviality R
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
⊢ ¬IsField R[X]
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
h : IsField R[X]
⊢ False
tactic: intro h
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
h : IsField R[X]
⊢ False
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
h : IsField R[X]
this : Field R[X] := h.toField
⊢ False
tactic: letI := h.toField
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
h : IsField R[X]
this : Field R[X] := h.toField
⊢ False
state_after: no goals
tactic: simpa using congr_arg natDegree (monic_X.eq_one_of_isUnit <| monic_X (R := R).ne_zero.isUnit)
Theorem: CategoryTheory.Sheaf.Hom.mono_iff_presheaf_mono
File: Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean

Proof steps:
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
F G : Sheaf J D
f : F ⟶ G
m : Mono f
⊢ Mono f.val
state_after: no goals
tactic: infer_instance
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
F G : Sheaf J D
f : F ⟶ G
m : Mono f.val
⊢ Mono f
state_after: no goals
tactic: exact Sheaf.Hom.mono_of_presheaf_mono J D f
Theorem: Multiset.mem_powersetCardAux
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
n : ℕ
l : List α
s : Multiset α
⊢ ∀ (a : List α), ⟦a⟧ ∈ powersetCardAux n l ↔ ⟦a⟧ ≤ ↑l ∧ card ⟦a⟧ = n
state_after: α : Type u_1
n : ℕ
l : List α
s : Multiset α
⊢ ∀ (a : List α), (∃ a_1, (a_1 <+ l ∧ a_1.length = n) ∧ a_1 ~ a) ↔ (∃ l_1, l_1 ~ a ∧ l_1 <+ l) ∧ a.length = n
tactic: simp only [quot_mk_to_coe, powersetCardAux_eq_map_coe, List.mem_map, mem_sublistsLen,
      coe_eq_coe, coe_le, Subperm, exists_prop, coe_card]
state_before: α : Type u_1
n : ℕ
l : List α
s : Multiset α
⊢ ∀ (a : List α), (∃ a_1, (a_1 <+ l ∧ a_1.length = n) ∧ a_1 ~ a) ↔ (∃ l_1, l_1 ~ a ∧ l_1 <+ l) ∧ a.length = n
state_after: no goals
tactic: exact fun l₁ =>
      ⟨fun ⟨l₂, ⟨s, e⟩, p⟩ => ⟨⟨_, p, s⟩, p.symm.length_eq.trans e⟩,
       fun ⟨⟨l₂, p, s⟩, e⟩ => ⟨_, ⟨s, p.length_eq.trans e⟩, p⟩⟩
Theorem: List.get_reverse_aux₂
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l r : List α
i : ℕ
h1 : l.length - 1 - i < (l.reverseAux r).length
h2 : i < l.length
⊢ (l.reverseAux r).get ⟨l.length - 1 - i, h1⟩ = l.get ⟨i, h2⟩
state_after: no goals
tactic: simp [getElem_reverse_aux₂, h1, h2]
Theorem: Filter.HasBasis.exists_inter_eq_singleton_of_mem_discrete
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ι : Type u_3
p : ι → Prop
t : ι → Set X
s : Set X
inst✝ : DiscreteTopology ↑s
x : X
hb : (𝓝 x).HasBasis p t
hx : x ∈ s
⊢ ∃ i, p i ∧ t i ∩ s = {x}
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ι : Type u_3
p : ι → Prop
t : ι → Set X
s : Set X
inst✝ : DiscreteTopology ↑s
x : X
hb : (𝓝 x).HasBasis p t
hx : x ∈ s
i : ι
hi : p i
hix : t i ∩ s ⊆ {x}
⊢ ∃ i, p i ∧ t i ∩ s = {x}
tactic: rcases (nhdsWithin_hasBasis hb s).mem_iff.1 (singleton_mem_nhdsWithin_of_mem_discrete hx) with
    ⟨i, hi, hix⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ι : Type u_3
p : ι → Prop
t : ι → Set X
s : Set X
inst✝ : DiscreteTopology ↑s
x : X
hb : (𝓝 x).HasBasis p t
hx : x ∈ s
i : ι
hi : p i
hix : t i ∩ s ⊆ {x}
⊢ ∃ i, p i ∧ t i ∩ s = {x}
state_after: no goals
tactic: exact ⟨i, hi, hix.antisymm <| singleton_subset_iff.2 ⟨mem_of_mem_nhds <| hb.mem_of_mem hi, hx⟩⟩