ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: EMetric.diam_union'
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ t : Set α
h : (s ∩ t).Nonempty
⊢ diam (s ∪ t) ≤ diam s + diam t
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ t : Set α
h : (s ∩ t).Nonempty
x : α
xs : x ∈ s
xt : x ∈ t
⊢ diam (s ∪ t) ≤ diam s + diam t
tactic: let ⟨x, ⟨xs, xt⟩⟩ := h
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ t : Set α
h : (s ∩ t).Nonempty
x : α
xs : x ∈ s
xt : x ∈ t
⊢ diam (s ∪ t) ≤ diam s + diam t
state_after: no goals
tactic: simpa using diam_union xs xt
Theorem: Finset.Shatters.subset_iff
File: Mathlib/Combinatorics/SetFamily/Shatter.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
⊢ (∃ u ∈ 𝒜, s ∩ u = t) → t ⊆ s
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
u : Finset α
left✝ : u ∈ 𝒜
⊢ s ∩ u ⊆ s
tactic: rintro ⟨u, _, rfl⟩
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
u : Finset α
left✝ : u ∈ 𝒜
⊢ s ∩ u ⊆ s
state_after: no goals
tactic: exact inter_subset_left
Theorem: FreeAddGroup.mk_toWord
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
⊢ ∀ {x : FreeGroup α}, mk x.toWord = x
state_after: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x✝ : FreeGroup α
L : List (α × Bool)
⊢ mk (toWord (Quot.mk Red.Step L)) = Quot.mk Red.Step L
tactic: rintro ⟨L⟩
state_before: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x✝ : FreeGroup α
L : List (α × Bool)
⊢ mk (toWord (Quot.mk Red.Step L)) = Quot.mk Red.Step L
state_after: no goals
tactic: exact reduce.self
Theorem: LieModule.nontrivial_lowerCentralSeriesLast
File: Mathlib/Algebra/Lie/Nilpotent.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
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₂
inst✝³ : LieRingModule L M₂
inst✝² : LieModule R L M₂
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
⊢ Nontrivial ↥↑(lowerCentralSeriesLast R L M)
state_after: 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
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₂
inst✝³ : LieRingModule L M₂
inst✝² : LieModule R L M₂
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
⊢ (match nilpotencyLength R L M with
    | 0 => ⊥
    | k.succ => lowerCentralSeries R L M k) ≠
    ⊥
tactic: rw [LieSubmodule.nontrivial_iff_ne_bot, lowerCentralSeriesLast]
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
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₂
inst✝³ : LieRingModule L M₂
inst✝² : LieModule R L M₂
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
⊢ (match nilpotencyLength R L M with
    | 0 => ⊥
    | k.succ => lowerCentralSeries R L M k) ≠
    ⊥
state_after: case zero
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
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₂
inst✝³ : LieRingModule L M₂
inst✝² : LieModule R L M₂
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
h : nilpotencyLength R L M = 0
⊢ (match 0 with
    | 0 => ⊥
    | k.succ => lowerCentralSeries R L M k) ≠
    ⊥

case succ
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
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₂
inst✝³ : LieRingModule L M₂
inst✝² : LieModule R L M₂
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
n✝ : ℕ
h : nilpotencyLength R L M = n✝ + 1
⊢ (match n✝ + 1 with
    | 0 => ⊥
    | k.succ => lowerCentralSeries R L M k) ≠
    ⊥
tactic: cases h : nilpotencyLength R L M
Theorem: Complex.cosh_sub
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cosh (x - y) = cosh x * cosh y - sinh x * sinh y
state_after: no goals
tactic: simp [sub_eq_add_neg, cosh_add, sinh_neg, cosh_neg]
Theorem: MeasureTheory.SimpleFunc.le_sup_lintegral
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ (map Prod.fst (f.pair g)).lintegral μ ⊔ (map Prod.snd (f.pair g)).lintegral μ ≤
    ∑ x ∈ (f.pair g).range, (x.1 ⊔ x.2) * μ (↑(f.pair g) ⁻¹' {x})
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ (∑ x ∈ (f.pair g).range, x.1 * μ (↑(f.pair g) ⁻¹' {x})) ⊔ ∑ x ∈ (f.pair g).range, x.2 * μ (↑(f.pair g) ⁻¹' {x}) ≤
    ∑ x ∈ (f.pair g).range, (x.1 ⊔ x.2) * μ (↑(f.pair g) ⁻¹' {x})
tactic: rw [map_lintegral, map_lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ (∑ x ∈ (f.pair g).range, x.1 * μ (↑(f.pair g) ⁻¹' {x})) ⊔ ∑ x ∈ (f.pair g).range, x.2 * μ (↑(f.pair g) ⁻¹' {x}) ≤
    ∑ x ∈ (f.pair g).range, (x.1 ⊔ x.2) * μ (↑(f.pair g) ⁻¹' {x})
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ (f.pair g).range
⊢ a.1 ≤ a.1 ⊔ a.2

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ (f.pair g).range
⊢ a.2 ≤ a.1 ⊔ a.2
tactic: refine sup_le ?_ ?_ <;> refine Finset.sum_le_sum fun a _ => mul_le_mul_right' ?_ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ ∑ x ∈ (f.pair g).range, (x.1 ⊔ x.2) * μ (↑(f.pair g) ⁻¹' {x}) = (f ⊔ g).lintegral μ
state_after: no goals
tactic: rw [sup_eq_map₂, map_lintegral]
Theorem: MeasureTheory.cylinder_eq_empty_iff
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
⊢ cylinder s S = ∅ ↔ S = ∅
state_after: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
⊢ S = ∅
tactic: refine ⟨fun h ↦ ?_, fun h ↦ by (rw [h]; exact cylinder_empty _)⟩
state_before: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
⊢ S = ∅
state_after: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
hS : ¬S = ∅
⊢ False
tactic: by_contra hS
state_before: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
hS : ¬S = ∅
⊢ False
state_after: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
hS : S.Nonempty
⊢ False
tactic: rw [← Ne, ← nonempty_iff_ne_empty] at hS
state_before: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
hS : S.Nonempty
⊢ False
state_after: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
hS : S.Nonempty
f : (i : { x // x ∈ s }) → α ↑i := hS.some
⊢ False
tactic: let f := hS.some
state_before: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
hS : S.Nonempty
f : (i : { x // x ∈ s }) → α ↑i := hS.some
⊢ False
state_after: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
hS : S.Nonempty
f : (i : { x // x ∈ s }) → α ↑i := hS.some
hf : f ∈ S
⊢ False
tactic: have hf : f ∈ S := hS.choose_spec
state_before: ι : Type u_1
α : ι → Type u_2
h_nonempty : Nonempty ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
h : cylinder s S = ∅
hS : S.Nonempty
f : (i : { x // x ∈ s }) → α ↑i := hS.some
hf : f ∈ S
⊢ False
state_after: no goals
tactic: classical
  let f' : ∀ i, α i := fun i ↦ if hi : i ∈ s then f ⟨i, hi⟩ else h_nonempty.some i
  have hf' : f' ∈ cylinder s S := by
    rw [mem_cylinder]
    simpa only [f', Finset.coe_mem, dif_pos]
  rw [h] at hf'
  exact not_mem_empty _ hf'
Theorem: LinearMap.trace_mul_cycle
File: Mathlib/LinearAlgebra/Trace.lean

Proof steps:
state_before: R : Type u
inst✝⁶ : CommSemiring R
M : Type v
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
ι : Type w
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : Fintype κ
b : Basis ι R M
c : Basis κ R M
f g h : M →ₗ[R] M
⊢ (trace R M) (f * g * h) = (trace R M) (h * f * g)
state_after: no goals
tactic: rw [LinearMap.trace_mul_comm, ← mul_assoc]
Theorem: lie_sub
File: Mathlib/Algebra/Lie/Basic.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
t : R
x y z : L
m n : M
⊢ ⁅x, m - n⁆ = ⁅x, m⁆ - ⁅x, n⁆
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: LinearMap.polyCharpolyAux_map_eq_charpoly
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹² : CommRing R
inst✝¹¹ : AddCommGroup L
inst✝¹⁰ : Module R L
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : Fintype ιM
inst✝⁴ : DecidableEq ι
inst✝³ : DecidableEq ι'
inst✝² : DecidableEq ιM
b : Basis ι R L
bₘ : Basis ιM R M
inst✝¹ : Module.Finite R M
inst✝ : Module.Free R M
x : L
⊢ Polynomial.map (MvPolynomial.eval ⇑(b.repr x)) (φ.polyCharpolyAux b bₘ) = charpoly (φ x)
state_after: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹² : CommRing R
inst✝¹¹ : AddCommGroup L
inst✝¹⁰ : Module R L
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : Fintype ιM
inst✝⁴ : DecidableEq ι
inst✝³ : DecidableEq ι'
inst✝² : DecidableEq ιM
b : Basis ι R L
bₘ : Basis ιM R M
inst✝¹ : Module.Finite R M
inst✝ : Module.Free R M
x : L
a✝ : Nontrivial R
⊢ Polynomial.map (MvPolynomial.eval ⇑(b.repr x)) (φ.polyCharpolyAux b bₘ) = charpoly (φ x)
tactic: nontriviality R
state_before: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹² : CommRing R
inst✝¹¹ : AddCommGroup L
inst✝¹⁰ : Module R L
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : Fintype ιM
inst✝⁴ : DecidableEq ι
inst✝³ : DecidableEq ι'
inst✝² : DecidableEq ιM
b : Basis ι R L
bₘ : Basis ιM R M
inst✝¹ : Module.Finite R M
inst✝ : Module.Free R M
x : L
a✝ : Nontrivial R
⊢ Polynomial.map (MvPolynomial.eval ⇑(b.repr x)) (φ.polyCharpolyAux b bₘ) = charpoly (φ x)
state_after: no goals
tactic: rw [polyCharpolyAux_map_eq_toMatrix_charpoly, LinearMap.charpoly_toMatrix]
Theorem: omegaLimit_iUnion
File: Mathlib/Dynamics/OmegaLimit.lean

Proof steps:
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
p : ι → Set α
⊢ ⋃ i, ω f ϕ (p i) ⊆ ω f ϕ (⋃ i, p i)
state_after: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
p : ι → Set α
⊢ ∀ (i : ι), ω f ϕ (p i) ⊆ ω f ϕ (⋃ i, p i)
tactic: rw [iUnion_subset_iff]
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
p : ι → Set α
⊢ ∀ (i : ι), ω f ϕ (p i) ⊆ ω f ϕ (⋃ i, p i)
state_after: no goals
tactic: exact fun i ↦ omegaLimit_mono_right _ _ (subset_iUnion _ _)
Theorem: MeasureTheory.iSup_lintegral_le
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 α
ι : Sort u_5
f : ι → α → ℝ≥0∞
⊢ ⨆ i, ∫⁻ (a : α), f i a ∂μ ≤ ∫⁻ (a : α), ⨆ i, f i a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_5
f : ι → α → ℝ≥0∞
⊢ ⨆ i, ∫⁻ (a : α), f i a ∂μ ≤ ∫⁻ (a : α), (⨆ i, f i) a ∂μ
tactic: simp only [← iSup_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_5
f : ι → α → ℝ≥0∞
⊢ ⨆ i, ∫⁻ (a : α), f i a ∂μ ≤ ∫⁻ (a : α), (⨆ i, f i) a ∂μ
state_after: no goals
tactic: exact (monotone_lintegral μ).le_map_iSup
Theorem: decide_True'
File: Mathlib/Init/Logic.lean

Proof steps:
state_before: α : Sort u
a b c d : Prop
p : ?m.8585
h : Decidable True
⊢ decide True = true
state_after: no goals
tactic: simp
Theorem: List.sublists'Aux_eq_map
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ x✝ : List (List α)
⊢ sublists'Aux a [] x✝ = x✝ ++ map (cons a) []
state_after: no goals
tactic: simp [sublists'Aux]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁✝ r₁ : List (List α)
l : List α
ih : ∀ (r₂ : List (List α)), sublists'Aux a r₁ r₂ = r₂ ++ map (cons a) r₁
r₂ : List (List α)
⊢ sublists'Aux a (r₁ ++ [l]) r₂ = r₂ ++ map (cons a) (r₁ ++ [l])
state_after: α : Type u
β : Type v
γ : Type w
a : α
r₁✝ r₁ : List (List α)
l : List α
ih : ∀ (r₂ : List (List α)), sublists'Aux a r₁ r₂ = r₂ ++ map (cons a) r₁
r₂ : List (List α)
⊢ foldl (fun r l => r ++ [a :: l]) (foldl (fun r l => r ++ [a :: l]) r₂ r₁ ++ [a :: l]) [] =
    sublists'Aux a r₁ r₂ ++ [a :: l]
tactic: rw [map_append, map_singleton, ← append_assoc, ← ih, sublists'Aux, foldl_append, foldl]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁✝ r₁ : List (List α)
l : List α
ih : ∀ (r₂ : List (List α)), sublists'Aux a r₁ r₂ = r₂ ++ map (cons a) r₁
r₂ : List (List α)
⊢ foldl (fun r l => r ++ [a :: l]) (foldl (fun r l => r ++ [a :: l]) r₂ r₁ ++ [a :: l]) [] =
    sublists'Aux a r₁ r₂ ++ [a :: l]
state_after: no goals
tactic: simp [sublists'Aux]
Theorem: Finset.disjoint_product
File: Mathlib/Data/Finset/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
⊢ _root_.Disjoint (s ×ˢ t) (s' ×ˢ t') ↔ _root_.Disjoint s s' ∨ _root_.Disjoint t t'
state_after: no goals
tactic: simp_rw [← disjoint_coe, coe_product, Set.disjoint_prod]
Theorem: IsQuasiSeparated.of_subset
File: Mathlib/Topology/QuasiSeparated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s t : Set α
ht : IsQuasiSeparated t
h : s ⊆ t
⊢ IsQuasiSeparated s
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s t : Set α
ht : IsQuasiSeparated t
h : s ⊆ t
U V : Set α
hU : U ⊆ s
hU' : IsOpen U
hU'' : IsCompact U
hV : V ⊆ s
hV' : IsOpen V
hV'' : IsCompact V
⊢ IsCompact (U ∩ V)
tactic: intro U V hU hU' hU'' hV hV' hV''
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s t : Set α
ht : IsQuasiSeparated t
h : s ⊆ t
U V : Set α
hU : U ⊆ s
hU' : IsOpen U
hU'' : IsCompact U
hV : V ⊆ s
hV' : IsOpen V
hV'' : IsCompact V
⊢ IsCompact (U ∩ V)
state_after: no goals
tactic: exact ht U V (hU.trans h) hU' hU'' (hV.trans h) hV' hV''
Theorem: List.sum_isAddUnit_iff
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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
⊢ IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m
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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
h : IsUnit L.prod
⊢ ∀ m ∈ L, IsUnit m
tactic: refine ⟨fun h => ?_, prod_isUnit⟩
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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
h : IsUnit L.prod
⊢ ∀ m ∈ L, IsUnit m
state_after: case nil
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
h : IsUnit [].prod
⊢ ∀ m ∈ [], IsUnit m

case cons
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit (m :: L).prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
tactic: induction' L with m L ih
state_before: case cons
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit (m :: L).prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
state_after: case cons
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit m ∧ IsUnit L.prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
tactic: rw [prod_cons, IsUnit.mul_iff] at h
state_before: case cons
ι : 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✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit m ∧ IsUnit L.prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
state_after: no goals
tactic: exact fun m' h' => Or.elim (eq_or_mem_of_mem_cons h') (fun H => H.substr h.1) fun H => ih h.2 _ H
Theorem: Metric.closedBall_subset_cthickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
E : Set α
hx : x ∈ E
δ : ℝ
⊢ closedBall x δ ⊆ cthickening δ E
state_after: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
E : Set α
hx : x ∈ E
δ : ℝ
⊢ {x} ⊆ E
tactic: refine (closedBall_subset_cthickening_singleton _ _).trans (cthickening_subset_of_subset _ ?_)
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
E : Set α
hx : x ∈ E
δ : ℝ
⊢ {x} ⊆ E
state_after: no goals
tactic: simpa using hx
Theorem: star_lt_star_iff
File: Mathlib/Algebra/Star/Order.lean

Proof steps:
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x y : R
⊢ star x < star y ↔ x < y
state_after: case pos
R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x y : R
h : x = y
⊢ star x < star y ↔ x < y

case neg
R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x y : R
h : ¬x = y
⊢ star x < star y ↔ x < y
tactic: by_cases h : x = y
Theorem: eq_mul_of_mul_inv_eq₀
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 : ℕ
hb : b ≠ 0
h : a * c⁻¹ = b
⊢ a = b * c
state_after: α : 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 : ℕ
hb : b ≠ 0
h : a * c⁻¹ = b
⊢ c ≠ 0
tactic: rwa [← mul_inv_eq_iff_eq_mul₀]
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 : ℕ
hb : b ≠ 0
h : a * c⁻¹ = b
⊢ c ≠ 0
state_after: α : 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 d : G₀
m n : ℕ
hb : b ≠ 0
h : a * 0⁻¹ = b
⊢ False
tactic: rintro rfl
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 d : G₀
m n : ℕ
hb : b ≠ 0
h : a * 0⁻¹ = b
⊢ False
state_after: no goals
tactic: simp [hb.symm] at h
Theorem: MulAction.zpow_smul_eq_iff_minimalPeriod_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
a : G
b : α
n : ℤ
⊢ a ^ n • b = b ↔ ↑(minimalPeriod (fun x => a • x) b) ∣ n
state_after: no goals
tactic: rw [← period_eq_minimalPeriod, zpow_smul_eq_iff_period_dvd]
Theorem: Equiv.Perm.support_congr
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
⊢ f = g
state_after: case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
⊢ f x = g x
tactic: ext x
state_before: case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
⊢ f x = g x
state_after: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
hx : x ∈ g.support
⊢ f x = g x

case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
hx : x ∉ g.support
⊢ f x = g x
tactic: by_cases hx : x ∈ g.support
Theorem: IsMaxOn.sub
File: Mathlib/Order/Filter/Extr.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝ : OrderedAddCommGroup β
f g : α → β
a : α
s : Set α
l : Filter α
hf : IsMaxOn f s a
hg : IsMinOn g s a
⊢ IsMaxOn (fun x => f x - g x) s a
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
Theorem: hyperoperation_zero
File: Mathlib/Data/Nat/Hyperoperation.lean

Proof steps:
state_before: m k : ℕ
⊢ hyperoperation 0 m k = k.succ
state_after: no goals
tactic: rw [hyperoperation, Nat.succ_eq_add_one]