ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Profinite.NobelingProof.continuous_swapTrue
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ Continuous (SwapTrue o)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ Continuous fun f i => if ord I i = o then true else f i
tactic: dsimp (config := { unfoldPartialApp := true }) [SwapTrue]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ Continuous fun f i => if ord I i = o then true else f i
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ ∀ (i : I), Continuous fun a => if ord I i = o then true else a i
tactic: apply continuous_pi
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ ∀ (i : I), Continuous fun a => if ord I i = o then true else a i
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
i : I
⊢ Continuous fun a => if ord I i = o then true else a i
tactic: intro i
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
i : I
⊢ Continuous fun a => if ord I i = o then true else a i
state_after: case h.hg
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
i : I
⊢ Continuous (ite (ord I i = o) true)

case h.hf
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
i : I
⊢ Continuous fun x => x i
tactic: apply Continuous.comp'
Theorem: Ordinal.bsup_comp
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
a : Ordinal.{max u v}
ha : a < o'
⊢ g a ha < o
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
a : Ordinal.{max u v}
ha : a < o'
⊢ g a ha < o'.blsub g
tactic: rw [← hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
a : Ordinal.{max u v}
ha : a < o'
⊢ g a ha < o'.blsub g
state_after: no goals
tactic: apply lt_blsub
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
⊢ (o'.bsup fun a ha => f (g a ha) ⋯) = o.bsup f
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
i : Ordinal.{max u v}
hi : i < o'
⊢ f (g i hi) ⋯ ≤ o.bsup f

case a
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
i : Ordinal.{max u v}
hi : i < o
⊢ f i hi ≤ o'.bsup fun a ha => f (g a ha) ⋯
tactic: apply le_antisymm <;> refine bsup_le fun i hi => ?_
Theorem: Algebra.IsAlgebraic.perfectField
File: Mathlib/FieldTheory/Perfect.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : Algebra.IsAlgebraic K L
inst✝ : PerfectField K
f : L[X]
hf : Irreducible f
⊢ f.Separable
state_after: case intro.intro.intro
K : Type u_1
L : Type u_2
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : Algebra.IsAlgebraic K L
inst✝ : PerfectField K
f : L[X]
hf : Irreducible f
w✝ : K[X]
left✝ : w✝.Monic
hi : Irreducible w✝
h : f ∣ map (algebraMap K L) w✝
⊢ f.Separable
tactic: obtain ⟨_, _, hi, h⟩ := hf.exists_dvd_monic_irreducible_of_isIntegral (K := K)
state_before: case intro.intro.intro
K : Type u_1
L : Type u_2
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : Algebra.IsAlgebraic K L
inst✝ : PerfectField K
f : L[X]
hf : Irreducible f
w✝ : K[X]
left✝ : w✝.Monic
hi : Irreducible w✝
h : f ∣ map (algebraMap K L) w✝
⊢ f.Separable
state_after: no goals
tactic: exact (PerfectField.separable_of_irreducible hi).map |>.of_dvd h
Theorem: Matrix.det_permute'
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
σ : Perm n
M : Matrix n n R
⊢ (M.submatrix id ⇑σ).det = ↑↑(sign σ) * M.det
state_after: no goals
tactic: rw [← det_transpose, transpose_submatrix, det_permute, det_transpose]
Theorem: Multiset.stronglyMeasurable_prod'
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l : Multiset (α → M)
hl : ∀ f ∈ l, StronglyMeasurable f
⊢ StronglyMeasurable l.prod
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, StronglyMeasurable f
⊢ StronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l))
tactic: rcases l with ⟨l⟩
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, StronglyMeasurable f
⊢ StronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l))
state_after: no goals
tactic: simpa using l.stronglyMeasurable_prod' (by simpa using hl)
Theorem: Monotone.ciSup_mem_iInter_Icc_of_antitone
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : SemilatticeSup β
f g : β → α
hf : Monotone f
hg : Antitone g
h : f ≤ g
⊢ ⨆ n, f n ∈ ⋂ n, Icc (f n) (g n)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : SemilatticeSup β
f g : β → α
hf : Monotone f
hg : Antitone g
h : f ≤ g
n : β
⊢ ⨆ n, f n ∈ Icc (f n) (g n)
tactic: refine mem_iInter.2 fun n => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : SemilatticeSup β
f g : β → α
hf : Monotone f
hg : Antitone g
h : f ≤ g
n : β
⊢ ⨆ n, f n ∈ Icc (f n) (g n)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : SemilatticeSup β
f g : β → α
hf : Monotone f
hg : Antitone g
h : f ≤ g
n : β
this : Nonempty β
⊢ ⨆ n, f n ∈ Icc (f n) (g n)
tactic: haveI : Nonempty β := ⟨n⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : SemilatticeSup β
f g : β → α
hf : Monotone f
hg : Antitone g
h : f ≤ g
n : β
this : Nonempty β
⊢ ⨆ n, f n ∈ Icc (f n) (g n)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : SemilatticeSup β
f g : β → α
hf : Monotone f
hg : Antitone g
h : f ≤ g
n : β
this✝ : Nonempty β
this : ∀ (m : β), f m ≤ g n
⊢ ⨆ n, f n ∈ Icc (f n) (g n)
tactic: have : ∀ m, f m ≤ g n := fun m => hf.forall_le_of_antitone hg h m n
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : SemilatticeSup β
f g : β → α
hf : Monotone f
hg : Antitone g
h : f ≤ g
n : β
this✝ : Nonempty β
this : ∀ (m : β), f m ≤ g n
⊢ ⨆ n, f n ∈ Icc (f n) (g n)
state_after: no goals
tactic: exact ⟨le_ciSup ⟨g <| n, forall_mem_range.2 this⟩ _, ciSup_le this⟩
Theorem: ENNReal.coe_inv_le
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ≥0∞
hb : 1 ≤ ↑r * b
⊢ ∀ (p : ℝ≥0), b = ↑p → r⁻¹ ≤ p
state_after: a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
hb : 1 ≤ ↑r * ↑b
⊢ r⁻¹ ≤ b
tactic: rintro b rfl
state_before: a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
hb : 1 ≤ ↑r * ↑b
⊢ r⁻¹ ≤ b
state_after: case h
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
hb : 1 ≤ ↑r * ↑b
⊢ 1 ≤ r * b
tactic: apply NNReal.inv_le_of_le_mul
state_before: case h
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
hb : 1 ≤ ↑r * ↑b
⊢ 1 ≤ r * b
state_after: no goals
tactic: rwa [← coe_mul, ← coe_one, coe_le_coe] at hb
Theorem: List.toFinsupp_eq_sum_map_enum_single
File: Mathlib/Data/List/ToFinsupp.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : Zero M
l✝ : List M
inst✝² : DecidablePred fun x => l✝.getD x 0 ≠ 0
n : ℕ
R : Type u_2
inst✝¹ : AddMonoid R
l : List R
inst✝ : DecidablePred fun x => l.getD x 0 ≠ 0
⊢ l.toFinsupp = (map (fun nr => Finsupp.single nr.1 nr.2) l.enum).sum
state_after: M : Type u_1
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => l.getD x 0 ≠ 0
n : ℕ
R : Type u_2
inst✝ : AddMonoid R
⊢ ∀ (l : List R) [inst : DecidablePred fun x => l.getD x 0 ≠ 0],
    l.toFinsupp = (map (fun nr => Finsupp.single nr.1 nr.2) l.enum).sum
tactic: revert l
state_before: M : Type u_1
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => l.getD x 0 ≠ 0
n : ℕ
R : Type u_2
inst✝ : AddMonoid R
⊢ ∀ (l : List R) [inst : DecidablePred fun x => l.getD x 0 ≠ 0],
    l.toFinsupp = (map (fun nr => Finsupp.single nr.1 nr.2) l.enum).sum
state_after: M : Type u_1
inst✝² : Zero M
l✝ : List M
inst✝¹ : DecidablePred fun x => l✝.getD x 0 ≠ 0
n : ℕ
R : Type u_2
inst✝ : AddMonoid R
l : List R
⊢ ∀ [inst : DecidablePred fun x => l.getD x 0 ≠ 0], l.toFinsupp = (map (fun nr => Finsupp.single nr.1 nr.2) l.enum).sum
tactic: intro l
state_before: M : Type u_1
inst✝² : Zero M
l✝ : List M
inst✝¹ : DecidablePred fun x => l✝.getD x 0 ≠ 0
n : ℕ
R : Type u_2
inst✝ : AddMonoid R
l : List R
⊢ ∀ [inst : DecidablePred fun x => l.getD x 0 ≠ 0], l.toFinsupp = (map (fun nr => Finsupp.single nr.1 nr.2) l.enum).sum
state_after: no goals
tactic: induction l using List.reverseRecOn with
  | nil => exact toFinsupp_nil
  | append_singleton x xs ih =>
    classical simp [toFinsupp_concat_eq_toFinsupp_add_single, enum_append, ih]
Theorem: Real.two_mul_arctan_inv_2_sub_arctan_inv_7
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: ⊢ 2 * arctan 2⁻¹ - arctan 7⁻¹ = π / 4
state_after: no goals
tactic: rw [two_mul_arctan, ← arctan_one, sub_eq_iff_eq_add, arctan_add] <;> norm_num
Theorem: Codisjoint.bihimp_eq_inf
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c d a b : α
h : Codisjoint a b
⊢ a ⇔ b = a ⊓ b
state_after: no goals
tactic: rw [bihimp, h.himp_eq_left, h.himp_eq_right]
Theorem: map_bind
File: Mathlib/Control/Basic.lean

Proof steps:
state_before: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : α → m β
f : β → γ
⊢ f <$> (x >>= g) = do
    let a ← x
    f <$> g a
state_after: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : α → m β
f : β → γ
⊢ (do
      let x ← x
      let a ← g x
      pure (f a)) =
    do
    let a ← x
    f <$> g a
tactic: rw [← bind_pure_comp, bind_assoc]
state_before: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : α → m β
f : β → γ
⊢ (do
      let x ← x
      let a ← g x
      pure (f a)) =
    do
    let a ← x
    f <$> g a
state_after: no goals
tactic: simp [bind_pure_comp]
Theorem: finprod_curry
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
h₁ : ∀ (a : α × β), ∏ᶠ (_ : a ∈ hf.toFinset), f a = f a
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
tactic: have h₁ : ∀ a, ∏ᶠ _ : a ∈ hf.toFinset, f a = f a := by simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
h₁ : ∀ (a : α × β), ∏ᶠ (_ : a ∈ hf.toFinset), f a = f a
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
h₁ : ∀ (a : α × β), ∏ᶠ (_ : a ∈ hf.toFinset), f a = f a
h₂ : ∏ᶠ (a : α × β), f a = ∏ᶠ (a : α × β) (_ : a ∈ hf.toFinset), f a
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
tactic: have h₂ : ∏ᶠ a, f a = ∏ᶠ (a) (_ : a ∈ hf.toFinset), f a := by simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
h₁ : ∀ (a : α × β), ∏ᶠ (_ : a ∈ hf.toFinset), f a = f a
h₂ : ∏ᶠ (a : α × β), f a = ∏ᶠ (a : α × β) (_ : a ∈ hf.toFinset), f a
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
state_after: no goals
tactic: simp_rw [h₂, finprod_mem_finset_product, h₁]
Theorem: invOf_mul_self_assoc
File: Mathlib/Algebra/Group/Invertible/Defs.lean

Proof steps:
state_before: α : Type u
inst✝¹ : Monoid α
a b : α
inst✝ : Invertible a
⊢ ⅟a * (a * b) = b
state_after: no goals
tactic: rw [← mul_assoc, invOf_mul_self, one_mul]
Theorem: TopologicalSpace.Compacts.equiv_apply
File: Mathlib/Topology/Sets/Compacts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
s : Compacts α
⊢ Compacts.map ⇑f.symm ⋯ (Compacts.map ⇑f ⋯ s) = s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
s : Compacts α
⊢ ↑(Compacts.map ⇑f.symm ⋯ (Compacts.map ⇑f ⋯ s)) = ↑s
tactic: ext1
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
s : Compacts α
⊢ ↑(Compacts.map ⇑f.symm ⋯ (Compacts.map ⇑f ⋯ s)) = ↑s
state_after: no goals
tactic: simp only [coe_map, ← image_comp, f.symm_comp_self, image_id]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
s : Compacts β
⊢ Compacts.map ⇑f ⋯ (Compacts.map ⇑f.symm ⋯ s) = s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
s : Compacts β
⊢ ↑(Compacts.map ⇑f ⋯ (Compacts.map ⇑f.symm ⋯ s)) = ↑s
tactic: ext1
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
s : Compacts β
⊢ ↑(Compacts.map ⇑f ⋯ (Compacts.map ⇑f.symm ⋯ s)) = ↑s
state_after: no goals
tactic: simp only [coe_map, ← image_comp, f.self_comp_symm, image_id]
Theorem: Polynomial.content_X
File: Mathlib/RingTheory/Polynomial/Content.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
⊢ X.content = 1
state_after: no goals
tactic: rw [← mul_one X, content_X_mul, content_one]
Theorem: Fin.length_list
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: n : Nat
⊢ (list n).length = n
state_after: no goals
tactic: simp [list]
Theorem: Equiv.Perm.toList_one
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
⊢ toList 1 x = []
state_after: no goals
tactic: simp [toList, cycleOf_one]
Theorem: Rack.self_distrib_inv
File: Mathlib/Algebra/Quandle.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Rack R
x y z : R
⊢ x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y) ◃⁻¹ x ◃⁻¹ z
state_after: R : Type u_1
inst✝ : Rack R
x y z : R
⊢ (x ◃ x ◃⁻¹ y) ◃ x ◃ x ◃⁻¹ y ◃⁻¹ z = z
tactic: rw [← left_cancel (x ◃⁻¹ y), right_inv, ← left_cancel x, right_inv, self_distrib]
state_before: R : Type u_1
inst✝ : Rack R
x y z : R
⊢ (x ◃ x ◃⁻¹ y) ◃ x ◃ x ◃⁻¹ y ◃⁻¹ z = z
state_after: no goals
tactic: repeat' rw [right_inv]
Theorem: Rel.mul_edgeDensity_le_edgeDensity
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 : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
hs₂ : s₂.Nonempty
ht₂ : t₂.Nonempty
⊢ ↑s₂.card / ↑s₁.card * (↑t₂.card / ↑t₁.card) * edgeDensity r s₂ t₂ ≤ edgeDensity r s₁ t₁
state_after: 𝕜 : 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 : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
hs₂ : s₂.Nonempty
ht₂ : t₂.Nonempty
hst : ↑s₂.card * ↑t₂.card ≠ 0
⊢ ↑s₂.card / ↑s₁.card * (↑t₂.card / ↑t₁.card) * edgeDensity r s₂ t₂ ≤ edgeDensity r s₁ t₁
tactic: have hst : (s₂.card : ℚ) * t₂.card ≠ 0 := by simp [hs₂.ne_empty, ht₂.ne_empty]
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 : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
hs₂ : s₂.Nonempty
ht₂ : t₂.Nonempty
hst : ↑s₂.card * ↑t₂.card ≠ 0
⊢ ↑s₂.card / ↑s₁.card * (↑t₂.card / ↑t₁.card) * edgeDensity r s₂ t₂ ≤ edgeDensity r s₁ t₁
state_after: 𝕜 : 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 : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
hs₂ : s₂.Nonempty
ht₂ : t₂.Nonempty
hst : ↑s₂.card * ↑t₂.card ≠ 0
⊢ ↑(interedges r s₂ t₂).card / (↑s₁.card * ↑t₁.card) ≤ ↑(interedges r s₁ t₁).card / (↑s₁.card * ↑t₁.card)
tactic: rw [edgeDensity, edgeDensity, div_mul_div_comm, mul_comm, div_mul_div_cancel _ hst]
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 : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
hs₂ : s₂.Nonempty
ht₂ : t₂.Nonempty
hst : ↑s₂.card * ↑t₂.card ≠ 0
⊢ ↑(interedges r s₂ t₂).card / (↑s₁.card * ↑t₁.card) ≤ ↑(interedges r s₁ t₁).card / (↑s₁.card * ↑t₁.card)
state_after: case hab.h.a
𝕜 : 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 : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
hs₂ : s₂.Nonempty
ht₂ : t₂.Nonempty
hst : ↑s₂.card * ↑t₂.card ≠ 0
⊢ interedges r s₂ t₂ ⊆ interedges r s₁ t₁
tactic: gcongr
state_before: case hab.h.a
𝕜 : 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 : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
hs₂ : s₂.Nonempty
ht₂ : t₂.Nonempty
hst : ↑s₂.card * ↑t₂.card ≠ 0
⊢ interedges r s₂ t₂ ⊆ interedges r s₁ t₁
state_after: no goals
tactic: exact interedges_mono hs ht
Theorem: Finsupp.mapRange_zero
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
f : M → N
hf : f 0 = 0
x✝ : α
⊢ (mapRange f hf 0) x✝ = 0 x✝
state_after: no goals
tactic: simp only [hf, zero_apply, mapRange_apply]
Theorem: RingHom.codomain_trivial_iff_map_one_eq_zero
File: Mathlib/Algebra/Ring/Hom/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f : α →+* β
x y : α
⊢ 0 = 1 ↔ f 1 = 0
state_after: no goals
tactic: rw [map_one, eq_comm]
Theorem: Real.div_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z✝ : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
z : ℝ
⊢ (x / y) ^ z = x ^ z / y ^ z
state_after: no goals
tactic: simp only [div_eq_mul_inv, mul_rpow hx (inv_nonneg.2 hy), inv_rpow hy]