tasksource/leandojo huggingface dataset:
Theorem: Function.Injective.beq_eq
File: Mathlib/Logic/Function/Basic.lean

tactic: by_cases h : a == b <;> simp [h] <;> simpa [I.eq_iff] using h
state_before: α : Type u_1
β : Type u_2
γ : Sort ?u.1513
f : α → β
inst✝³ : BEq α
inst✝² : LawfulBEq α
inst✝¹ : BEq β
inst✝ : LawfulBEq β
I : Injective f
a b : α
⊢ (f a == f b) = (a == b)
Theorem: Fintype.card_subtype_lt
File: Mathlib/Data/Fintype/Card.lean

tactic: rwa [Subtype.range_coe_subtype]
state_before: α : Type u_1
β : Type ?u.55528
γ : Type ?u.55531
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
x : α
hx : ¬p x
⊢ ¬?m.55837 hx ∈ Set.range Subtype.val
Theorem: WfDvdMonoid.of_wfDvdMonoid_associates
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: refine' (Surjective.wellFounded_iff mk_surjective _).2 wellFounded_dvdNotUnit
state_before: α : Type u_1
inst✝ : CommMonoidWithZero α
h : WfDvdMonoid (Associates α)
⊢ WellFounded DvdNotUnit

tactic: intros
state_before: α : Type u_1
inst✝ : CommMonoidWithZero α
h : WfDvdMonoid (Associates α)
⊢ ∀ {a b : α}, DvdNotUnit a b ↔ DvdNotUnit (Associates.mk a) (Associates.mk b)

tactic: rw [mk_dvdNotUnit_mk_iff]
state_before: α : Type u_1
inst✝ : CommMonoidWithZero α
h : WfDvdMonoid (Associates α)
a✝ b✝ : α
⊢ DvdNotUnit a✝ b✝ ↔ DvdNotUnit (Associates.mk a✝) (Associates.mk b✝)
Theorem: zero_eq_dist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [eq_comm, dist_eq_zero]
state_before: α : Type u
β : Type v
X : Type ?u.548945
ι : Type ?u.548948
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x y : γ
⊢ 0 = dist x y ↔ x = y
Theorem: real_inner_I_smul_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp [real_inner_eq_re_inner 𝕜, inner_smul_right]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.4042510
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
G : Type ?u.4042559
x : E
⊢ inner x (I • x) = 0
Theorem: Fin.card_Iic
File: Mathlib/Data/Fin/Interval.lean

tactic: rw [← Nat.card_Iic b, ← map_valEmbedding_Iic, card_map]
state_before: n : ℕ
a b : Fin n
⊢ card (Iic b) = ↑b + 1
Theorem: Filter.tendsto_pi
File: Mathlib/Order/Filter/Pi.lean

tactic: simp only [pi, tendsto_iInf, tendsto_comap_iff]
state_before: ι : Type u_2
α : ι → Type u_3
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
β : Type u_1
m : β → (i : ι) → α i
l : Filter β
⊢ Tendsto m l (pi f) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)

tactic: rfl
state_before: ι : Type u_2
α : ι → Type u_3
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
β : Type u_1
m : β → (i : ι) → α i
l : Filter β
⊢ (∀ (i : ι), Tendsto (eval i ∘ m) l (f i)) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)
Theorem: Nat.add_sub_add_right
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction k with
| zero => simp
| succ k ih => simp [add_succ, add_succ, succ_sub_succ, ih]
state_before: n k m : Nat
⊢ n + k - (m + k) = n - m

tactic: simp
state_before: case zero
n m : Nat
⊢ n + zero - (m + zero) = n - m

tactic: simp [add_succ, add_succ, succ_sub_succ, ih]
state_before: case succ
n m k : Nat
ih : n + k - (m + k) = n - m
⊢ n + succ k - (m + succ k) = n - m
Theorem: UV.compress_idem
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: unfold compress
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
⊢ compress u v (compress u v a) = compress u v a

tactic: split_ifs with h h' <;> try rfl
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
⊢ (if
        Disjoint u (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ∧
          v ≤ if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a then
      ((if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ⊔ u) \ v
    else if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) =
    if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a

tactic: rw [le_sdiff_iff.1 h'.2, sdiff_bot, sdiff_bot, sup_assoc, sup_idem]
state_before: case inl.inl
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
h : Disjoint u a ∧ v ≤ a
h' : Disjoint u ((a ⊔ u) \ v) ∧ v ≤ (a ⊔ u) \ v
⊢ ((a ⊔ u) \ v ⊔ u) \ v = (a ⊔ u) \ v

tactic: rfl
state_before: case inr
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
h : ¬(Disjoint u a ∧ v ≤ a)
⊢ a = a
Theorem: List.zip_unzip
File: Mathlib/Data/List/Zip.lean

tactic: simp only [unzip_cons, zip_cons_cons, zip_unzip l]
state_before: α : Type u
β : Type u_1
γ : Type ?u.85724
δ : Type ?u.85727
ε : Type ?u.85730
a : α
b : β
l : List (α × β)
⊢ zip (unzip ((a, b) :: l)).fst (unzip ((a, b) :: l)).snd = (a, b) :: l
Theorem: Mathlib.Meta.NormNum.isRat_eq_true
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: congr
state_before: α : Type u_1
inst✝ : Ring α
num✝ : ℤ
denom✝ : ℕ
inv✝¹ inv✝ : Invertible ↑denom✝
⊢ ↑num✝ * ⅟↑denom✝ = ↑num✝ * ⅟↑denom✝

tactic: apply Subsingleton.elim
state_before: case e_a.h.e_5.h
α : Type u_1
inst✝ : Ring α
num✝ : ℤ
denom✝ : ℕ
inv✝¹ inv✝ : Invertible ↑denom✝
⊢ inv✝¹ = inv✝
Theorem: CategoryTheory.Limits.IsImage.fac_lift
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝ : Category C
X Y : C
f : X ⟶ Y
F : MonoFactorisation f
hF : IsImage F
F' : MonoFactorisation f
⊢ (F.e ≫ lift hF F') ≫ F'.m = F'.e ≫ F'.m
Theorem: Class.iota_val
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rwa [← (H x').1 <| (h x').2 rfl]
state_before: A : Class
x : ZFSet
H : ∀ (y : ZFSet), A y ↔ y = x
y : ZFSet
x✝ : iota A y
x' : ZFSet
h : setOf (fun x => ∀ (y : ZFSet), A y ↔ y = x) x'
yx' : y ∈ ↑x'
⊢ ↑x y
Theorem: Subgroup.comap_normalizer_eq_of_surjective
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: intro x hx
state_before: G : Type u_1
G' : Type ?u.618855
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.618864
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ↑f
⊢ normalizer (comap f H) ≤ comap f (normalizer H)

tactic: simp only [mem_comap, mem_normalizer_iff] at *
state_before: G : Type u_1
G' : Type ?u.618855
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.618864
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ↑f
x : N
hx : x ∈ normalizer (comap f H)
⊢ x ∈ comap f (normalizer H)

tactic: intro n
state_before: G : Type u_1
G' : Type ?u.618855
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.618864
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ↑f
x : N
hx : ∀ (h : N), ↑f h ∈ H ↔ ↑f (x * h * x⁻¹) ∈ H
⊢ ∀ (h : G), h ∈ H ↔ ↑f x * h * (↑f x)⁻¹ ∈ H

tactic: rcases hf n with ⟨y, rfl⟩
state_before: G : Type u_1
G' : Type ?u.618855
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.618864
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ↑f
x : N
hx : ∀ (h : N), ↑f h ∈ H ↔ ↑f (x * h * x⁻¹) ∈ H
n : G
⊢ n ∈ H ↔ ↑f x * n * (↑f x)⁻¹ ∈ H

tactic: simp [hx y]
state_before: case intro
G : Type u_1
G' : Type ?u.618855
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.618864
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ↑f
x : N
hx : ∀ (h : N), ↑f h ∈ H ↔ ↑f (x * h * x⁻¹) ∈ H
y : N
⊢ ↑f y ∈ H ↔ ↑f x * ↑f y * (↑f x)⁻¹ ∈ H
Theorem: List.map_id
File: Std/Data/List/Init/Lemmas.lean

tactic: induction l <;> simp_all
state_before: α : Type u_1
l : List α
⊢ map id l = l
Theorem: Function.Surjective.nontrivial
File: Mathlib/Logic/Nontrivial.lean

tactic: rcases exists_pair_ne β with ⟨x, y, h⟩
state_before: α : Type u_2
β : Type u_1
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
⊢ Nontrivial α

tactic: rcases hf x with ⟨x', hx'⟩
state_before: case intro.intro
α : Type u_2
β : Type u_1
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
⊢ Nontrivial α

tactic: rcases hf y with ⟨y', hy'⟩
state_before: case intro.intro.intro
α : Type u_2
β : Type u_1
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
⊢ Nontrivial α

tactic: have : x' ≠ y' := by
  refine fun H ↦ h ?_
  rw [← hx', ← hy', H]
state_before: case intro.intro.intro.intro
α : Type u_2
β : Type u_1
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
y' : α
hy' : f y' = y
⊢ Nontrivial α

tactic: exact ⟨⟨x', y', this⟩⟩
state_before: case intro.intro.intro.intro
α : Type u_2
β : Type u_1
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
y' : α
hy' : f y' = y
this : x' ≠ y'
⊢ Nontrivial α

tactic: refine fun H ↦ h ?_
state_before: α : Type u_2
β : Type u_1
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
y' : α
hy' : f y' = y
⊢ x' ≠ y'

tactic: rw [← hx', ← hy', H]
state_before: α : Type u_2
β : Type u_1
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
y' : α
hy' : f y' = y
H : x' = y'
⊢ x = y
Theorem: MvPolynomial.eval₂Hom_monomial
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: simp only [monomial_eq, RingHom.map_mul, eval₂Hom_C, Finsupp.prod, map_prod,
  RingHom.map_pow, eval₂Hom_X']
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f✝ : R →+* S₁
g✝ : σ → S₁
f : R →+* S₁
g : σ → S₁
d : σ →₀ ℕ
r : R
⊢ ↑(eval₂Hom f g) (↑(monomial d) r) = ↑f r * Finsupp.prod d fun i k => g i ^ k
Theorem: ne₁₃_of_not_collinear
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rintro rfl
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.307822
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : ¬Collinear k {p₁, p₂, p₃}
⊢ p₁ ≠ p₃

tactic: simp [collinear_pair] at h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.307822
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
h : ¬Collinear k {p₁, p₂, p₁}
⊢ False
Theorem: Int.preimage_Ici
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type ?u.246015
α : Type u_1
β : Type ?u.246021
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ Int.cast ⁻¹' Ici a = Ici ⌈a⌉

tactic: simp [ceil_le]
state_before: case h
F : Type ?u.246015
α : Type u_1
β : Type ?u.246021
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ici a ↔ x✝ ∈ Ici ⌈a⌉
Theorem: Nat.psub'_eq_psub
File: Mathlib/Data/Nat/PSub.lean

tactic: rw [psub']
state_before: m n : ℕ
⊢ psub' m n = psub m n

tactic: split_ifs with h
state_before: m n : ℕ
⊢ (if n ≤ m then some (m - n) else none) = psub m n

tactic: exact (psub_eq_sub h).symm
state_before: case inl
m n : ℕ
h : n ≤ m
⊢ some (m - n) = psub m n

case inr
m n : ℕ
h : ¬n ≤ m
⊢ none = psub m n

tactic: exact (psub_eq_none.2 (not_le.1 h)).symm
state_before: case inr
m n : ℕ
h : ¬n ≤ m
⊢ none = psub m n
Theorem: CategoryTheory.mono_of_mono_fac
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: subst h
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : Mono h
w : f ≫ g = h
⊢ Mono f

tactic: exact mono_of_mono f g
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ Mono f
Theorem: Order.Ideal.IsPrime.mem_or_compl_mem
File: Mathlib/Order/PrimeIdeal.lean

tactic: apply hI.mem_or_mem
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsPrime I
⊢ x ∈ I ∨ xᶜ ∈ I

tactic: rw [inf_compl_eq_bot]
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsPrime I
⊢ x ⊓ xᶜ ∈ I

tactic: exact I.bot_mem
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsPrime I
⊢ ⊥ ∈ I
Theorem: CategoryTheory.Limits.equalizerSubobject_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [equalizerSubobjectIso]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f g : X ⟶ Y
inst✝ : HasEqualizer f g
⊢ (equalizerSubobjectIso f g).hom ≫ equalizer.ι f g = arrow (equalizerSubobject f g)
Theorem: PadicSeq.equiv_zero_of_val_eq_of_equiv_zero
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simpa [h] using hi _ hj
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)
hf : f ≈ 0
ε : ℚ
hε : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → padicNorm p (↑(f - 0) j) < ε
j : ℕ
hj : j ≥ i
⊢ padicNorm p (↑(g - 0) j) < ε
Theorem: Real.sInf_empty
File: Mathlib/Data/Real/Basic.lean

tactic: simp [sInf_def, sSup_empty]
state_before: x y : ℝ
⊢ sInf ∅ = 0
Theorem: RingHom.lift_injective_of_ker_le_ideal
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: rw [RingHom.injective_iff_ker_eq_bot, RingHom.ker_eq_bot_iff_eq_zero]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f✝ : R →+* S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hI : ker f ≤ I
⊢ Function.Injective ↑(Ideal.Quotient.lift I f H)

tactic: intro u hu
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f✝ : R →+* S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hI : ker f ≤ I
⊢ ∀ (x : R ⧸ I), ↑(Ideal.Quotient.lift I f H) x = 0 → x = 0

tactic: obtain ⟨v, rfl⟩ := Ideal.Quotient.mk_surjective u
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f✝ : R →+* S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hI : ker f ≤ I
u : R ⧸ I
hu : ↑(Ideal.Quotient.lift I f H) u = 0
⊢ u = 0

tactic: rw [Ideal.Quotient.lift_mk] at hu
state_before: case intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f✝ : R →+* S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hI : ker f ≤ I
v : R
hu : ↑(Ideal.Quotient.lift I f H) (↑(Ideal.Quotient.mk I) v) = 0
⊢ ↑(Ideal.Quotient.mk I) v = 0

tactic: rw [Ideal.Quotient.eq_zero_iff_mem]
state_before: case intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f✝ : R →+* S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hI : ker f ≤ I
v : R
hu : ↑f v = 0
⊢ ↑(Ideal.Quotient.mk I) v = 0

tactic: exact hI ((RingHom.mem_ker f).mpr hu)
state_before: case intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f✝ : R →+* S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hI : ker f ≤ I
v : R
hu : ↑f v = 0
⊢ v ∈ I
Theorem: Filter.HasBasis.filter_eq
File: Mathlib/Order/Filter/Bases.lean

tactic: ext U
state_before: α : Type u_1
β : Type ?u.14406
γ : Type ?u.14409
ι : Sort u_2
ι' : Sort ?u.14415
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : HasBasis l p s
⊢ IsBasis.filter (_ : IsBasis p s) = l

tactic: simp [h.mem_iff, IsBasis.mem_filter_iff]
state_before: case a
α : Type u_1
β : Type ?u.14406
γ : Type ?u.14409
ι : Sort u_2
ι' : Sort ?u.14415
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : HasBasis l p s
U : Set α
⊢ U ∈ IsBasis.filter (_ : IsBasis p s) ↔ U ∈ l
Theorem: MeasureTheory.Measure.isHaarMeasure_map
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: intro K hK
state_before: 𝕜 : Type ?u.592530
G : Type u_1
H✝ : Type ?u.592536
inst✝¹² : MeasurableSpace G
inst✝¹¹ : MeasurableSpace H✝
inst✝¹⁰ : Group G
inst✝⁹ : TopologicalSpace G
μ : Measure G
inst✝⁸ : IsHaarMeasure μ
inst✝⁷ : BorelSpace G
inst✝⁶ : TopologicalGroup G
H : Type u_2
inst✝⁵ : Group H
inst✝⁴ : TopologicalSpace H
inst✝³ : MeasurableSpace H
inst✝² : BorelSpace H
inst✝¹ : T2Space H
inst✝ : TopologicalGroup H
f : G →* H
hf : Continuous ↑f
h_surj : Surjective ↑f
h_prop : Tendsto (↑f) (cocompact G) (cocompact H)
⊢ ∀ ⦃K : Set H⦄, IsCompact K → ↑↑(map (↑f) μ) K < ⊤

tactic: rw [map_apply hf.measurable hK.measurableSet]
state_before: 𝕜 : Type ?u.592530
G : Type u_1
H✝ : Type ?u.592536
inst✝¹² : MeasurableSpace G
inst✝¹¹ : MeasurableSpace H✝
inst✝¹⁰ : Group G
inst✝⁹ : TopologicalSpace G
μ : Measure G
inst✝⁸ : IsHaarMeasure μ
inst✝⁷ : BorelSpace G
inst✝⁶ : TopologicalGroup G
H : Type u_2
inst✝⁵ : Group H
inst✝⁴ : TopologicalSpace H
inst✝³ : MeasurableSpace H
inst✝² : BorelSpace H
inst✝¹ : T2Space H
inst✝ : TopologicalGroup H
f : G →* H
hf : Continuous ↑f
h_surj : Surjective ↑f
h_prop : Tendsto (↑f) (cocompact G) (cocompact H)
K : Set H
hK : IsCompact K
⊢ ↑↑(map (↑f) μ) K < ⊤

tactic: exact IsCompact.measure_lt_top ((⟨⟨f, hf⟩, h_prop⟩ : CocompactMap G H).isCompact_preimage hK)
state_before: 𝕜 : Type ?u.592530
G : Type u_1
H✝ : Type ?u.592536
inst✝¹² : MeasurableSpace G
inst✝¹¹ : MeasurableSpace H✝
inst✝¹⁰ : Group G
inst✝⁹ : TopologicalSpace G
μ : Measure G
inst✝⁸ : IsHaarMeasure μ
inst✝⁷ : BorelSpace G
inst✝⁶ : TopologicalGroup G
H : Type u_2
inst✝⁵ : Group H
inst✝⁴ : TopologicalSpace H
inst✝³ : MeasurableSpace H
inst✝² : BorelSpace H
inst✝¹ : T2Space H
inst✝ : TopologicalGroup H
f : G →* H
hf : Continuous ↑f
h_surj : Surjective ↑f
h_prop : Tendsto (↑f) (cocompact G) (cocompact H)
K : Set H
hK : IsCompact K
⊢ ↑↑μ (↑f ⁻¹' K) < ⊤
Theorem: Primrec.option_iget
File: Mathlib/Computability/Primrec.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type ?u.115565
γ : Type ?u.115568
δ : Type ?u.115571
σ : Type ?u.115574
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
inst✝ : Inhabited α
o : Option α
⊢ (Option.casesOn (id o) default fun b => b) = Option.iget o
Theorem: PerfectClosure.mul_aux_right
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: rw [← iterate_succ_apply, iterate_succ_apply', iterate_succ_apply', ← frobenius_mul]
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y1 y2 : ℕ × K
H : R K p y1 y2
n : ℕ
y : K
⊢ R K p (x.fst + (n, y).fst, (↑(frobenius K p)^[(n, y).fst]) x.snd * (↑(frobenius K p)^[x.fst]) (n, y).snd)
    (x.fst + (n + 1, ↑(frobenius K p) y).fst,
      (↑(frobenius K p)^[(n + 1, ↑(frobenius K p) y).fst]) x.snd *
        (↑(frobenius K p)^[x.fst]) (n + 1, ↑(frobenius K p) y).snd)

tactic: apply R.intro
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y1 y2 : ℕ × K
H : R K p y1 y2
n : ℕ
y : K
⊢ R K p (x.fst + (n, y).fst, (↑(frobenius K p)^[(n, y).fst]) x.snd * (↑(frobenius K p)^[x.fst]) (n, y).snd)
    (x.fst + (n + 1, ↑(frobenius K p) y).fst,
      ↑(frobenius K p) ((↑(frobenius K p)^[n]) x.snd * (↑(frobenius K p)^[x.fst]) y))
Theorem: Finset.le_multiplicativeEnergy
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: rw [← card_product]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ card s * card t ≤ multiplicativeEnergy s t

tactic: refine'
  card_le_card_of_inj_on (@fun x => ((x.1, x.1), x.2, x.2)) (by
  simp only [ ← and_imp, mem_product, and_imp, Prod.forall, mem_filter,
      and_self, and_true, imp_self, implies_true]) fun a _ b _ => _
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ card (s ×ˢ t) ≤ multiplicativeEnergy s t

tactic: simp only [Prod.mk.inj_iff, and_self_iff, and_imp]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
a : α × α
x✝¹ : a ∈ s ×ˢ t
b : α × α
x✝ : b ∈ s ×ˢ t
⊢ (fun x => ((x.fst, x.fst), x.snd, x.snd)) a = (fun x => ((x.fst, x.fst), x.snd, x.snd)) b → a = b

tactic: exact Prod.ext
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
a : α × α
x✝¹ : a ∈ s ×ˢ t
b : α × α
x✝ : b ∈ s ×ˢ t
⊢ a.fst = b.fst → a.snd = b.snd → a = b

tactic: simp only [ ← and_imp, mem_product, and_imp, Prod.forall, mem_filter,
  and_self, and_true, imp_self, implies_true]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ ∀ (a : α × α),
    a ∈ s ×ˢ t →
      (fun x => ((x.fst, x.fst), x.snd, x.snd)) a ∈
        filter (fun x => x.fst.fst * x.snd.fst = x.fst.snd * x.snd.snd) ((s ×ˢ s) ×ˢ t ×ˢ t)
Theorem: UniqueFactorizationMonoid.normalize_normalized_factor
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [normalizedFactors, factors]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ ∀ (x : α), x ∈ normalizedFactors a → ↑normalize x = x

tactic: split_ifs with h
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ ∀ (x : α),
    x ∈
        Multiset.map (↑normalize)
          (if h : a = 0 then 0 else Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a)) →
      ↑normalize x = x

tactic: intro x hx
state_before: case inr
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
h : ¬a = 0
⊢ ∀ (x : α),
    x ∈
        Multiset.map (fun x => ↑normalize x)
          (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a)) →
      ↑normalize x = x

tactic: obtain ⟨y, _, rfl⟩ := Multiset.mem_map.1 hx
state_before: case inr
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
h : ¬a = 0
x : α
hx :
  x ∈
    Multiset.map (fun x => ↑normalize x)
      (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a))
⊢ ↑normalize x = x

tactic: apply normalize_idem
state_before: case inr.intro.intro
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
h : ¬a = 0
y : α
left✝ : y ∈ Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a)
hx :
  ↑normalize y ∈
    Multiset.map (fun x => ↑normalize x)
      (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a))
⊢ ↑normalize (↑normalize y) = ↑normalize y

tactic: simp
state_before: case inl
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
h : a = 0
⊢ ∀ (x : α), x ∈ Multiset.map (fun x => ↑normalize x) 0 → ↑normalize x = x
Theorem: PNat.gcd_eq_left_iff_dvd
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [dvd_iff]
state_before: m n : ℕ+
⊢ m ∣ n ↔ gcd m n = m

tactic: rw [Nat.gcd_eq_left_iff_dvd]
state_before: m n : ℕ+
⊢ ↑m ∣ ↑n ↔ gcd m n = m

tactic: rw [← coe_inj]
state_before: m n : ℕ+
⊢ Nat.gcd ↑m ↑n = ↑m ↔ gcd m n = m

tactic: simp
state_before: m n : ℕ+
⊢ Nat.gcd ↑m ↑n = ↑m ↔ ↑(gcd m n) = ↑m
Theorem: coord_norm'
File: Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean

tactic: rw [norm_smul (x := coord 𝕜 x h), IsROrC.norm_coe_norm, coord_norm,
  mul_inv_cancel (mt norm_eq_zero.mp h)]
state_before: 𝕜 : Type v
inst✝² : IsROrC 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
h : x ≠ 0
⊢ ‖↑‖x‖ • coord 𝕜 x h‖ = 1
Theorem: CommGroupCat.isZero_of_subsingleton
File: Mathlib/Algebra/Category/GroupCat/Zero.lean

tactic: refine' ⟨fun X => ⟨⟨⟨1⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨1⟩, fun f => _⟩⟩⟩
state_before: G : CommGroupCat
inst✝ : Subsingleton ↑G
⊢ IsZero G

tactic: ext x
state_before: case refine'_1
G : CommGroupCat
inst✝ : Subsingleton ↑G
X : CommGroupCat
f : G ⟶ X
⊢ f = default

tactic: have : x = 1 := Subsingleton.elim _ _
state_before: case refine'_1.w
G : CommGroupCat
inst✝ : Subsingleton ↑G
X : CommGroupCat
f : G ⟶ X
x : ↑G
⊢ ↑f x = ↑default x

tactic: rw [this, map_one, map_one]
state_before: case refine'_1.w
G : CommGroupCat
inst✝ : Subsingleton ↑G
X : CommGroupCat
f : G ⟶ X
x : ↑G
this : x = 1
⊢ ↑f x = ↑default x

tactic: ext
state_before: case refine'_2
G : CommGroupCat
inst✝ : Subsingleton ↑G
X : CommGroupCat
f : X ⟶ G
⊢ f = default

tactic: apply Subsingleton.elim
state_before: case refine'_2.w
G : CommGroupCat
inst✝ : Subsingleton ↑G
X : CommGroupCat
f : X ⟶ G
x✝ : ↑X
⊢ ↑f x✝ = ↑default x✝