ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.PreGaloisCategory.autGaloisSystem_map
File: Mathlib/CategoryTheory/Galois/Prorepresentability.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A : PointedGaloisObject F
⊢ { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (𝟙 A) =
    𝟙 ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.obj A)
state_after: case w
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A : PointedGaloisObject F
σ : Aut A.obj
⊢ ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (𝟙 A)) σ =
    (𝟙 ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.obj A)) σ
tactic: ext (σ : Aut A.obj)
state_before: case w
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A : PointedGaloisObject F
σ : Aut A.obj
⊢ ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (𝟙 A)) σ =
    (𝟙 ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.obj A)) σ
state_after: no goals
tactic: simp
state_before: C✝ : Type u₁
inst✝² : Category.{u₂, u₁} C✝
inst✝¹ : GaloisCategory C✝
F : C✝ ⥤ FintypeCat
inst✝ : FiberFunctor F
A B C : PointedGaloisObject F
f : A ⟶ B
g : B ⟶ C
⊢ { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (f ≫ g) =
    { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map f ≫
      { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map g
state_after: case w
C✝ : Type u₁
inst✝² : Category.{u₂, u₁} C✝
inst✝¹ : GaloisCategory C✝
F : C✝ ⥤ FintypeCat
inst✝ : FiberFunctor F
A B C : PointedGaloisObject F
f : A ⟶ B
g : B ⟶ C
σ : Aut A.obj
⊢ ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (f ≫ g)) σ =
    ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map f ≫
        { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map g)
      σ
tactic: ext (σ : Aut A.obj)
state_before: case w
C✝ : Type u₁
inst✝² : Category.{u₂, u₁} C✝
inst✝¹ : GaloisCategory C✝
F : C✝ ⥤ FintypeCat
inst✝ : FiberFunctor F
A B C : PointedGaloisObject F
f : A ⟶ B
g : B ⟶ C
σ : Aut A.obj
⊢ ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (f ≫ g)) σ =
    ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map f ≫
        { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map g)
      σ
state_after: no goals
tactic: simp
Theorem: MvPolynomial.vars_bind₁
File: Mathlib/Algebra/MvPolynomial/Monad.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : CommSemiring T
f✝ : σ → MvPolynomial τ R
inst✝ : DecidableEq τ
f : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ ((bind₁ f) φ).vars ⊆ φ.vars.biUnion fun i => (f i).vars
state_after: case calc_1
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : CommSemiring T
f✝ : σ → MvPolynomial τ R
inst✝ : DecidableEq τ
f : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ (φ.support.biUnion fun d => (C (coeff d φ) * ∏ i ∈ d.support, f i ^ d i).vars) ≤
    φ.support.biUnion fun d => d.support.biUnion fun i => (f i).vars

case calc_2
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : CommSemiring T
f✝ : σ → MvPolynomial τ R
inst✝ : DecidableEq τ
f : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ (φ.support.biUnion fun d => d.support.biUnion fun i => (f i).vars) ≤ φ.vars.biUnion fun i => (f i).vars
tactic: calc (bind₁ f φ).vars
    _ = (φ.support.sum fun x : σ →₀ ℕ => (bind₁ f) (monomial x (coeff x φ))).vars := by
      rw [← map_sum, ← φ.as_sum]
    _ ≤ φ.support.biUnion fun i : σ →₀ ℕ => ((bind₁ f) (monomial i (coeff i φ))).vars :=
      (vars_sum_subset _ _)
    _ = φ.support.biUnion fun d : σ →₀ ℕ => vars (C (coeff d φ) * ∏ i ∈ d.support, f i ^ d i) := by
      simp only [bind₁_monomial]
    _ ≤ φ.support.biUnion fun d : σ →₀ ℕ => d.support.biUnion fun i => vars (f i) := ?_
    -- proof below
    _ ≤ φ.vars.biUnion fun i : σ => vars (f i) := ?_
Theorem: Real.BohrMollerup.f_nat_eq
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

Proof steps:
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
⊢ f ↑n = f 1 + log ↑(n - 1)!
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
⊢ f ↑(m + 1) = f 1 + log ↑(m + 1 - 1)!
tactic: refine Nat.le_induction (by simp) (fun m hm IH => ?_) n (Nat.one_le_iff_ne_zero.2 hn)
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
⊢ f ↑(m + 1) = f 1 + log ↑(m + 1 - 1)!
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ f ↑(m + 1) = f 1 + log ↑(m + 1 - 1)!
tactic: have A : 0 < (m : ℝ) := Nat.cast_pos.2 hm
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ f ↑(m + 1) = f 1 + log ↑(m + 1 - 1)!
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ f ↑m + log ↑m = f 1 + log ↑m !
tactic: simp only [hf_feq A, Nat.cast_add, Nat.cast_one, Nat.add_succ_sub_one, add_zero]
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ f ↑m + log ↑m = f 1 + log ↑m !
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ f 1 + log ↑((m - 1)! * m) = f 1 + log ↑m !
tactic: rw [IH, add_assoc, ← log_mul (Nat.cast_ne_zero.mpr (Nat.factorial_ne_zero _)) A.ne', ←
    Nat.cast_mul]
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ f 1 + log ↑((m - 1)! * m) = f 1 + log ↑m !
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ f 1 + log ↑((m - 1)! * m) = f 1 + log ↑(m.pred ! * (m.pred + 1))
tactic: conv_rhs => rw [← Nat.succ_pred_eq_of_pos hm, Nat.factorial_succ, mul_comm]
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ f 1 + log ↑((m - 1)! * m) = f 1 + log ↑(m.pred ! * (m.pred + 1))
state_after: case e_a.e_x.e_a.e_a
f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ m = m.pred + 1
tactic: congr
state_before: case e_a.e_x.e_a.e_a
f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
m : ℕ
hm : 1 ≤ m
IH : f ↑m = f 1 + log ↑(m - 1)!
A : 0 < ↑m
⊢ m = m.pred + 1
state_after: no goals
tactic: exact (Nat.succ_pred_eq_of_pos hm).symm
Theorem: Set.ssubset_iff_sdiff_singleton
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ s ⊂ t ↔ ∃ a ∈ t, s ⊆ t \ {a}
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ (∃ a ∉ s, a ∈ t ∧ s ⊆ t) ↔ ∃ a ∈ t, s ⊆ t ∧ a ∉ s
tactic: simp [ssubset_iff_insert, subset_diff, insert_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ (∃ a ∉ s, a ∈ t ∧ s ⊆ t) ↔ ∃ a ∈ t, s ⊆ t ∧ a ∉ s
state_after: no goals
tactic: aesop
Theorem: Sum.isLeft_map
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β
g : γ → δ
x : α ⊕ γ
⊢ (Sum.map f g x).isLeft = x.isLeft
state_after: no goals
tactic: cases x <;> rfl
Theorem: FreeAddGroup.Red.length
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
h : Red L₁ L₂
⊢ ∃ n, L₁.length = L₂.length + 2 * n
state_after: case refl
α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ ∃ n, L₁.length = L₁.length + 2 * n

case tail
α : Type u
L L₁ L₂✝ L₃✝ L₄ L₂ L₃ : List (α × Bool)
_h₁₂ : ReflTransGen Step L₁ L₂
h₂₃ : Step L₂ L₃
ih : ∃ n, L₁.length = L₂.length + 2 * n
⊢ ∃ n, L₁.length = L₃.length + 2 * n
tactic: induction' h with L₂ L₃ _h₁₂ h₂₃ ih
Theorem: add_le_iff
File: Mathlib/Algebra/Order/Kleene.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝ : IdemSemiring α
a b c : α
⊢ a + b ≤ c ↔ a ≤ c ∧ b ≤ c
state_after: no goals
tactic: simp
Theorem: convexJoin_singleton_left
File: Mathlib/Analysis/Convex/Join.lean

Proof steps:
state_before: ι : Sort u_1
𝕜 : Type u_2
E : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s t✝ s₁ s₂ t₁ t₂ u : Set E
x✝ y : E
t : Set E
x : E
⊢ convexJoin 𝕜 {x} t = ⋃ y ∈ t, segment 𝕜 x y
state_after: no goals
tactic: simp [convexJoin]
Theorem: FirstOrder.Language.Theory.isSatisfiable_directed_union_iff
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
⊢ IsSatisfiable (⋃ i, T i) ↔ ∀ (i : ι), (T i).IsSatisfiable
state_after: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
⊢ IsSatisfiable (⋃ i, T i)
tactic: refine ⟨fun h' i => h'.mono (Set.subset_iUnion _ _), fun h' => ?_⟩
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
⊢ IsSatisfiable (⋃ i, T i)
state_after: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
⊢ ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ ⋃ i, T i → IsSatisfiable ↑T0
tactic: rw [isSatisfiable_iff_isFinitelySatisfiable, IsFinitelySatisfiable]
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
⊢ ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ ⋃ i, T i → IsSatisfiable ↑T0
state_after: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
T0 : Finset L.Sentence
hT0 : ↑T0 ⊆ ⋃ i, T i
⊢ IsSatisfiable ↑T0
tactic: intro T0 hT0
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
T0 : Finset L.Sentence
hT0 : ↑T0 ⊆ ⋃ i, T i
⊢ IsSatisfiable ↑T0
state_after: case intro
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
T0 : Finset L.Sentence
hT0 : ↑T0 ⊆ ⋃ i, T i
i : ι
hi : ↑T0 ⊆ T i
⊢ IsSatisfiable ↑T0
tactic: obtain ⟨i, hi⟩ := h.exists_mem_subset_of_finset_subset_biUnion hT0
state_before: case intro
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
T0 : Finset L.Sentence
hT0 : ↑T0 ⊆ ⋃ i, T i
i : ι
hi : ↑T0 ⊆ T i
⊢ IsSatisfiable ↑T0
state_after: no goals
tactic: exact (h' i).mono hi
Theorem: ZMod.valMinAbs_def_pos
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
⊢ x.valMinAbs = if x.val ≤ n / 2 then ↑x.val else ↑x.val - ↑n
state_after: case zero
m n : ℕ
inst✝ : NeZero 0
x : ZMod 0
⊢ x.valMinAbs = if x.val ≤ 0 / 2 then ↑x.val else ↑x.val - ↑0

case succ
m n n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
x : ZMod (n✝ + 1)
⊢ x.valMinAbs = if x.val ≤ (n✝ + 1) / 2 then ↑x.val else ↑x.val - ↑(n✝ + 1)
tactic: cases n
Theorem: lineMap_one_half
File: Mathlib/LinearAlgebra/AffineSpace/MidpointZero.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : DivisionRing R
inst✝³ : CharZero R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
a b : P
⊢ (lineMap a b) (1 / 2) = midpoint R a b
state_after: no goals
tactic: rw [one_div, lineMap_inv_two]
Theorem: Matrix.exp_transpose
File: Mathlib/Analysis/NormedSpace/MatrixExponential.lean

Proof steps:
state_before: 𝕂 : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
n' : m → Type u_5
𝔸 : Type u_6
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq m
inst✝⁵ : Field 𝕂
inst✝⁴ : CommRing 𝔸
inst✝³ : TopologicalSpace 𝔸
inst✝² : TopologicalRing 𝔸
inst✝¹ : Algebra 𝕂 𝔸
inst✝ : T2Space 𝔸
A : Matrix m m 𝔸
⊢ exp 𝕂 Aᵀ = (exp 𝕂 A)ᵀ
state_after: no goals
tactic: simp_rw [exp_eq_tsum, transpose_tsum, transpose_smul, transpose_pow]
Theorem: MeasureTheory.Measure.InnerRegularWRT.exists_subset_lt_add
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε
state_after: case inl
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U = 0
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε

case inr
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U ≠ 0
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε
tactic: rcases eq_or_ne (μ U) 0 with h₀ | h₀
Theorem: monovaryOn_inv
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ MonovaryOn f⁻¹ g⁻¹ s ↔ MonovaryOn f g s
state_after: no goals
tactic: simp
Theorem: Matrix.det_updateColumn_add_smul_self
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ (A.updateColumn i fun k => A k i + c • A k j).det = A.det
state_after: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ (Aᵀ.updateRow i fun k => A k i + c • A k j).det = Aᵀ.det
tactic: rw [← det_transpose, ← updateRow_transpose, ← det_transpose A]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ (Aᵀ.updateRow i fun k => A k i + c • A k j).det = Aᵀ.det
state_after: no goals
tactic: exact det_updateRow_add_smul_self Aᵀ hij c
Theorem: CategoryTheory.Subgroupoid.id_mem_of_nonempty_isotropy
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
⊢ c ∈ S.objs → 𝟙 c ∈ S.arrows c c
state_after: case intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
γ : c ⟶ c
hγ : γ ∈ S.arrows c c
⊢ 𝟙 c ∈ S.arrows c c
tactic: rintro ⟨γ, hγ⟩
state_before: case intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
γ : c ⟶ c
hγ : γ ∈ S.arrows c c
⊢ 𝟙 c ∈ S.arrows c c
state_after: case h.e'_4
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
γ : c ⟶ c
hγ : γ ∈ S.arrows c c
⊢ 𝟙 c = γ ≫ Groupoid.inv γ
tactic: convert S.mul hγ (S.inv hγ)
state_before: case h.e'_4
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
γ : c ⟶ c
hγ : γ ∈ S.arrows c c
⊢ 𝟙 c = γ ≫ Groupoid.inv γ
state_after: no goals
tactic: simp only [inv_eq_inv, IsIso.hom_inv_id]
Theorem: MeasureTheory.Measure.volumeIoiPow_apply_Iio
File: Mathlib/MeasureTheory/Constructions/HaarToSphere.lean

Proof steps:
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
n : ℕ
x : ↑(Ioi 0)
⊢ (volumeIoiPow n) (Iio x) = ENNReal.ofReal (↑x ^ (n + 1) / (↑n + 1))
state_after: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
n : ℕ
x : ↑(Ioi 0)
hr₀ : 0 ≤ ↑x
⊢ (volumeIoiPow n) (Iio x) = ENNReal.ofReal (↑x ^ (n + 1) / (↑n + 1))
tactic: have hr₀ : 0 ≤ x.1 := le_of_lt x.2
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
n : ℕ
x : ↑(Ioi 0)
hr₀ : 0 ≤ ↑x
⊢ (volumeIoiPow n) (Iio x) = ENNReal.ofReal (↑x ^ (n + 1) / (↑n + 1))
state_after: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
n : ℕ
x : ↑(Ioi 0)
hr₀ : 0 ≤ ↑x
⊢ ENNReal.ofReal (∫ (x : ℝ) in 0 ..↑x, x ^ n) = ENNReal.ofReal (↑x ^ (n + 1) / (↑n + 1))

E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
n : ℕ
x : ↑(Ioi 0)
hr₀ : 0 ≤ ↑x
⊢ 0 ≤ᶠ[ae (volume.restrict (Ioc 0 ↑x))] fun x => x ^ n
tactic: rw [volumeIoiPow, withDensity_apply _ measurableSet_Iio,
    setLIntegral_subtype measurableSet_Ioi _ fun a : ℝ ↦ .ofReal (a ^ n),
    image_subtype_val_Ioi_Iio, restrict_congr_set Ioo_ae_eq_Ioc,
    ← ofReal_integral_eq_lintegral_ofReal (intervalIntegrable_pow _).1, ← integral_of_le hr₀]
Theorem: ZMod.gauss_lemma
File: Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean

Proof steps:
state_before: p : ℕ
h : Fact (Nat.Prime p)
a : ℤ
hp : p ≠ 2
ha0 : ↑a ≠ 0
⊢ legendreSym p a = (-1) ^ (filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card
state_after: p : ℕ
h : Fact (Nat.Prime p)
a : ℤ
ha0 : ↑a ≠ 0
hp : Odd p
⊢ legendreSym p a = (-1) ^ (filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card
tactic: replace hp : Odd p := h.out.odd_of_ne_two hp
state_before: p : ℕ
h : Fact (Nat.Prime p)
a : ℤ
ha0 : ↑a ≠ 0
hp : Odd p
⊢ legendreSym p a = (-1) ^ (filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card
state_after: p : ℕ
h : Fact (Nat.Prime p)
a : ℤ
ha0 : ↑a ≠ 0
hp : Odd p
this : ↑(legendreSym p a) = ↑((-1) ^ (filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card)
⊢ legendreSym p a = (-1) ^ (filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card
tactic: have : (legendreSym p a : ZMod p) = (((-1) ^ ((Ico 1 (p / 2).succ).filter fun x : ℕ =>
      p / 2 < (a * x : ZMod p).val).card : ℤ) : ZMod p) := by
    rw [legendreSym.eq_pow, gauss_lemma_aux p ha0]
state_before: p : ℕ
h : Fact (Nat.Prime p)
a : ℤ
ha0 : ↑a ≠ 0
hp : Odd p
this : ↑(legendreSym p a) = ↑((-1) ^ (filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card)
⊢ legendreSym p a = (-1) ^ (filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card
state_after: no goals
tactic: cases legendreSym.eq_one_or_neg_one p ha0 <;>
  cases neg_one_pow_eq_or ℤ
    ((Ico 1 (p / 2).succ).filter fun x : ℕ => p / 2 < (a * x : ZMod p).val).card <;>
  simp_all [ne_neg_self hp one_ne_zero, (ne_neg_self hp one_ne_zero).symm]
Theorem: CategoryTheory.Equivalence.unit_app_inverse
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ e.unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ 𝟙 (e.inverse.obj Y) = 𝟙 (e.inverse.obj ((𝟭 D).obj Y))
tactic: erw [← Iso.comp_hom_eq_id (e.inverse.mapIso (e.counitIso.app Y)), unit_inverse_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ 𝟙 (e.inverse.obj Y) = 𝟙 (e.inverse.obj ((𝟭 D).obj Y))
state_after: no goals
tactic: dsimp
Theorem: pow_dvd_of_mul_eq_pow
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
h2 : d₁ ^ k ∣ a * b
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
tactic: have h2 : d₁ ^ k ∣ a * b := by
    use d₂ ^ k
    rw [h, hc]
    exact mul_pow d₁ d₂ k
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
h2 : d₁ ^ k ∣ a * b
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
h2 : d₁ ^ k ∣ b * a
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
tactic: rw [mul_comm] at h2
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
h2 : d₁ ^ k ∣ b * a
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
h2 : d₁ ^ k ∣ b * a
h3 : d₁ ^ k ∣ a
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
tactic: have h3 : d₁ ^ k ∣ a := by
    apply (dvd_gcd_mul_of_dvd_mul h2).trans
    rw [h1.mul_left_dvd]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
h2 : d₁ ^ k ∣ b * a
h3 : d₁ ^ k ∣ a
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
h2 : d₁ ^ k ∣ b * a
h3 : d₁ ^ k ∣ a
h4 : d₁ ^ k ≠ 0
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
tactic: have h4 : d₁ ^ k ≠ 0 := by
    intro hdk
    rw [hdk] at h3
    apply absurd (zero_dvd_iff.mp h3) ha
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c d₁ d₂ : α
ha : a ≠ 0
hab : IsUnit (gcd a b)
k : ℕ
h : a * b = c ^ k
hc : c = d₁ * d₂
hd₁ : d₁ ∣ a
h1 : IsUnit (gcd (d₁ ^ k) b)
h2 : d₁ ^ k ∣ b * a
h3 : d₁ ^ k ∣ a
h4 : d₁ ^ k ≠ 0
⊢ d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a
state_after: no goals
tactic: exact ⟨h4, h3⟩