ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.tendsto_atTop_atTop_of_monotone'
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder ι
inst✝ : LinearOrder α
u : ι → α
h : Monotone u
H : ¬BddAbove (range u)
⊢ Tendsto u atTop atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder ι
inst✝ : LinearOrder α
u : ι → α
h : Monotone u
H : ¬BddAbove (range u)
⊢ ∀ (b : α), ∃ a, b ≤ u a
tactic: apply h.tendsto_atTop_atTop
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder ι
inst✝ : LinearOrder α
u : ι → α
h : Monotone u
H : ¬BddAbove (range u)
⊢ ∀ (b : α), ∃ a, b ≤ u a
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder ι
inst✝ : LinearOrder α
u : ι → α
h : Monotone u
H : ¬BddAbove (range u)
b : α
⊢ ∃ a, b ≤ u a
tactic: intro b
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder ι
inst✝ : LinearOrder α
u : ι → α
h : Monotone u
H : ¬BddAbove (range u)
b : α
⊢ ∃ a, b ≤ u a
state_after: case intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder ι
inst✝ : LinearOrder α
u : ι → α
h : Monotone u
H : ¬BddAbove (range u)
b : α
N : ι
hN : b < u N
⊢ ∃ a, b ≤ u a
tactic: rcases not_bddAbove_iff.1 H b with ⟨_, ⟨N, rfl⟩, hN⟩
state_before: case intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder ι
inst✝ : LinearOrder α
u : ι → α
h : Monotone u
H : ¬BddAbove (range u)
b : α
N : ι
hN : b < u N
⊢ ∃ a, b ≤ u a
state_after: no goals
tactic: exact ⟨N, le_of_lt hN⟩
Theorem: not_xor
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: a b P Q : Prop
⊢ ¬Xor' P Q ↔ (P ↔ Q)
state_after: no goals
tactic: simp only [not_and, Xor', not_or, not_not, ← iff_iff_implies_and_implies]
Theorem: add_pow_expChar
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝ : CommSemiring R
q : ℕ
hR : ExpChar R q
x y : R
⊢ (x + y) ^ q = x ^ q + y ^ q
state_after: case zero
R : Type u
inst✝¹ : CommSemiring R
x y : R
inst✝ : CharZero R
⊢ (x + y) ^ 1 = x ^ 1 + y ^ 1

case prime
R : Type u
inst✝ : CommSemiring R
q : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x + y) ^ q = x ^ q + y ^ q
tactic: cases' hR with _ _ hprime _
state_before: case prime
R : Type u
inst✝ : CommSemiring R
q : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x + y) ^ q = x ^ q + y ^ q
state_after: case prime
R : Type u
inst✝ : CommSemiring R
q : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x + y) ^ q = x ^ q + y ^ q
tactic: haveI := Fact.mk hprime
state_before: case prime
R : Type u
inst✝ : CommSemiring R
q : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x + y) ^ q = x ^ q + y ^ q
state_after: no goals
tactic: exact add_pow_char R x y
Theorem: Diffeomorph.isLocalDiffeomorph
File: Mathlib/Geometry/Manifold/LocalDiffeomorph.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
H : Type u_4
inst✝⁵ : TopologicalSpace H
G : Type u_5
inst✝⁴ : TopologicalSpace G
I : ModelWithCorners 𝕜 E H
J : ModelWithCorners 𝕜 F G
M : Type u_6
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
N : Type u_7
inst✝¹ : TopologicalSpace N
inst✝ : ChartedSpace G N
n : ℕ∞
f : M → N
s : Set M
x : M
Φ : M ≃ₘ^n⟮I, J⟯ N
_x : M
⊢ _x ∈ Φ.toPartialDiffeomorph.source
state_after: no goals
tactic: trivial
Theorem: Module.support_of_algebra
File: Mathlib/RingTheory/Support.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p : PrimeSpectrum R
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra R A
⊢ support R A = PrimeSpectrum.zeroLocus ↑(RingHom.ker (algebraMap R A))
state_after: case h
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : PrimeSpectrum R
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra R A
p : PrimeSpectrum R
⊢ p ∈ support R A ↔ p ∈ PrimeSpectrum.zeroLocus ↑(RingHom.ker (algebraMap R A))
tactic: ext p
state_before: case h
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : PrimeSpectrum R
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra R A
p : PrimeSpectrum R
⊢ p ∈ support R A ↔ p ∈ PrimeSpectrum.zeroLocus ↑(RingHom.ker (algebraMap R A))
state_after: case h
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : PrimeSpectrum R
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra R A
p : PrimeSpectrum R
⊢ (∃ m, ∀ r ∉ p.asIdeal, ¬r • m = 0) ↔ RingHom.ker (algebraMap R A) ≤ p.asIdeal
tactic: simp only [mem_support_iff', ne_eq, PrimeSpectrum.mem_zeroLocus, SetLike.coe_subset_coe]
state_before: case h
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : PrimeSpectrum R
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra R A
p : PrimeSpectrum R
⊢ (∃ m, ∀ r ∉ p.asIdeal, ¬r • m = 0) ↔ RingHom.ker (algebraMap R A) ≤ p.asIdeal
state_after: case h.refine_1
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : PrimeSpectrum R
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra R A
p : PrimeSpectrum R
x✝ : ∃ m, ∀ r ∉ p.asIdeal, ¬r • m = 0
x : R
hx : x ∈ RingHom.ker (algebraMap R A)
m : A
hm : ∀ r ∉ p.asIdeal, ¬r • m = 0
hx' : x ∉ p.asIdeal
⊢ False

case h.refine_2
R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : PrimeSpectrum R
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra R A
p : PrimeSpectrum R
H : RingHom.ker (algebraMap R A) ≤ p.asIdeal
r : R
hr : r ∉ p.asIdeal
e : r • 1 = 0
⊢ False
tactic: refine ⟨fun ⟨m, hm⟩ x hx ↦ not_not.mp fun hx' ↦ ?_, fun H ↦ ⟨1, fun r hr e ↦ ?_⟩⟩
Theorem: derivWithin_congr_set'
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
y : 𝕜
h : s =ᶠ[𝓝[{y}ᶜ] x] t
⊢ derivWithin f s x = derivWithin f t x
state_after: no goals
tactic: simp only [derivWithin, fderivWithin_congr_set' y h]
Theorem: ENNReal.top_div
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ⊤ / a = if a = ⊤ then 0 else ⊤
state_after: no goals
tactic: simp [div_eq_mul_inv, top_mul']
Theorem: Filter.exists_lt_of_tendsto_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
u : α → β
h : Tendsto u atTop atTop
a : α
b : β
⊢ ∃ a' ≥ a, b < u a'
state_after: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
u : α → β
h : Tendsto u atTop atTop
a : α
b b' : β
hb' : b < b'
⊢ ∃ a' ≥ a, b < u a'
tactic: cases' exists_gt b with b' hb'
state_before: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
u : α → β
h : Tendsto u atTop atTop
a : α
b b' : β
hb' : b < b'
⊢ ∃ a' ≥ a, b < u a'
state_after: case intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
u : α → β
h : Tendsto u atTop atTop
a : α
b b' : β
hb' : b < b'
a' : α
ha' : a' ≥ a
ha'' : b' ≤ u a'
⊢ ∃ a' ≥ a, b < u a'
tactic: rcases exists_le_of_tendsto_atTop h a b' with ⟨a', ha', ha''⟩
state_before: case intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
u : α → β
h : Tendsto u atTop atTop
a : α
b b' : β
hb' : b < b'
a' : α
ha' : a' ≥ a
ha'' : b' ≤ u a'
⊢ ∃ a' ≥ a, b < u a'
state_after: no goals
tactic: exact ⟨a', ha', lt_of_lt_of_le hb' ha''⟩
Theorem: MeasureTheory.Martingale.condexp_stopping_time_ae_eq_restrict_eq_const_of_le_const
File: Mathlib/Probability/Martingale/OptionalSampling.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
m : MeasurableSpace Ω
μ : Measure Ω
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
ι : Type u_3
inst✝⁵ : LinearOrder ι
inst✝⁴ : TopologicalSpace ι
inst✝³ : OrderTopology ι
inst✝² : FirstCountableTopology ι
ℱ : Filtration ι m
inst✝¹ : SigmaFiniteFiltration μ ℱ
τ σ : Ω → ι
f : ι → Ω → E
i✝ n : ι
h : Martingale f ℱ μ
hτ : IsStoppingTime ℱ τ
hτ_le : ∀ (x : Ω), τ x ≤ n
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
⊢ μ[f n|hτ.measurableSpace] =ᶠ[ae (μ.restrict {x | τ x = i})] f i
state_after: case pos
Ω : Type u_1
E : Type u_2
m : MeasurableSpace Ω
μ : Measure Ω
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
ι : Type u_3
inst✝⁵ : LinearOrder ι
inst✝⁴ : TopologicalSpace ι
inst✝³ : OrderTopology ι
inst✝² : FirstCountableTopology ι
ℱ : Filtration ι m
inst✝¹ : SigmaFiniteFiltration μ ℱ
τ σ : Ω → ι
f : ι → Ω → E
i✝ n : ι
h : Martingale f ℱ μ
hτ : IsStoppingTime ℱ τ
hτ_le : ∀ (x : Ω), τ x ≤ n
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
hin : i ≤ n
⊢ μ[f n|hτ.measurableSpace] =ᶠ[ae (μ.restrict {x | τ x = i})] f i

case neg
Ω : Type u_1
E : Type u_2
m : MeasurableSpace Ω
μ : Measure Ω
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
ι : Type u_3
inst✝⁵ : LinearOrder ι
inst✝⁴ : TopologicalSpace ι
inst✝³ : OrderTopology ι
inst✝² : FirstCountableTopology ι
ℱ : Filtration ι m
inst✝¹ : SigmaFiniteFiltration μ ℱ
τ σ : Ω → ι
f : ι → Ω → E
i✝ n : ι
h : Martingale f ℱ μ
hτ : IsStoppingTime ℱ τ
hτ_le : ∀ (x : Ω), τ x ≤ n
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
hin : ¬i ≤ n
⊢ μ[f n|hτ.measurableSpace] =ᶠ[ae (μ.restrict {x | τ x = i})] f i
tactic: by_cases hin : i ≤ n
Theorem: AlgebraicGeometry.Scheme.OpenCover.add_obj
File: Mathlib/AlgebraicGeometry/Cover/Open.lean

Proof steps:
state_before: X✝ Y✝ Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
inst✝¹ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X Y : Scheme
𝒰 : X.OpenCover
f : Y ⟶ X
inst✝ : IsOpenImmersion f
⊢ ∀ (x : Option 𝒰.J), IsOpenImmersion ((fun i => Option.rec f 𝒰.map i) x)
state_after: no goals
tactic: rintro (_ | _) <;> dsimp <;> infer_instance
Theorem: AddAction.mem_fixedPoints_iff_card_orbit_eq_one
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ a ∈ fixedPoints M α ↔ Fintype.card ↑(orbit M a) = 1
state_after: M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ (∀ (m : M), m • a = a) ↔ ∃ x, ∀ (y : ↑(orbit M a)), y = x
tactic: rw [Fintype.card_eq_one_iff, mem_fixedPoints]
state_before: M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ (∀ (m : M), m • a = a) ↔ ∃ x, ∀ (y : ↑(orbit M a)), y = x
state_after: case mp
M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ (∀ (m : M), m • a = a) → ∃ x, ∀ (y : ↑(orbit M a)), y = x

case mpr
M : Type u
inst✝³ : Monoid M
α : Type v
inst✝² : MulAction M α
β : Type u_1
inst✝¹ : MulAction M β
a : α
inst✝ : Fintype ↑(orbit M a)
⊢ (∃ x, ∀ (y : ↑(orbit M a)), y = x) → ∀ (m : M), m • a = a
tactic: constructor
Theorem: EMetric.tendsto_atTop
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 : Set α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
a : α
⊢ (∀ (ib : ℝ≥0∞), 0 < ib → ∃ ia, True ∧ ∀ x ∈ Ici ia, u x ∈ ball a ib) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, edist (u n) a < ε
state_after: no goals
tactic: simp only [exists_prop, true_and_iff, mem_Ici, mem_ball]
Theorem: unitary.coe_div
File: Mathlib/Algebra/Star/Unitary.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : GroupWithZero R
inst✝ : StarMul R
U₁ U₂ : ↥(unitary R)
⊢ ↑(U₁ / U₂) = ↑U₁ / ↑U₂
state_after: no goals
tactic: simp only [div_eq_mul_inv, coe_inv, Submonoid.coe_mul]
Theorem: Subgroup.leftTransversals.smul_diff_smul
File: Mathlib/GroupTheory/Transfer.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
A : Type u_2
inst✝¹ : CommGroup A
ϕ : ↥H →* A
R S T : ↑(leftTransversals ↑H)
inst✝ : H.FiniteIndex
g : G
x✝¹ : Fintype (G ⧸ H) := H.fintypeQuotientOfFiniteIndex
x✝ : G ⧸ H
⊢ ϕ ⟨(↑((MemLeftTransversals.toEquiv ⋯) x✝))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) x✝), ⋯⟩ =
    ϕ
      ⟨(↑((MemLeftTransversals.toEquiv ⋯) ((Equiv.symm (toPerm g)) x✝)))⁻¹ *
          ↑((MemLeftTransversals.toEquiv ⋯) ((Equiv.symm (toPerm g)) x✝)),
        ⋯⟩
state_after: no goals
tactic: simp only [smul_apply_eq_smul_apply_inv_smul, smul_eq_mul, mul_inv_rev, mul_assoc,
      inv_mul_cancel_left, toPerm_symm_apply]
Theorem: IsGenericPoint.image
File: Mathlib/Topology/Sober.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
h : IsGenericPoint x S
f : α → β
hf : Continuous f
⊢ IsGenericPoint (f x) (closure (f '' S))
state_after: no goals
tactic: rw [isGenericPoint_def, ← h.def, ← image_singleton, closure_image_closure hf]
Theorem: ValuationSubring.valuationSubring_valuation
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
⊢ A.valuation.valuationSubring = A
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
x✝ : K
⊢ x✝ ∈ A.valuation.valuationSubring ↔ x✝ ∈ A
tactic: ext
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
x✝ : K
⊢ x✝ ∈ A.valuation.valuationSubring ↔ x✝ ∈ A
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
x✝ : K
⊢ x✝ ∈ A.valuation.valuationSubring ↔ A.valuation x✝ ≤ 1
tactic: rw [← A.valuation_le_one_iff]
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
x✝ : K
⊢ x✝ ∈ A.valuation.valuationSubring ↔ A.valuation x✝ ≤ 1
state_after: no goals
tactic: rfl
Theorem: AList.lookup_to_alist
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : List (Sigma β)
⊢ lookup a s.toAList = dlookup a s
state_after: no goals
tactic: rw [List.toAList, lookup, dlookup_dedupKeys]
Theorem: List.cons_prefix_iff
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂
state_after: case mp
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ a :: l₁ <+: b :: l₂ → a = b ∧ l₁ <+: l₂

case mpr
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ a = b ∧ l₁ <+: l₂ → a :: l₁ <+: b :: l₂
tactic: constructor
Theorem: IsDedekindDomain.HeightOneSpectrum.valuedAdicCompletion_eq_valuation'
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
k : K
⊢ Valued.v (↑K k) = v.valuation k
state_after: no goals
tactic: convert Valued.valuedCompletion_apply k
Theorem: Matroid.Restriction.antisymm
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N M' : Matroid α
h : M ≤r M'
h' : M' ≤r M
⊢ M = M'
state_after: no goals
tactic: simpa using (ofMatroid_le_iff.2 h).antisymm (ofMatroid_le_iff.2 h')
Theorem: contDiffOn_stereoToFun
File: Mathlib/Geometry/Manifold/Instances/Sphere.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
v : E
⊢ ContDiffOn ℝ ⊤ (stereoToFun v) {x | ((innerSL ℝ) v) x ≠ 1}
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
v : E
⊢ ContDiffOn ℝ ⊤ (fun x => 2 / (1 - ((innerSL ℝ) v) x)) {x | ((innerSL ℝ) v) x ≠ 1}
tactic: refine ContDiffOn.smul ?_ (orthogonalProjection (ℝ ∙ v)ᗮ).contDiff.contDiffOn
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
v : E
⊢ ContDiffOn ℝ ⊤ (fun x => 2 / (1 - ((innerSL ℝ) v) x)) {x | ((innerSL ℝ) v) x ≠ 1}
state_after: case refine_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
v : E
⊢ ContDiffOn ℝ ⊤ (fun x => 1 - ((innerSL ℝ) v) x) {x | ((innerSL ℝ) v) x ≠ 1}

case refine_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
v : E
⊢ ∀ x ∈ {x | ((innerSL ℝ) v) x ≠ 1}, 1 - ((innerSL ℝ) v) x ≠ 0
tactic: refine contDiff_const.contDiffOn.div ?_ ?_
Theorem: abs_sub_round_div_natCast_eq
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
⊢ |↑m / ↑n - ↑(round (↑m / ↑n))| = ↑(min (m % n) (n - m % n)) / ↑n
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m : ℕ
⊢ |↑m / ↑0 - ↑(round (↑m / ↑0))| = ↑(min (m % 0) (0 - m % 0)) / ↑0

case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
hn : n > 0
⊢ |↑m / ↑n - ↑(round (↑m / ↑n))| = ↑(min (m % n) (n - m % n)) / ↑n
tactic: rcases n.eq_zero_or_pos with (rfl | hn)
state_before: case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
hn : n > 0
⊢ |↑m / ↑n - ↑(round (↑m / ↑n))| = ↑(min (m % n) (n - m % n)) / ↑n
state_after: case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
hn : n > 0
hn' : 0 < ↑n
⊢ |↑m / ↑n - ↑(round (↑m / ↑n))| = ↑(min (m % n) (n - m % n)) / ↑n
tactic: have hn' : 0 < (n : α) := by
    norm_cast
state_before: case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
hn : n > 0
hn' : 0 < ↑n
⊢ |↑m / ↑n - ↑(round (↑m / ↑n))| = ↑(min (m % n) (n - m % n)) / ↑n
state_after: no goals
tactic: rw [abs_sub_round_eq_min, Nat.cast_min, ← min_div_div_right hn'.le,
    fract_div_natCast_eq_div_natCast_mod, Nat.cast_sub (m.mod_lt hn).le, sub_div, div_self hn'.ne']
Theorem: gal_X_pow_sub_C_isSolvable
File: Mathlib/FieldTheory/AbelRuffini.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
n : ℕ
x : F
⊢ IsSolvable (X ^ n - C x).Gal
state_after: case pos
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
n : ℕ
x : F
hx : x = 0
⊢ IsSolvable (X ^ n - C x).Gal

case neg
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
n : ℕ
x : F
hx : ¬x = 0
⊢ IsSolvable (X ^ n - C x).Gal
tactic: by_cases hx : x = 0
state_before: case neg
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
n : ℕ
x : F
hx : ¬x = 0
⊢ IsSolvable (X ^ n - C x).Gal
state_after: case neg.hpq
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
n : ℕ
x : F
hx : ¬x = 0
⊢ Splits (algebraMap F (X ^ n - C x).SplittingField) (X ^ n - 1)

case neg.hp
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
n : ℕ
x : F
hx : ¬x = 0
⊢ IsSolvable (X ^ n - 1).Gal

case neg.hq
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
n : ℕ
x : F
hx : ¬x = 0
⊢ IsSolvable (Polynomial.map (algebraMap F (X ^ n - 1).SplittingField) (X ^ n - C x)).Gal
tactic: apply gal_isSolvable_tower (X ^ n - 1) (X ^ n - C x)
Theorem: Set.compl_compl_image
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s t : Set α
inst✝ : BooleanAlgebra α
S : Set α
⊢ compl '' (compl '' S) = S
state_after: no goals
tactic: rw [← image_comp, compl_comp_compl, image_id]
Theorem: Finset.sum_fiberwise_eq_sum_filter'
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝¹ s₁ s₂ : Finset α✝
a : α✝
f✝¹ g✝¹ : α✝ → β
inst✝² : CommMonoid β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝¹ : CommMonoid α
s✝ : Finset ι
t✝ : Finset κ
f✝ : ι → α
g✝ : κ → α
inst✝ : DecidableEq κ
s : Finset ι
t : Finset κ
g : ι → κ
f : κ → α
⊢ ∏ j ∈ t, ∏ _i ∈ filter (fun i => g i = j) s, f j = ∏ i ∈ filter (fun i => g i ∈ t) s, f (g i)
state_after: no goals
tactic: calc
    _ = ∏ j ∈ t, ∏ i ∈ s.filter fun i ↦ g i = j, f (g i) :=
        prod_congr rfl fun j _ ↦ prod_congr rfl fun i hi ↦ by rw [(mem_filter.1 hi).2]
    _ = _ := prod_fiberwise_eq_prod_filter _ _ _ _
Theorem: CoxeterSystem.not_isRightDescent_one
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ ¬cs.IsRightDescent 1 i
state_after: no goals
tactic: simp [IsRightDescent]
Theorem: MeasureTheory.Integrable.hasSum_intervalIntegral_comp_add_int
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
μ : Measure ℝ
f : ℝ → E
hfi : Integrable f volume
⊢ HasSum (fun n => ∫ (x : ℝ) in 0 ..1, f (x + ↑n)) (∫ (x : ℝ), f x)
state_after: no goals
tactic: simpa only [integral_comp_add_right, zero_add, add_comm (1 : ℝ)] using
    hfi.hasSum_intervalIntegral 0
Theorem: FirstOrder.Language.LHom.map_constants_comp_sumInl
File: Mathlib/ModelTheory/LanguageMap.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
α : Type w'
β : Type u_1
f : α → β
⊢ (L.lhomWithConstantsMap f).comp LHom.sumInl = L.lhomWithConstants β
state_after: no goals
tactic: ext <;> rfl
Theorem: Batteries.RBNode.All.ins
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
t : RBNode α
h₁ : p x
h₂ : All p t
⊢ All p (ins cmp x t)
state_after: case node
α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
h₁ : p x
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : All p l✝ → All p (ins cmp x l✝)
r_ih✝ : All p r✝ → All p (ins cmp x r✝)
h₂ : All p (node c✝ l✝ v✝ r✝)
⊢ All p
    (match node c✝ l✝ v✝ r✝ with
    | nil => node red nil x nil
    | node red a y b =>
      match cmp x y with
      | Ordering.lt => node red (ins cmp x a) y b
      | Ordering.gt => node red a y (ins cmp x b)
      | Ordering.eq => node red a x b
    | node black a y b =>
      match cmp x y with
      | Ordering.lt => (ins cmp x a).balance1 y b
      | Ordering.gt => a.balance2 y (ins cmp x b)
      | Ordering.eq => node black a x b)
tactic: induction t <;> unfold ins <;> try simp [*]
state_before: case node
α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
h₁ : p x
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : All p l✝ → All p (ins cmp x l✝)
r_ih✝ : All p r✝ → All p (ins cmp x r✝)
h₂ : All p (node c✝ l✝ v✝ r✝)
⊢ All p
    (match node c✝ l✝ v✝ r✝ with
    | nil => node red nil x nil
    | node red a y b =>
      match cmp x y with
      | Ordering.lt => node red (ins cmp x a) y b
      | Ordering.gt => node red a y (ins cmp x b)
      | Ordering.eq => node red a x b
    | node black a y b =>
      match cmp x y with
      | Ordering.lt => (ins cmp x a).balance1 y b
      | Ordering.gt => a.balance2 y (ins cmp x b)
      | Ordering.eq => node black a x b)
state_after: no goals
tactic: split <;> cases ‹_=_› <;> split <;> simp at h₂ <;> simp [*]
Theorem: Subgroup.relindex_top_right
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ H.relindex ⊤ = H.index
state_after: no goals
tactic: rw [← relindex_mul_index (show H ≤ ⊤ from le_top), index_top, mul_one]