ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsMinFilter.sub
File: Mathlib/Order/Filter/Extr.lean

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

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
ι : Sort u_3
us' : ι → UniformSpace β
h' : ∀ (i : ι), UniformGroup β
⊢ UniformGroup β
state_after: no goals
tactic: exact uniformGroup_sInf (Set.forall_mem_range.mpr h')
Theorem: Filter.coclosedCompact_eq_cocompact
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
⊢ coclosedCompact X = cocompact X
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
⊢ coclosedCompact X ≤ cocompact X
tactic: refine le_antisymm ?_ cocompact_le_coclosedCompact
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
⊢ coclosedCompact X ≤ cocompact X
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
⊢ ∀ (i' : Set X), IsCompact i' → ∃ i, (IsClosed i ∧ IsCompact i) ∧ iᶜ ⊆ i'ᶜ
tactic: rw [hasBasis_coclosedCompact.le_basis_iff hasBasis_cocompact]
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
⊢ ∀ (i' : Set X), IsCompact i' → ∃ i, (IsClosed i ∧ IsCompact i) ∧ iᶜ ⊆ i'ᶜ
state_after: no goals
tactic: exact fun K hK ↦ ⟨closure K, ⟨isClosed_closure, hK.closure⟩, compl_subset_compl.2 subset_closure⟩
Theorem: Nat.sub_lt_iff_lt_add'
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hba : b ≤ a
⊢ a - b < c ↔ a < c + b
state_after: no goals
tactic: omega
Theorem: Class.mem_of_mem_sInter
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x y z : Class
hy : y ∈ ⋂₀ x
hz : z ∈ x
⊢ y ∈ z
state_after: case intro.intro
x z : Class
hz : z ∈ x
w : ZFSet
hw : (⋂₀ x) w
⊢ ↑w ∈ z
tactic: obtain ⟨w, rfl, hw⟩ := hy
state_before: case intro.intro
x z : Class
hz : z ∈ x
w : ZFSet
hw : (⋂₀ x) w
⊢ ↑w ∈ z
state_after: no goals
tactic: exact coe_mem.2 (hw z hz)
Theorem: Finset.pairwiseDisjoint_map_sigmaMk
File: Mathlib/Data/Finset/Sigma.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
⊢ (↑s).PairwiseDisjoint fun i => map (Embedding.sigmaMk i) (t i)
state_after: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ (_root_.Disjoint on fun i => map (Embedding.sigmaMk i) (t i)) i j
tactic: intro i _ j _ hij
state_before: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ (_root_.Disjoint on fun i => map (Embedding.sigmaMk i) (t i)) i j
state_after: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ ∀ ⦃a : (x : ι) × α x⦄, a ∈ map (Embedding.sigmaMk i) (t i) → a ∉ map (Embedding.sigmaMk j) (t j)
tactic: rw [Function.onFun, disjoint_left]
state_before: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ ∀ ⦃a : (x : ι) × α x⦄, a ∈ map (Embedding.sigmaMk i) (t i) → a ∉ map (Embedding.sigmaMk j) (t j)
state_after: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ ∀ ⦃a : (x : ι) × α x⦄, (∃ a_1 ∈ t i, ⟨i, a_1⟩ = a) → ¬∃ a_2 ∈ t j, ⟨j, a_2⟩ = a
tactic: simp_rw [mem_map, Function.Embedding.sigmaMk_apply]
state_before: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ ∀ ⦃a : (x : ι) × α x⦄, (∃ a_1 ∈ t i, ⟨i, a_1⟩ = a) → ¬∃ a_2 ∈ t j, ⟨j, a_2⟩ = a
state_after: case intro.intro.intro.intro
ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
y : α i
left✝¹ : y ∈ t i
z : α j
left✝ : z ∈ t j
hz' : ⟨j, z⟩ = ⟨i, y⟩
⊢ False
tactic: rintro _ ⟨y, _, rfl⟩ ⟨z, _, hz'⟩
state_before: case intro.intro.intro.intro
ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
y : α i
left✝¹ : y ∈ t i
z : α j
left✝ : z ∈ t j
hz' : ⟨j, z⟩ = ⟨i, y⟩
⊢ False
state_after: no goals
tactic: exact hij (congr_arg Sigma.fst hz'.symm)
Theorem: vadd_add_vadd
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
inst✝⁴ : Monoid M
inst✝³ : MulAction M α
inst✝² : Mul α
r s : M
x y : α
inst✝¹ : IsScalarTower M α α
inst✝ : SMulCommClass M α α
⊢ r • x * s • y = (r * s) • (x * y)
state_after: no goals
tactic: rw [smul_mul_assoc, mul_smul_comm, ← smul_assoc, smul_eq_mul]
Theorem: PLift.down_injective
File: Mathlib/Logic/Function/ULift.lean

Proof steps:
state_before: α : Sort u_1
a b : α
x✝ : { down := a }.down = { down := b }.down
⊢ { down := a } = { down := b }
state_after: no goals
tactic: congr
Theorem: Rel.card_interedges_add_card_interedges_compl
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t : Finset β
⊢ (interedges r s t).card + (interedges (fun x y => ¬r x y) s t).card = s.card * t.card
state_after: no goals
tactic: classical
  rw [← card_product, interedges, interedges, ← card_union_of_disjoint, filter_union_filter_neg_eq]
  exact disjoint_filter.2 fun _ _ ↦ Classical.not_not.2
Theorem: schnirelmannDensity_finset
File: Mathlib/Combinatorics/Schnirelmann.lean

Proof steps:
state_before: A : Finset ℕ
⊢ schnirelmannDensity ↑A = 0
state_after: A : Finset ℕ
⊢ schnirelmannDensity ↑A ≤ 0
tactic: refine le_antisymm ?_ schnirelmannDensity_nonneg
state_before: A : Finset ℕ
⊢ schnirelmannDensity ↑A ≤ 0
state_after: A : Finset ℕ
⊢ ∀ (ε : ℝ), 0 < ε → ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
tactic: simp only [schnirelmannDensity_le_iff_forall, zero_add]
state_before: A : Finset ℕ
⊢ ∀ (ε : ℝ), 0 < ε → ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
state_after: A : Finset ℕ
ε : ℝ
hε : 0 < ε
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
tactic: intro ε hε
state_before: A : Finset ℕ
ε : ℝ
hε : 0 < ε
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
state_after: case inr
A : Finset ℕ
ε : ℝ
hε : 0 < ε
this : ∀ (ε : ℝ), 0 < ε → ε ≤ 1 → ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
hε₁ : ¬ε ≤ 1
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε

A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
tactic: wlog hε₁ : ε ≤ 1 generalizing ε
state_before: A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
state_after: A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
n : ℕ := ⌊↑A.card / ε⌋₊ + 1
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
tactic: let n : ℕ := ⌊A.card / ε⌋₊ + 1
state_before: A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
n : ℕ := ⌊↑A.card / ε⌋₊ + 1
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
state_after: A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
n : ℕ := ⌊↑A.card / ε⌋₊ + 1
hn : 0 < n
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
tactic: have hn : 0 < n := Nat.succ_pos _
state_before: A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
n : ℕ := ⌊↑A.card / ε⌋₊ + 1
hn : 0 < n
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
state_after: case right
A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
n : ℕ := ⌊↑A.card / ε⌋₊ + 1
hn : 0 < n
⊢ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
tactic: use n, hn
state_before: case right
A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
n : ℕ := ⌊↑A.card / ε⌋₊ + 1
hn : 0 < n
⊢ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ↑n < ε
state_after: case right
A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
n : ℕ := ⌊↑A.card / ε⌋₊ + 1
hn : 0 < n
⊢ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ε < ↑⌊↑A.card / ε⌋₊ + 1
tactic: rw [div_lt_iff (Nat.cast_pos.2 hn), ← div_lt_iff' hε, Nat.cast_add_one]
state_before: case right
A : Finset ℕ
ε : ℝ
hε : 0 < ε
hε₁ : ε ≤ 1
n : ℕ := ⌊↑A.card / ε⌋₊ + 1
hn : 0 < n
⊢ ↑(filter (fun x => x ∈ ↑A) (Ioc 0 n)).card / ε < ↑⌊↑A.card / ε⌋₊ + 1
state_after: no goals
tactic: exact (Nat.lt_floor_add_one _).trans_le' <| by gcongr; simp [subset_iff]
Theorem: le_mul_left
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
h : a ≤ c
⊢ a = 1 * a
state_after: no goals
tactic: simp
Theorem: toIocMod_le_toIcoMod_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp a b ≤ toIcoMod hp a b + p
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a b ≤ toIocDiv hp a b + 1
tactic: rw [toIcoMod, toIocMod, sub_add, sub_le_sub_iff_left, sub_le_iff_le_add, ← add_one_zsmul,
    (zsmul_strictMono_left hp).le_iff_le]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a b ≤ toIocDiv hp a b + 1
state_after: no goals
tactic: apply (toIocDiv_wcovBy_toIcoDiv _ _ _).le_succ
Theorem: Nat.not_isWellOrderLimitElement
File: Mathlib/Order/IsWellOrderLimitElement.lean

Proof steps:
state_before: α : Type u_1
inst✝² : LinearOrder α
a✝ : α
ha : IsWellOrderLimitElement a✝
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
a : ℕ
inst✝ : IsWellOrderLimitElement a
⊢ False
state_after: case zero
α : Type u_1
inst✝² : LinearOrder α
a : α
ha : IsWellOrderLimitElement a
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
inst✝ : IsWellOrderLimitElement 0
⊢ False

case succ
α : Type u_1
inst✝² : LinearOrder α
a✝ : α
ha : IsWellOrderLimitElement a✝
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
a : ℕ
inst✝ : IsWellOrderLimitElement (a + 1)
⊢ False
tactic: obtain _|a := a
Theorem: Right.inv_lt_one_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a⁻¹ < 1 ↔ 1 < a
state_after: no goals
tactic: rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
Theorem: RCLike.normSq_sub
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z w : K
⊢ normSq (z - w) = normSq z + normSq w - 2 * re (z * (starRingEnd K) w)
state_after: no goals
tactic: simp only [normSq_add, sub_eq_add_neg, map_neg, mul_neg, normSq_neg, map_neg]
Theorem: Int.natCast_dvd
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m✝ n : ℤ
m : ℕ
⊢ ↑m ∣ n ↔ m ∣ n.natAbs
state_after: no goals
tactic: obtain hn | hn := natAbs_eq n <;> rw [hn] <;> simp [← natCast_dvd_natCast, Int.dvd_neg]
Theorem: WithTop.coe_sSup'
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ↑(sSup s) = sSup ((fun a => ↑a) '' s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ↑(sSup s) =
    if ⊤ ∈ (fun a => ↑a) '' s then ⊤
    else
      if BddAbove ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s)) then ↑(sSup ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s))) else ⊤
tactic: change _ = ite _ _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ↑(sSup s) =
    if ⊤ ∈ (fun a => ↑a) '' s then ⊤
    else
      if BddAbove ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s)) then ↑(sSup ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s))) else ⊤
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ Injective fun a => ↑a

case hnc
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ⊤ ∉ (fun a => ↑a) '' s
tactic: rw [if_neg, preimage_image_eq, if_pos hs]
Theorem: ENNReal.log_ofReal
File: Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean

Proof steps:
state_before: x : ℝ
⊢ (ENNReal.ofReal x).log = if x ≤ 0 then ⊥ else ↑(Real.log x)
state_after: x : ℝ
⊢ (if x ≤ 0 then ⊥ else if False then ⊤ else ↑(Real.log (ENNReal.ofReal x).toReal)) = if x ≤ 0 then ⊥ else ↑(Real.log x)
tactic: simp only [log, ENNReal.none_eq_top, ENNReal.ofReal_ne_top, IsEmpty.forall_iff,
    ENNReal.ofReal_eq_zero, EReal.coe_ennreal_ofReal]
state_before: x : ℝ
⊢ (if x ≤ 0 then ⊥ else if False then ⊤ else ↑(Real.log (ENNReal.ofReal x).toReal)) = if x ≤ 0 then ⊥ else ↑(Real.log x)
state_after: case pos
x : ℝ
h_nonpos : x ≤ 0
⊢ ⊥ = ⊥

case pos
x : ℝ
h_nonpos : ¬x ≤ 0
h✝ : False
⊢ ⊤ = ↑(Real.log x)

case neg
x : ℝ
h_nonpos : ¬x ≤ 0
h✝ : ¬False
⊢ ↑(Real.log (ENNReal.ofReal x).toReal) = ↑(Real.log x)
tactic: split_ifs with h_nonpos
Theorem: Submodule.map_inf_eq_map_inf_comap
File: Mathlib/Algebra/Module/Submodule/Map.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p'✝ : Submodule R M
q q' : Submodule R₂ M₂
x : M
F : Type u_9
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
inst✝ : RingHomSurjective σ₁₂
f : F
p : Submodule R M
p' : Submodule R₂ M₂
⊢ map f p ⊓ p' ≤ map f (p ⊓ comap f p')
state_after: case intro.intro.intro
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p'✝ : Submodule R M
q q' : Submodule R₂ M₂
x✝ : M
F : Type u_9
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
inst✝ : RingHomSurjective σ₁₂
f : F
p : Submodule R M
p' : Submodule R₂ M₂
x : M
h₁ : x ∈ ↑p
h₂ : f x ∈ ↑p'
⊢ f x ∈ map f (p ⊓ comap f p')
tactic: rintro _ ⟨⟨x, h₁, rfl⟩, h₂⟩
state_before: case intro.intro.intro
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p'✝ : Submodule R M
q q' : Submodule R₂ M₂
x✝ : M
F : Type u_9
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
inst✝ : RingHomSurjective σ₁₂
f : F
p : Submodule R M
p' : Submodule R₂ M₂
x : M
h₁ : x ∈ ↑p
h₂ : f x ∈ ↑p'
⊢ f x ∈ map f (p ⊓ comap f p')
state_after: no goals
tactic: exact ⟨_, ⟨h₁, h₂⟩, rfl⟩
Theorem: Mathlib.Tactic.Monoidal.evalComp_nil_nil
File: Mathlib/Tactic/CategoryTheory/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
f✝ f' g✝ g' h✝ i j f g h : C
α : f ⟶ g
β : g ⟶ h
⊢ α ≫ β = α ≫ β
state_after: no goals
tactic: simp
Theorem: Turing.Tape.mk'_nth_nat
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
L R : ListBlank Γ
n : ℕ
⊢ (mk' L R).nth ↑n = R.nth n
state_after: no goals
tactic: rw [← Tape.right₀_nth, Tape.mk'_right₀]
Theorem: CategoryTheory.coyonedaEquiv_symm_map
File: Mathlib/CategoryTheory/Yoneda.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
F : C ⥤ Type v₁
t : F.obj X
⊢ coyonedaEquiv.symm (F.map f t) = coyoneda.map f.op ≫ coyonedaEquiv.symm t
state_after: case intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
F : C ⥤ Type v₁
u : coyoneda.obj (op X) ⟶ F
⊢ coyonedaEquiv.symm (F.map f (coyonedaEquiv u)) = coyoneda.map f.op ≫ coyonedaEquiv.symm (coyonedaEquiv u)
tactic: obtain ⟨u, rfl⟩ := coyonedaEquiv.surjective t
state_before: case intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
F : C ⥤ Type v₁
u : coyoneda.obj (op X) ⟶ F
⊢ coyonedaEquiv.symm (F.map f (coyonedaEquiv u)) = coyoneda.map f.op ≫ coyonedaEquiv.symm (coyonedaEquiv u)
state_after: no goals
tactic: simp [coyonedaEquiv_naturality u f]
Theorem: Complex.Gamma_mul_Gamma_one_sub
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

Proof steps:
state_before: z : ℂ
⊢ Gamma z * Gamma (1 - z) = ↑π / sin (↑π * z)
state_after: z : ℂ
pi_ne : ↑π ≠ 0
⊢ Gamma z * Gamma (1 - z) = ↑π / sin (↑π * z)
tactic: have pi_ne : (π : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr pi_ne_zero
state_before: z : ℂ
pi_ne : ↑π ≠ 0
⊢ Gamma z * Gamma (1 - z) = ↑π / sin (↑π * z)
state_after: case pos
z : ℂ
pi_ne : ↑π ≠ 0
hs : sin (↑π * z) = 0
⊢ Gamma z * Gamma (1 - z) = ↑π / sin (↑π * z)

case neg
z : ℂ
pi_ne : ↑π ≠ 0
hs : ¬sin (↑π * z) = 0
⊢ Gamma z * Gamma (1 - z) = ↑π / sin (↑π * z)
tactic: by_cases hs : sin (↑π * z) = 0
state_before: case neg
z : ℂ
pi_ne : ↑π ≠ 0
hs : ¬sin (↑π * z) = 0
⊢ Gamma z * Gamma (1 - z) = ↑π / sin (↑π * z)
state_after: case neg
z : ℂ
pi_ne : ↑π ≠ 0
hs : ¬sin (↑π * z) = 0
⊢ Tendsto (fun x => z.GammaSeq x * (1 - z).GammaSeq x) atTop (𝓝 (↑π / sin (↑π * z)))
tactic: refine tendsto_nhds_unique ((GammaSeq_tendsto_Gamma z).mul (GammaSeq_tendsto_Gamma <| 1 - z)) ?_
state_before: case neg
z : ℂ
pi_ne : ↑π ≠ 0
hs : ¬sin (↑π * z) = 0
⊢ Tendsto (fun x => z.GammaSeq x * (1 - z).GammaSeq x) atTop (𝓝 (↑π / sin (↑π * z)))
state_after: case neg
z : ℂ
pi_ne : ↑π ≠ 0
hs : ¬sin (↑π * z) = 0
this : ↑π / sin (↑π * z) = 1 * (↑π / sin (↑π * z))
⊢ Tendsto (fun x => z.GammaSeq x * (1 - z).GammaSeq x) atTop (𝓝 (↑π / sin (↑π * z)))
tactic: have : ↑π / sin (↑π * z) = 1 * (π / sin (π * z)) := by rw [one_mul]
state_before: case neg
z : ℂ
pi_ne : ↑π ≠ 0
hs : ¬sin (↑π * z) = 0
this : ↑π / sin (↑π * z) = 1 * (↑π / sin (↑π * z))
⊢ Tendsto (fun x => z.GammaSeq x * (1 - z).GammaSeq x) atTop (𝓝 (↑π / sin (↑π * z)))
state_after: case neg.convert_3
z : ℂ
pi_ne : ↑π ≠ 0
hs : ¬sin (↑π * z) = 0
this : ↑π / sin (↑π * z) = 1 * (↑π / sin (↑π * z))
⊢ Tendsto (fun n => ↑n / (↑n + 1 - z)) atTop (𝓝 1)

case neg.convert_4
z : ℂ
pi_ne : ↑π ≠ 0
hs : ¬sin (↑π * z) = 0
this : ↑π / sin (↑π * z) = 1 * (↑π / sin (↑π * z))
⊢ Tendsto (fun n => 1 / (z * ∏ j ∈ Finset.range n, (1 - z ^ 2 / (↑j + 1) ^ 2))) atTop (𝓝 (↑π / sin (↑π * z)))
tactic: convert Tendsto.congr' ((eventually_ne_atTop 0).mp (eventually_of_forall fun n hn =>
    (GammaSeq_mul z hn).symm)) (Tendsto.mul _ _)
Theorem: LinearMap.isSymmetric_iff_isSelfAdjoint
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] E
⊢ A.IsSymmetric ↔ IsSelfAdjoint A
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] E
⊢ A = adjoint A ↔ adjoint A = A
tactic: rw [isSelfAdjoint_iff', IsSymmetric, ← LinearMap.eq_adjoint_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] E
⊢ A = adjoint A ↔ adjoint A = A
state_after: no goals
tactic: exact eq_comm
Theorem: LinearMap.injective_iff_surjective_of_finrank_eq_finrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
⊢ Injective ⇑f ↔ Surjective ⇑f
state_after: K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K ↥(range f) + finrank K ↥(ker f) = finrank K V
⊢ Injective ⇑f ↔ Surjective ⇑f
tactic: have := finrank_range_add_finrank_ker f
state_before: K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K ↥(range f) + finrank K ↥(ker f) = finrank K V
⊢ Injective ⇑f ↔ Surjective ⇑f
state_after: K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K ↥(range f) + finrank K ↥(ker f) = finrank K V
⊢ ker f = ⊥ ↔ range f = ⊤
tactic: rw [← ker_eq_bot, ← range_eq_top]
state_before: K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K ↥(range f) + finrank K ↥(ker f) = finrank K V
⊢ ker f = ⊥ ↔ range f = ⊤
state_after: case refine_1
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K ↥(range f) + finrank K ↥(ker f) = finrank K V
h : ker f = ⊥
⊢ range f = ⊤

case refine_2
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K ↥(range f) + finrank K ↥(ker f) = finrank K V
h : range f = ⊤
⊢ ker f = ⊥
tactic: refine ⟨fun h => ?_, fun h => ?_⟩