ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.eval₂_sum
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T
p : T[X]
g : ℕ → T → R[X]
x : S
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)
state_after: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)
tactic: let T : R[X] →+ S :=
    { toFun := eval₂ f x
      map_zero' := eval₂_zero _ _
      map_add' := fun p q => eval₂_add _ _ }
state_before: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)
state_after: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
A : ∀ (y : R[X]), eval₂ f x y = T y
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)
tactic: have A : ∀ y, eval₂ f x y = T y := fun y => rfl
state_before: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
A : ∀ (y : R[X]), eval₂ f x y = T y
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)
state_after: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
A : ∀ (y : R[X]), eval₂ f x y = T y
⊢ T (p.sum g) = p.sum fun n a => T (g n a)
tactic: simp only [A]
state_before: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
A : ∀ (y : R[X]), eval₂ f x y = T y
⊢ T (p.sum g) = p.sum fun n a => T (g n a)
state_after: no goals
tactic: rw [sum, map_sum, sum]
Theorem: ZMod.χ₄_nat_mod_four
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

Proof steps:
state_before: n : ℕ
⊢ χ₄ ↑n = χ₄ ↑(n % 4)
state_after: no goals
tactic: rw [← ZMod.natCast_mod n 4]
Theorem: ExteriorAlgebra.ιMulti_span
File: Mathlib/LinearAlgebra/ExteriorAlgebra/Grading.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ Submodule.span R (Set.range fun x => (ιMulti R x.fst) x.snd) = ⊤
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ ∀ (x : ExteriorAlgebra R M), x ∈ Submodule.span R (Set.range fun x => (ιMulti R x.fst) x.snd)
tactic: rw [Submodule.eq_top_iff']
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ ∀ (x : ExteriorAlgebra R M), x ∈ Submodule.span R (Set.range fun x => (ιMulti R x.fst) x.snd)
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : ExteriorAlgebra R M
⊢ x ∈ Submodule.span R (Set.range fun x => (ιMulti R x.fst) x.snd)
tactic: intro x
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : ExteriorAlgebra R M
⊢ x ∈ Submodule.span R (Set.range fun x => (ιMulti R x.fst) x.snd)
state_after: no goals
tactic: induction x using DirectSum.Decomposition.inductionOn fun i => ⋀[R]^i M with
  | h_zero => exact Submodule.zero_mem _
  | h_add _ _ hm hm' => exact Submodule.add_mem _ hm hm'
  | h_homogeneous hm =>
    let ⟨m, hm⟩ := hm
    apply Set.mem_of_mem_of_subset hm
    rw [← ιMulti_span_fixedDegree]
    refine Submodule.span_mono fun _ hx ↦ ?_
    obtain ⟨y, rfl⟩ := hx
    exact ⟨⟨_, y⟩, rfl⟩
Theorem: CategoryTheory.regularTopology.equalizerConditionMap_iff_nonempty_isLimit
File: Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
inst✝¹ : Category.{?u.124100, u_3} E
P : Cᵒᵖ ⥤ D
X B : C
π : X ⟶ B
inst✝ : HasPullback π π
⊢ SingleEqualizerCondition P π ↔
    Nonempty (IsLimit (P.mapCone (Sieve.ofArrows (fun x => X) fun x => π).arrows.cocone.op))
state_after: case mp
C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
inst✝¹ : Category.{?u.124100, u_3} E
P : Cᵒᵖ ⥤ D
X B : C
π : X ⟶ B
inst✝ : HasPullback π π
⊢ SingleEqualizerCondition P π →
    Nonempty (IsLimit (P.mapCone (Sieve.ofArrows (fun x => X) fun x => π).arrows.cocone.op))

case mpr
C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
inst✝¹ : Category.{?u.124100, u_3} E
P : Cᵒᵖ ⥤ D
X B : C
π : X ⟶ B
inst✝ : HasPullback π π
⊢ Nonempty (IsLimit (P.mapCone (Sieve.ofArrows (fun x => X) fun x => π).arrows.cocone.op)) →
    SingleEqualizerCondition P π
tactic: constructor
Theorem: MulLECancellable.injective_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Mul α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : PartialOrder α
a : α
ha : MulLECancellable a
b c : α
h : (fun x => x * a) b = (fun x => x * a) c
⊢ (fun x => a * x) b = (fun x => a * x) c
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Mul α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : PartialOrder α
a : α
ha : MulLECancellable a
b c : α
h : (fun x => x * a) b = (fun x => x * a) c
⊢ a * b = a * c
tactic: dsimp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Mul α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : PartialOrder α
a : α
ha : MulLECancellable a
b c : α
h : (fun x => x * a) b = (fun x => x * a) c
⊢ a * b = a * c
state_after: no goals
tactic: rwa [i.symm_op a, i.symm_op a]
Theorem: AddSubmonoid.val_neg_addUnitsTypeEquivIsAddUnitAddSubmonoid_symm_apply
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x : ↥(IsUnit.submonoid M)
⊢ (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x
state_after: no goals
tactic: simp_rw [IsUnit.unit_spec]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
    { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun x *
      { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
tactic: simp_rw [Units.val_mul]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: hasDerivAt_fourier
File: Mathlib/Analysis/Fourier/AddCircle.lean

Proof steps:
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => (fourier n) ↑y) (2 * ↑π * I * ↑n / ↑T * (fourier n) ↑x) x
state_after: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => cexp (2 * ↑π * I * ↑n * ↑y / ↑T)) (2 * ↑π * I * ↑n / ↑T * cexp (2 * ↑π * I * ↑n * ↑x / ↑T)) x
tactic: simp_rw [fourier_coe_apply]
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => cexp (2 * ↑π * I * ↑n * ↑y / ↑T)) (2 * ↑π * I * ↑n / ↑T * cexp (2 * ↑π * I * ↑n * ↑x / ↑T)) x
state_after: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => cexp (2 * ↑π * I * ↑n * y / ↑T)) (2 * ↑π * I * ↑n / ↑T * cexp (2 * ↑π * I * ↑n * ↑x / ↑T)) ↑x
tactic: refine (?_ : HasDerivAt (fun y => exp (2 * π * I * n * y / T)) _ _).comp_ofReal
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => cexp (2 * ↑π * I * ↑n * y / ↑T)) (2 * ↑π * I * ↑n / ↑T * cexp (2 * ↑π * I * ↑n * ↑x / ↑T)) ↑x
state_after: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => cexp (2 * ↑π * I * ↑n * y / ↑T)) (cexp (2 * ↑π * I * ↑n * ↑x / ↑T) * (2 * ↑π * I * ↑n / ↑T)) ↑x
tactic: rw [(fun α β => by ring : ∀ α β : ℂ, α * exp β = exp β * α)]
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => cexp (2 * ↑π * I * ↑n * y / ↑T)) (cexp (2 * ↑π * I * ↑n * ↑x / ↑T) * (2 * ↑π * I * ↑n / ↑T)) ↑x
state_after: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => 2 * ↑π * I * ↑n * y / ↑T) (2 * ↑π * I * ↑n / ↑T) ↑x
tactic: refine (hasDerivAt_exp _).comp (x : ℂ) ?_
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ HasDerivAt (fun y => 2 * ↑π * I * ↑n * y / ↑T) (2 * ↑π * I * ↑n / ↑T) ↑x
state_after: case h.e'_6
T : ℝ
n : ℤ
x : ℝ
⊢ (fun y => 2 * ↑π * I * ↑n * y / ↑T) = fun x => x * (2 * ↑π * I * ↑n / ↑T)
tactic: convert hasDerivAt_mul_const (2 * ↑π * I * ↑n / T) using 1
state_before: case h.e'_6
T : ℝ
n : ℤ
x : ℝ
⊢ (fun y => 2 * ↑π * I * ↑n * y / ↑T) = fun x => x * (2 * ↑π * I * ↑n / ↑T)
state_after: case h.e'_6.h
T : ℝ
n : ℤ
x : ℝ
y : ℂ
⊢ 2 * ↑π * I * ↑n * y / ↑T = y * (2 * ↑π * I * ↑n / ↑T)
tactic: ext1 y
state_before: case h.e'_6.h
T : ℝ
n : ℤ
x : ℝ
y : ℂ
⊢ 2 * ↑π * I * ↑n * y / ↑T = y * (2 * ↑π * I * ↑n / ↑T)
state_after: no goals
tactic: ring
Theorem: CategoryTheory.ComposableArrows.homMk₄_app_three
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.318794, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ⟶ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁ = app₀ ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂ = app₁ ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃ = app₂ ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄ = app₃ ≫ g.map' 3 4 ⋯ ⋯
⊢ 3 < 4 + 1
state_after: no goals
tactic: valid
Theorem: normEDS_zero
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ normEDS b c d 0 = 0
state_after: no goals
tactic: erw [normEDS_ofNat, preNormEDS'_zero, zero_mul]
Theorem: ENNReal.ofReal_add
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hp : 0 ≤ p
hq : 0 ≤ q
⊢ ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q
state_after: no goals
tactic: rw [ENNReal.ofReal, ENNReal.ofReal, ENNReal.ofReal, ← coe_add, coe_inj,
    Real.toNNReal_add hp hq]
Theorem: Ideal.comap_ne_top
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
hK : K ≠ ⊤
⊢ 1 ∉ comap f K
state_after: R : Type u
S : Type v
F : Type u_1
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
hK : K ≠ ⊤
⊢ 1 ∉ K
tactic: rw [mem_comap, map_one]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
hK : K ≠ ⊤
⊢ 1 ∉ K
state_after: no goals
tactic: exact (ne_top_iff_one _).1 hK
Theorem: WithLp.edist_equiv_symm_fst
File: Mathlib/Analysis/Normed/Lp/ProdLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
x₁ x₂ : α
⊢ edist ((WithLp.equiv p (α × β)).symm (x₁, 0)) ((WithLp.equiv p (α × β)).symm (x₂, 0)) = edist x₁ x₂
state_after: no goals
tactic: simp only [edist_nndist, nndist_equiv_symm_fst p α β x₁ x₂]
Theorem: IsLocalization.ringEquivOfRingEquiv_eq
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁷ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁶ : CommSemiring S
inst✝⁵ : Algebra R S
P : Type u_3
inst✝⁴ : CommSemiring P
inst✝³ : IsLocalization M S
g : R →+* P
hg : ∀ (y : ↥M), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝² : CommSemiring Q
hy : M ≤ Submonoid.comap g T
inst✝¹ : Algebra P Q
inst✝ : IsLocalization T Q
j : R ≃+* P
H : Submonoid.map j.toMonoidHom M = T
x : R
⊢ (ringEquivOfRingEquiv S Q j H) ((algebraMap R S) x) = (algebraMap P Q) (j x)
state_after: no goals
tactic: simp
Theorem: IsOpen.closure_inter
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsOpen t
⊢ closure s ∩ t ⊆ closure (s ∩ t)
state_after: no goals
tactic: simpa only [inter_comm t] using h.inter_closure
Theorem: Multiset.sizeOf_lt_sizeOf_of_mem
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : SizeOf α
x : α
s : Multiset α
hx : x ∈ s
⊢ sizeOf x < sizeOf s
state_after: case h
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : SizeOf α
x : α
l : List α
hx : x ∈ Quot.mk Setoid.r l
⊢ sizeOf x < sizeOf (Quot.mk Setoid.r l)
tactic: induction' s using Quot.inductionOn with l a b
state_before: case h
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : SizeOf α
x : α
l : List α
hx : x ∈ Quot.mk Setoid.r l
⊢ sizeOf x < sizeOf (Quot.mk Setoid.r l)
state_after: no goals
tactic: exact List.sizeOf_lt_sizeOf_of_mem hx
Theorem: IsOfFinAddOrder.mono
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x y✝ : G
n m : ℕ
inst✝ : Monoid β
y : β
hx : IsOfFinOrder x
h : orderOf y ∣ orderOf x
⊢ IsOfFinOrder y
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x y✝ : G
n m : ℕ
inst✝ : Monoid β
y : β
hx : 0 < orderOf x
h : orderOf y ∣ orderOf x
⊢ 0 < orderOf y
tactic: rw [← orderOf_pos_iff] at hx ⊢
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x y✝ : G
n m : ℕ
inst✝ : Monoid β
y : β
hx : 0 < orderOf x
h : orderOf y ∣ orderOf x
⊢ 0 < orderOf y
state_after: no goals
tactic: exact Nat.pos_of_dvd_of_pos h hx
Theorem: Rel.preimage_id
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Set α
⊢ preimage Eq s = s
state_after: no goals
tactic: simp only [preimage, inv_id, image_id]
Theorem: exists_nonneg_left_iff_sameRay
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
⊢ (∃ r, 0 ≤ r ∧ r • x = y) ↔ SameRay R x y
state_after: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
h : ∃ r, 0 ≤ r ∧ r • x = y
⊢ SameRay R x y
tactic: refine ⟨fun h => ?_, fun h => h.exists_nonneg_left hx⟩
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
h : ∃ r, 0 ≤ r ∧ r • x = y
⊢ SameRay R x y
state_after: case intro.intro
R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hx : x ≠ 0
r : R
hr : 0 ≤ r
⊢ SameRay R x (r • x)
tactic: rcases h with ⟨r, hr, rfl⟩
state_before: case intro.intro
R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hx : x ≠ 0
r : R
hr : 0 ≤ r
⊢ SameRay R x (r • x)
state_after: no goals
tactic: exact SameRay.sameRay_nonneg_smul_right x hr
Theorem: WithTop.strictMono_map_iff
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ ((StrictMono fun a => map f ↑a) ∧ ∀ (x : α), map f ↑x < map f ⊤) ↔ StrictMono f
state_after: no goals
tactic: simp [StrictMono, coe_lt_top]
Theorem: Con.conGen_eq
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
r : M → M → Prop
s : Con M
hs : s ∈ {s | ∀ (x y : M), r x y → s x y}
x y : M
hxy : (conGen r) x y
⊢ s x y
state_after: case of
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
r : M → M → Prop
s : Con M
hs : s ∈ {s | ∀ (x y : M), r x y → s x y}
x y : M
hxy : (conGen r) x y
⊢ ∀ (x y : M), r x y → s x y

case refl
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
r : M → M → Prop
s : Con M
hs : s ∈ {s | ∀ (x y : M), r x y → s x y}
x y : M
hxy : (conGen r) x y
⊢ ∀ (x : M), s x x

case symm
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
r : M → M → Prop
s : Con M
hs : s ∈ {s | ∀ (x y : M), r x y → s x y}
x y : M
hxy : (conGen r) x y
⊢ ∀ {x y : M}, ConGen.Rel r x y → s x y → s y x

case trans
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
r : M → M → Prop
s : Con M
hs : s ∈ {s | ∀ (x y : M), r x y → s x y}
x y : M
hxy : (conGen r) x y
⊢ ∀ {x y z : M}, ConGen.Rel r x y → ConGen.Rel r y z → s x y → s y z → s x z

case mul
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
r : M → M → Prop
s : Con M
hs : s ∈ {s | ∀ (x y : M), r x y → s x y}
x y : M
hxy : (conGen r) x y
⊢ ∀ {w x y z : M}, ConGen.Rel r w x → ConGen.Rel r y z → s w x → s y z → s (w * y) (x * z)
tactic: apply ConGen.Rel.recOn (motive := fun x y _ => s x y) hxy
Theorem: Subspace.dualPairing_nondegenerate
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
⊢ (Submodule.dualPairing W).Nondegenerate
state_after: case left
K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
⊢ (Submodule.dualPairing W).SeparatingLeft

case right
K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
⊢ (Submodule.dualPairing W).SeparatingRight
tactic: constructor
Theorem: exterior_singleton_eq_ker_nhds
File: Mathlib/Topology/AlexandrovDiscrete.lean

Proof steps:
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
a✝ x y a : α
⊢ exterior {a} = (𝓝 a).ker
state_after: no goals
tactic: simp [exterior]
Theorem: CategoryTheory.Equivalence.sheafCongr.counitIso_hom_app_val_app
File: Mathlib/CategoryTheory/Sites/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
K : GrothendieckTopology D
e : C ≌ D
G : D ⥤ C
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
inst✝ : TransportsGrothendieckTopology J K e
⊢ ∀ {X Y : Sheaf K A} (f : X ⟶ Y),
    (inverse J K e A ⋙ functor J K e A).map f ≫
        ((fun F =>
              { hom := { val := (isoWhiskerRight e.op.counitIso F.val).hom },
                inv := { val := (isoWhiskerRight e.op.counitIso F.val).inv }, hom_inv_id := ⋯, inv_hom_id := ⋯ })
            Y).hom =
      ((fun F =>
              { hom := { val := (isoWhiskerRight e.op.counitIso F.val).hom },
                inv := { val := (isoWhiskerRight e.op.counitIso F.val).inv }, hom_inv_id := ⋯, inv_hom_id := ⋯ })
            X).hom ≫
        (𝟭 (Sheaf K A)).map f
state_after: no goals
tactic: aesop
Theorem: MeasureTheory.addContent_union'
File: Mathlib/MeasureTheory/Measure/AddContent.lean

Proof steps:
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m m' : AddContent C
hs : s ∈ C
ht : t ∈ C
hst : s ∪ t ∈ C
h_dis : Disjoint s t
⊢ m (s ∪ t) = m s + m t
state_after: case pos
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m m' : AddContent C
hs : s ∈ C
ht : t ∈ C
hst : s ∪ t ∈ C
h_dis : Disjoint s t
hs_empty : s = ∅
⊢ m (s ∪ t) = m s + m t

case neg
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m m' : AddContent C
hs : s ∈ C
ht : t ∈ C
hst : s ∪ t ∈ C
h_dis : Disjoint s t
hs_empty : ¬s = ∅
⊢ m (s ∪ t) = m s + m t
tactic: by_cases hs_empty : s = ∅
Theorem: MeasureTheory.Integrable.integral_norm_condDistrib_map
File: Mathlib/Probability/Kernel/CondDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ Integrable (fun x => ∫ (y : Ω), ‖f (x, y)‖ ∂(condDistrib Y X μ) x) (Measure.map X μ)
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ Integrable (fun x => ∫ (y : Ω), ‖f (x, y)‖ ∂(Measure.map (fun a => (X a, Y a)) μ).condKernel x)
    (Measure.map (fun a => (X a, Y a)) μ).fst
tactic: rw [condDistrib, ← Measure.fst_map_prod_mk₀ (X := X) hY]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ Integrable (fun x => ∫ (y : Ω), ‖f (x, y)‖ ∂(Measure.map (fun a => (X a, Y a)) μ).condKernel x)
    (Measure.map (fun a => (X a, Y a)) μ).fst
state_after: no goals
tactic: exact hf_int.integral_norm_condKernel
Theorem: Set.toFinset_prod
File: Mathlib/Data/Fintype/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t✝ s : Set α
t : Set β
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ×ˢ t)
⊢ (s ×ˢ t).toFinset = s.toFinset ×ˢ t.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t✝ s : Set α
t : Set β
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ×ˢ t)
a✝ : α × β
⊢ a✝ ∈ (s ×ˢ t).toFinset ↔ a✝ ∈ s.toFinset ×ˢ t.toFinset
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t✝ s : Set α
t : Set β
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ×ˢ t)
a✝ : α × β
⊢ a✝ ∈ (s ×ˢ t).toFinset ↔ a✝ ∈ s.toFinset ×ˢ t.toFinset
state_after: no goals
tactic: simp