ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: OrthonormalBasis.addHaar_eq_volume
File: Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean

Proof steps:
state_before: ι✝ : Type u_1
E : Type u_2
F✝ : Type u_3
inst✝¹¹ : Fintype ι✝
inst✝¹⁰ : NormedAddCommGroup F✝
inst✝⁹ : InnerProductSpace ℝ F✝
inst✝⁸ : FiniteDimensional ℝ F✝
inst✝⁷ : MeasurableSpace F✝
inst✝⁶ : BorelSpace F✝
ι : Type u_4
F : Type u_5
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
b : OrthonormalBasis ι ℝ F
⊢ b.toBasis.addHaar = volume
state_after: ι✝ : Type u_1
E : Type u_2
F✝ : Type u_3
inst✝¹¹ : Fintype ι✝
inst✝¹⁰ : NormedAddCommGroup F✝
inst✝⁹ : InnerProductSpace ℝ F✝
inst✝⁸ : FiniteDimensional ℝ F✝
inst✝⁷ : MeasurableSpace F✝
inst✝⁶ : BorelSpace F✝
ι : Type u_4
F : Type u_5
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
b : OrthonormalBasis ι ℝ F
⊢ volume ↑b.toBasis.parallelepiped = 1
tactic: rw [Basis.addHaar_eq_iff]
state_before: ι✝ : Type u_1
E : Type u_2
F✝ : Type u_3
inst✝¹¹ : Fintype ι✝
inst✝¹⁰ : NormedAddCommGroup F✝
inst✝⁹ : InnerProductSpace ℝ F✝
inst✝⁸ : FiniteDimensional ℝ F✝
inst✝⁷ : MeasurableSpace F✝
inst✝⁶ : BorelSpace F✝
ι : Type u_4
F : Type u_5
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
b : OrthonormalBasis ι ℝ F
⊢ volume ↑b.toBasis.parallelepiped = 1
state_after: no goals
tactic: exact b.volume_parallelepiped
Theorem: Ring.toNonUnitalRing_injective
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
⊢ Function.Injective (@toNonUnitalRing R)
state_after: R : Type u
a₁✝ a₂✝ : Ring R
h : toNonUnitalRing = toNonUnitalRing
⊢ a₁✝ = a₂✝
tactic: intro _ _ h
state_before: R : Type u
a₁✝ a₂✝ : Ring R
h : toNonUnitalRing = toNonUnitalRing
⊢ a₁✝ = a₂✝
state_after: case h_add.h.h
R : Type u
a₁✝ a₂✝ : Ring R
h : toNonUnitalRing = toNonUnitalRing
x y : R
⊢ x + y = x + y

case h_mul.h.h
R : Type u
a₁✝ a₂✝ : Ring R
h : toNonUnitalRing = toNonUnitalRing
x y : R
⊢ x * y = x * y
tactic: ext x y
Theorem: Finset.union_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 : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ (s ∪ s') ×ˢ t = s ×ˢ t ∪ s' ×ˢ t
state_after: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x : α
y : β
⊢ (x, y) ∈ (s ∪ s') ×ˢ t ↔ (x, y) ∈ s ×ˢ t ∪ s' ×ˢ t
tactic: ext ⟨x, y⟩
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x : α
y : β
⊢ (x, y) ∈ (s ∪ s') ×ˢ t ↔ (x, y) ∈ s ×ˢ t ∪ s' ×ˢ t
state_after: no goals
tactic: simp only [or_and_right, mem_union, mem_product]
Theorem: Option.map_map₂_antidistrib_left
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
g : γ → δ
f' : β' → α → δ
g' : β → β'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g' b) a
state_after: no goals
tactic: cases a <;> cases b <;> simp [h_antidistrib]
Theorem: MeasureTheory.ae_eq_condexp_of_forall_setIntegral_eq
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean

Proof steps:
state_before: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace 𝕜 F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g✝ : α → F'
s : Set α
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
f g : α → F'
hf : Integrable f μ
hg_int_finite : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → IntegrableOn g s μ
hg_eq : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, g x ∂μ = ∫ (x : α) in s, f x ∂μ
hgm : AEStronglyMeasurable' m g μ
⊢ g =ᶠ[ae μ] μ[f|m]
state_after: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace 𝕜 F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g✝ : α → F'
s✝ : Set α
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
f g : α → F'
hf : Integrable f μ
hg_int_finite : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → IntegrableOn g s μ
hg_eq : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, g x ∂μ = ∫ (x : α) in s, f x ∂μ
hgm : AEStronglyMeasurable' m g μ
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
⊢ ∫ (x : α) in s, g x ∂μ = ∫ (x : α) in s, (μ[f|m]) x ∂μ
tactic: refine ae_eq_of_forall_setIntegral_eq_of_sigmaFinite' hm hg_int_finite
    (fun s _ _ => integrable_condexp.integrableOn) (fun s hs hμs => ?_) hgm
    (StronglyMeasurable.aeStronglyMeasurable' stronglyMeasurable_condexp)
state_before: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace 𝕜 F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g✝ : α → F'
s✝ : Set α
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
f g : α → F'
hf : Integrable f μ
hg_int_finite : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → IntegrableOn g s μ
hg_eq : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, g x ∂μ = ∫ (x : α) in s, f x ∂μ
hgm : AEStronglyMeasurable' m g μ
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
⊢ ∫ (x : α) in s, g x ∂μ = ∫ (x : α) in s, (μ[f|m]) x ∂μ
state_after: no goals
tactic: rw [hg_eq s hs hμs, setIntegral_condexp hm hf hs]
Theorem: Finset.filter_singleton
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 α
a : α
⊢ filter p {a} = if p a then {a} else ∅
state_after: no goals
tactic: classical
    ext x
    simp only [mem_singleton, forall_eq, mem_filter]
    split_ifs with h <;> by_cases h' : x = a <;> simp [h, h']
Theorem: FirstOrder.Language.Theory.models_iff_finset_models
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ T ⊨ᵇ φ ↔ ∃ T0, ↑T0 ⊆ T ∧ ↑T0 ⊨ᵇ φ
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ ¬(T ∪ {Formula.not φ}).IsSatisfiable ↔ ∃ T0, ↑T0 ⊆ T ∧ ¬(↑T0 ∪ {Formula.not φ}).IsSatisfiable
tactic: simp only [models_iff_not_satisfiable]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ ¬(T ∪ {Formula.not φ}).IsSatisfiable ↔ ∃ T0, ↑T0 ⊆ T ∧ ¬(↑T0 ∪ {Formula.not φ}).IsSatisfiable
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ (∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T ∪ {Formula.not φ} → IsSatisfiable ↑T0) ↔
    ¬∃ T0, ↑T0 ⊆ T ∧ ¬(↑T0 ∪ {Formula.not φ}).IsSatisfiable
tactic: rw [← not_iff_not, not_not, isSatisfiable_iff_isFinitelySatisfiable, IsFinitelySatisfiable]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ (∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T ∪ {Formula.not φ} → IsSatisfiable ↑T0) ↔
    ¬∃ T0, ↑T0 ⊆ T ∧ ¬(↑T0 ∪ {Formula.not φ}).IsSatisfiable
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ (∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T ∪ {Formula.not φ} → IsSatisfiable ↑T0) ↔
    ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T → (↑T0 ∪ {Formula.not φ}).IsSatisfiable
tactic: push_neg
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ (∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T ∪ {Formula.not φ} → IsSatisfiable ↑T0) ↔
    ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T → (↑T0 ∪ {Formula.not φ}).IsSatisfiable
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
this : DecidableEq L.Sentence := Classical.decEq L.Sentence
⊢ (∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T ∪ {Formula.not φ} → IsSatisfiable ↑T0) ↔
    ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T → (↑T0 ∪ {Formula.not φ}).IsSatisfiable
tactic: letI := Classical.decEq (Sentence L)
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
this : DecidableEq L.Sentence := Classical.decEq L.Sentence
⊢ (∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T ∪ {Formula.not φ} → IsSatisfiable ↑T0) ↔
    ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T → (↑T0 ∪ {Formula.not φ}).IsSatisfiable
state_after: case mp
L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
this : DecidableEq L.Sentence := Classical.decEq L.Sentence
⊢ (∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T ∪ {Formula.not φ} → IsSatisfiable ↑T0) →
    ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T → (↑T0 ∪ {Formula.not φ}).IsSatisfiable

case mpr
L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
this : DecidableEq L.Sentence := Classical.decEq L.Sentence
⊢ (∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T → (↑T0 ∪ {Formula.not φ}).IsSatisfiable) →
    ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ T ∪ {Formula.not φ} → IsSatisfiable ↑T0
tactic: constructor
Theorem: PiTensorProduct.map_add
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

Proof steps:
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹² : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹¹ : (i : ι) → AddCommMonoid (s i)
inst✝¹⁰ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
E : Type u_9
inst✝⁷ : AddCommMonoid E
inst✝⁶ : Module R E
F : Type u_10
inst✝⁵ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝⁴ : (i : ι) → AddCommMonoid (t i)
inst✝³ : (i : ι) → Module R (t i)
inst✝² : (i : ι) → AddCommMonoid (t' i)
inst✝¹ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f : (i : ι) → s i →ₗ[R] t i
inst✝ : DecidableEq ι
i : ι
u v : s i →ₗ[R] t i
⊢ map (update f i (u + v)) = map (update f i u) + map (update f i v)
state_after: case H.H
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹² : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹¹ : (i : ι) → AddCommMonoid (s i)
inst✝¹⁰ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
E : Type u_9
inst✝⁷ : AddCommMonoid E
inst✝⁶ : Module R E
F : Type u_10
inst✝⁵ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝⁴ : (i : ι) → AddCommMonoid (t i)
inst✝³ : (i : ι) → Module R (t i)
inst✝² : (i : ι) → AddCommMonoid (t' i)
inst✝¹ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f : (i : ι) → s i →ₗ[R] t i
inst✝ : DecidableEq ι
i : ι
u v : s i →ₗ[R] t i
x : (i : ι) → s i
⊢ ((map (update f i (u + v))).compMultilinearMap (tprod R)) x =
    ((map (update f i u) + map (update f i v)).compMultilinearMap (tprod R)) x
tactic: ext x
state_before: case H.H
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹² : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹¹ : (i : ι) → AddCommMonoid (s i)
inst✝¹⁰ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
E : Type u_9
inst✝⁷ : AddCommMonoid E
inst✝⁶ : Module R E
F : Type u_10
inst✝⁵ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝⁴ : (i : ι) → AddCommMonoid (t i)
inst✝³ : (i : ι) → Module R (t i)
inst✝² : (i : ι) → AddCommMonoid (t' i)
inst✝¹ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f : (i : ι) → s i →ₗ[R] t i
inst✝ : DecidableEq ι
i : ι
u v : s i →ₗ[R] t i
x : (i : ι) → s i
⊢ ((map (update f i (u + v))).compMultilinearMap (tprod R)) x =
    ((map (update f i u) + map (update f i v)).compMultilinearMap (tprod R)) x
state_after: no goals
tactic: simp only [LinearMap.compMultilinearMap_apply, map_tprod, map_add_smul_aux, LinearMap.add_apply,
    MultilinearMap.map_add]
Theorem: HNNExtension.NormalWord.unitsSMul_cancels_iff
File: Mathlib/GroupTheory/HNNExtension.lean

Proof steps:
state_before: G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
u : ℤˣ
w : NormalWord d
⊢ Cancels (-u) (unitsSMul φ u w) ↔ ¬Cancels u w
state_after: case pos
G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
u : ℤˣ
w : NormalWord d
h : Cancels u w
⊢ Cancels (-u) (unitsSMul φ u w) ↔ ¬Cancels u w

case neg
G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
u : ℤˣ
w : NormalWord d
h : ¬Cancels u w
⊢ Cancels (-u) (unitsSMul φ u w) ↔ ¬Cancels u w
tactic: by_cases h : Cancels u w
Theorem: CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_right_symm_aux
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ F.map f ≫ (adj.homEquiv (G.obj Y) Y').symm (G.map g) = (adj.homEquiv X Y).symm f ≫ g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = (adj.homEquiv X Y') ((adj.homEquiv X Y).symm f ≫ g)
tactic: rw [← homEquiv_naturality_left_symm, Equiv.symm_apply_eq]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = (adj.homEquiv X Y') ((adj.homEquiv X Y).symm f ≫ g)
state_after: no goals
tactic: simp
Theorem: Set.le_chainHeight_TFAE
File: Mathlib/Order/Height.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
⊢ [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE
state_after: case tfae_1_to_2
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
⊢ ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n

α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n
⊢ [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE
tactic: tfae_have 1 → 2
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n
⊢ [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE
state_after: case tfae_2_to_3
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n
⊢ (∃ l ∈ s.subchain, l.length = n) → ∃ l ∈ s.subchain, n ≤ l.length

α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n
tfae_2_to_3 : (∃ l ∈ s.subchain, l.length = n) → ∃ l ∈ s.subchain, n ≤ l.length
⊢ [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE
tactic: tfae_have 2 → 3
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n
tfae_2_to_3 : (∃ l ∈ s.subchain, l.length = n) → ∃ l ∈ s.subchain, n ≤ l.length
⊢ [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE
state_after: case tfae_3_to_1
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n
tfae_2_to_3 : (∃ l ∈ s.subchain, l.length = n) → ∃ l ∈ s.subchain, n ≤ l.length
⊢ (∃ l ∈ s.subchain, n ≤ l.length) → ↑n ≤ s.chainHeight

α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n
tfae_2_to_3 : (∃ l ∈ s.subchain, l.length = n) → ∃ l ∈ s.subchain, n ≤ l.length
tfae_3_to_1 : (∃ l ∈ s.subchain, n ≤ l.length) → ↑n ≤ s.chainHeight
⊢ [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE
tactic: tfae_have 3 → 1
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n
tfae_2_to_3 : (∃ l ∈ s.subchain, l.length = n) → ∃ l ∈ s.subchain, n ≤ l.length
tfae_3_to_1 : (∃ l ∈ s.subchain, n ≤ l.length) → ↑n ≤ s.chainHeight
⊢ [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE
state_after: no goals
tactic: tfae_finish
Theorem: Real.exp_log_eq_abs
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
hx : x ≠ 0
⊢ rexp (log x) = |x|
state_after: no goals
tactic: rw [log_of_ne_zero hx, ← coe_expOrderIso_apply, OrderIso.apply_symm_apply, Subtype.coe_mk]
Theorem: MeasureTheory.iUnion_spanningSets
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
μ : Measure α
inst✝ : SigmaFinite μ
⊢ ⋃ i, spanningSets μ i = univ
state_after: no goals
tactic: simp_rw [spanningSets, iUnion_accumulate, μ.toFiniteSpanningSetsIn.spanning]
Theorem: Polynomial.toSubring_one
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ ↑((toSubring 1 T ⋯).coeff i) = ↑(coeff 1 i)
state_after: no goals
tactic: rw [coeff_toSubring', coeff_one, coeff_one, apply_ite Subtype.val, ZeroMemClass.coe_zero,
      OneMemClass.coe_one]
Theorem: Rel.comp_left_top
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
⊢ ⊤ • r = fun x y => y ∈ r.codom
state_after: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
x : γ
z : β
⊢ (⊤ • r) x z ↔ z ∈ r.codom
tactic: ext x z
state_before: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
x : γ
z : β
⊢ (⊤ • r) x z ↔ z ∈ r.codom
state_after: no goals
tactic: simp [comp, Top.top, codom]
Theorem: ae_restrict_iff_subtype
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
p : α → Prop
⊢ (∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : ↑s) ∂Measure.comap Subtype.val μ, p ↑x
state_after: no goals
tactic: rw [← map_comap_subtype_coe hs, (MeasurableEmbedding.subtype_coe hs).ae_map_iff]
Theorem: Shrink.ext
File: Mathlib/Logic/Small/Defs.lean

Proof steps:
state_before: α : Type v
inst✝ : Small.{w, v} α
x y : Shrink.{w, v} α
w : (equivShrink α).symm x = (equivShrink α).symm y
⊢ x = y
state_after: no goals
tactic: simpa using w
Theorem: Primrec.list_tail
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List α
⊢ (List.casesOn (id l) [] fun b l_1 => (l, b, l_1).2.2) = l.tail
state_after: no goals
tactic: cases l <;> rfl
Theorem: Cardinal.natCast_eq_toPartENat_iff
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
c : Cardinal.{u_3}
⊢ ↑n = toPartENat c ↔ ↑n = c
state_after: no goals
tactic: rw [le_antisymm_iff, le_antisymm_iff, Cardinal.toPartENat_le_natCast_iff,
    Cardinal.natCast_le_toPartENat_iff]
Theorem: Rat.add_nonneg
File: Mathlib/Algebra/Order/Ring/Rat.lean

Proof steps:
state_before: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ + n₂ /. ↑d₂
state_after: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ + n₂ /. ↑d₂
tactic: have d₁0 : 0 < (d₁ : ℤ) := mod_cast Nat.pos_of_ne_zero h₁
state_before: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ + n₂ /. ↑d₂
state_after: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ + n₂ /. ↑d₂
tactic: have d₂0 : 0 < (d₂ : ℤ) := mod_cast Nat.pos_of_ne_zero h₂
state_before: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ + n₂ /. ↑d₂
state_after: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ → 0 ≤ n₂ → 0 ≤ n₁ * ↑d₂ + n₂ * ↑d₁
tactic: simp only [d₁0, d₂0, h₁, h₂, mul_pos, divInt_nonneg_iff_of_pos_right, divInt_add_divInt, Ne,
      Nat.cast_eq_zero, not_false_iff]
state_before: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ → 0 ≤ n₂ → 0 ≤ n₁ * ↑d₂ + n₂ * ↑d₁
state_after: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
n₁0 : 0 ≤ n₁
n₂0 : 0 ≤ n₂
⊢ 0 ≤ n₁ * ↑d₂ + n₂ * ↑d₁
tactic: intro n₁0 n₂0
Theorem: RootPairing.apply_root_root_zero_iff
File: Mathlib/LinearAlgebra/RootSystem/RootPositive.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
⊢ (B (P.root i)) (P.root j) = 0 ↔ P.pairing i j = 0
state_after: case refine_1
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
hB : (B (P.root i)) (P.root j) = 0
⊢ P.pairing i j = 0

case refine_2
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
hP : P.pairing i j = 0
⊢ (B (P.root i)) (P.root j) = 0
tactic: refine ⟨fun hB => ?_, fun hP => ?_⟩
Theorem: Finset.sum_smul_vsub_eq_affineCombination_vsub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p₁ p₂ : ι → P
⊢ ∑ i ∈ s, w i • (p₁ i -ᵥ p₂ i) = (affineCombination k s p₁) w -ᵥ (affineCombination k s p₂) w
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p₁ p₂ : ι → P
⊢ ∑ i ∈ s, w i • (p₁ i -ᵥ p₂ i) =
    (s.weightedVSubOfPoint p₁ (Classical.choice ⋯)) w - (s.weightedVSubOfPoint p₂ (Classical.choice ⋯)) w
tactic: simp_rw [affineCombination_apply, vadd_vsub_vadd_cancel_right]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p₁ p₂ : ι → P
⊢ ∑ i ∈ s, w i • (p₁ i -ᵥ p₂ i) =
    (s.weightedVSubOfPoint p₁ (Classical.choice ⋯)) w - (s.weightedVSubOfPoint p₂ (Classical.choice ⋯)) w
state_after: no goals
tactic: exact s.sum_smul_vsub_eq_weightedVSubOfPoint_sub _ _ _ _