tasksource/leandojo huggingface dataset:
Theorem: StarConvex.neg
File: Mathlib/Analysis/Convex/Star.lean

tactic: rw [← image_neg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.132147
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t : Set E
hs : StarConvex 𝕜 x s
⊢ StarConvex 𝕜 (-x) (-s)

tactic: exact hs.is_linear_image IsLinearMap.isLinearMap_neg
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.132147
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t : Set E
hs : StarConvex 𝕜 x s
⊢ StarConvex 𝕜 (-x) (Neg.neg '' s)
Theorem: FirstOrder.Language.BoundedFormula.realize_relabel
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [relabel, realize_mapTermRel_add_castLe] <;> intros <;> simp
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.96990
P : Type ?u.96993
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
φ : BoundedFormula L α n
g : α → β ⊕ Fin m
v : β → M
xs : Fin (m + n) → M
⊢ Realize (relabel g φ) v xs ↔ Realize φ (Sum.elim v (xs ∘ ↑(castAdd n)) ∘ g) (xs ∘ ↑(natAdd m))
Theorem: SemiconjBy.neg_left
File: Mathlib/Algebra/Ring/Semiconj.lean

tactic: simp only [SemiconjBy, h.eq, neg_mul, mul_neg]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Mul R
inst✝ : HasDistribNeg R
a x y : R
h : SemiconjBy a x y
⊢ SemiconjBy (-a) x y
Theorem: List.bind_ret_eq_map
File: Mathlib/Data/List/Basic.lean

tactic: unfold List.bind
state_before: ι : Type ?u.133759
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
⊢ List.bind l (List.ret ∘ f) = map f l

tactic: induction l <;> simp [map, join, List.ret, cons_append, nil_append, *] at *
state_before: ι : Type ?u.133759
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
⊢ join (map (List.ret ∘ f) l) = map f l

tactic: assumption
state_before: case cons
ι : Type ?u.133759
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
head✝ : α
tail✝ : List α
tail_ih✝ : join (map ((fun a => [a]) ∘ f) tail✝) = map f tail✝
⊢ join (map ((fun a => [a]) ∘ f) tail✝) = map f tail✝
Theorem: aemeasurable_inv_iff₀
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [inv_inv] using h.inv
state_before: G : Type ?u.2578903
α : Type u_2
inst✝⁵ : Inv G
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableInv G
m : MeasurableSpace α
f✝ : α → G
μ : MeasureTheory.Measure α
G₀ : Type u_1
inst✝² : GroupWithZero G₀
inst✝¹ : MeasurableSpace G₀
inst✝ : MeasurableInv G₀
f : α → G₀
h : AEMeasurable fun x => (f x)⁻¹
⊢ AEMeasurable f
Theorem: SeparationQuotient.map_mk_nhdsSet
File: Mathlib/Topology/Inseparable.lean

tactic: rw [← comap_mk_nhdsSet_image, map_comap_of_surjective surjective_mk]
state_before: X : Type u_1
Y : Type ?u.69573
Z : Type ?u.69576
α : Type ?u.69579
ι : Type ?u.69582
π : ι → Type ?u.69587
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
⊢ Filter.map mk (𝓝ˢ s) = 𝓝ˢ (mk '' s)
Theorem: Matrix.map_updateColumn
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1224395
m : Type u_2
n : Type u_1
o : Type ?u.1224404
m' : o → Type ?u.1224409
n' : o → Type ?u.1224414
R : Type ?u.1224417
S : Type ?u.1224420
α : Type v
β : Type w
γ : Type ?u.1224427
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
f : α → β
⊢ map (updateColumn M j c) f = updateColumn (map M f) j (f ∘ c)

tactic: rw [updateColumn_apply, map_apply, map_apply, updateColumn_apply]
state_before: case a.h
l : Type ?u.1224395
m : Type u_2
n : Type u_1
o : Type ?u.1224404
m' : o → Type ?u.1224409
n' : o → Type ?u.1224414
R : Type ?u.1224417
S : Type ?u.1224420
α : Type v
β : Type w
γ : Type ?u.1224427
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
f : α → β
i✝ : m
x✝ : n
⊢ map (updateColumn M j c) f i✝ x✝ = updateColumn (map M f) j (f ∘ c) i✝ x✝

tactic: exact apply_ite f _ _ _
state_before: case a.h
l : Type ?u.1224395
m : Type u_2
n : Type u_1
o : Type ?u.1224404
m' : o → Type ?u.1224409
n' : o → Type ?u.1224414
R : Type ?u.1224417
S : Type ?u.1224420
α : Type v
β : Type w
γ : Type ?u.1224427
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
f : α → β
i✝ : m
x✝ : n
⊢ f (if x✝ = j then c i✝ else M i✝ x✝) = if x✝ = j then (f ∘ c) i✝ else f (M i✝ x✝)
Theorem: Subalgebra.induction_on_adjoin
File: Mathlib/RingTheory/Adjoin/FG.lean

tactic: obtain ⟨t, rfl⟩ := S.fg_of_noetherian
state_before: R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : IsNoetherian R A
P : Subalgebra R A → Prop
base : P ⊥
ih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x ↑S))
S : Subalgebra R A
⊢ P S

tactic: refine' Finset.induction_on t _ _
state_before: case intro
R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : IsNoetherian R A
P : Subalgebra R A → Prop
base : P ⊥
ih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x ↑S))
t : Finset A
⊢ P (Algebra.adjoin R ↑t)

tactic: intro x t _ h
state_before: case intro.refine'_2
R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : IsNoetherian R A
P : Subalgebra R A → Prop
base : P ⊥
ih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x ↑S))
t : Finset A
⊢ ∀ ⦃a : A⦄ {s : Finset A}, ¬a ∈ s → P (Algebra.adjoin R ↑s) → P (Algebra.adjoin R ↑(insert a s))

tactic: rw [Finset.coe_insert]
state_before: case intro.refine'_2
R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : IsNoetherian R A
P : Subalgebra R A → Prop
base : P ⊥
ih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x ↑S))
t✝ : Finset A
x : A
t : Finset A
a✝ : ¬x ∈ t
h : P (Algebra.adjoin R ↑t)
⊢ P (Algebra.adjoin R ↑(insert x t))

tactic: simpa only [Algebra.adjoin_insert_adjoin] using ih _ x h
state_before: case intro.refine'_2
R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : IsNoetherian R A
P : Subalgebra R A → Prop
base : P ⊥
ih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x ↑S))
t✝ : Finset A
x : A
t : Finset A
a✝ : ¬x ∈ t
h : P (Algebra.adjoin R ↑t)
⊢ P (Algebra.adjoin R (insert x ↑t))

tactic: simpa using base
state_before: case intro.refine'_1
R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : IsNoetherian R A
P : Subalgebra R A → Prop
base : P ⊥
ih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x ↑S))
t : Finset A
⊢ P (Algebra.adjoin R ↑∅)
Theorem: thickenedIndicatorAux_closure_eq
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: simp_rw [thickenedIndicatorAux, infEdist_closure]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
⊢ thickenedIndicatorAux δ (closure E) = thickenedIndicatorAux δ E
Theorem: comap_uniformity_of_spaced_out
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: refine' le_antisymm _ (@refl_le_uniformity α (UniformSpace.comap f _))
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α✝
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
α : Type u_1
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => ¬(f x, f y) ∈ s
⊢ comap (Prod.map f f) (𝓤 β) = 𝓟 idRel

tactic: calc
  comap (Prod.map f f) (𝓤 β) ≤ comap (Prod.map f f) (𝓟 s) := comap_mono (le_principal_iff.2 hs)
  _ = 𝓟 (Prod.map f f ⁻¹' s) := comap_principal
  _ ≤ 𝓟 idRel := principal_mono.2 ?_
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α✝
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
α : Type u_1
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => ¬(f x, f y) ∈ s
⊢ comap (Prod.map f f) (𝓤 β) ≤ 𝓟 idRel

tactic: rintro ⟨x, y⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α✝
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
α : Type u_1
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => ¬(f x, f y) ∈ s
⊢ Prod.map f f ⁻¹' s ⊆ idRel

tactic: simpa [not_imp_not] using @hf x y
state_before: case mk
α✝ : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α✝
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
α : Type u_1
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => ¬(f x, f y) ∈ s
x y : α
⊢ (x, y) ∈ Prod.map f f ⁻¹' s → (x, y) ∈ idRel
Theorem: NonUnitalSubsemiring.mem_map
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: convert Set.mem_image_iff_bex
state_before: R : Type u
S : Type v
T : Type w
inst✝⁴ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝³ : NonUnitalNonAssocSemiring S
inst✝² : NonUnitalNonAssocSemiring T
F : Type u_1
G : Type ?u.101174
inst✝¹ : NonUnitalRingHomClass F R S
inst✝ : NonUnitalRingHomClass G S T
s✝ : NonUnitalSubsemiring R
f : F
s : NonUnitalSubsemiring R
y : S
⊢ y ∈ map f s ↔ ∃ x, x ∈ s ∧ ↑f x = y

tactic: simp
state_before: case h.e'_2.h.e'_2.h.a
R : Type u
S : Type v
T : Type w
inst✝⁴ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝³ : NonUnitalNonAssocSemiring S
inst✝² : NonUnitalNonAssocSemiring T
F : Type u_1
G : Type ?u.101174
inst✝¹ : NonUnitalRingHomClass F R S
inst✝ : NonUnitalRingHomClass G S T
s✝ : NonUnitalSubsemiring R
f : F
s : NonUnitalSubsemiring R
y : S
x✝ : R
⊢ x✝ ∈ s ∧ ↑f x✝ = y ↔ ∃ x, ↑f x✝ = y
Theorem: DMatrix.map_zero
File: Mathlib/Data/Matrix/DMatrix.lean

tactic: ext
state_before: l : Type ?u.18435
m : Type u_1
n : Type u_2
o : Type ?u.18444
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → Zero (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → Zero (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j
h : ∀ (i : m) (j : n), f 0 = 0
⊢ map 0 f = 0

tactic: simp [h]
state_before: case a
l : Type ?u.18435
m : Type u_1
n : Type u_2
o : Type ?u.18444
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → Zero (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → Zero (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j
h : ∀ (i : m) (j : n), f 0 = 0
i✝ : m
j✝ : n
⊢ map 0 f i✝ j✝ = OfNat.ofNat 0 i✝ j✝
Theorem: PGame.neg_ofLists
File: Mathlib/SetTheory/Game/PGame.lean

tactic: simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
  mk.injEq]
state_before: L R : List PGame
⊢ -ofLists L R = ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L)

tactic: constructor
state_before: L R : List PGame
⊢ (HEq (fun j => -List.nthLe R ↑j.down (_ : ↑j.down < List.length R)) fun i =>
      -List.nthLe R ↑i.down (_ : ↑i.down < List.length R)) ∧
    HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j =>
      -List.nthLe L ↑j.down (_ : ↑j.down < List.length L)

tactic: apply hfunext
state_before: case right
L R : List PGame
⊢ HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j =>
    -List.nthLe L ↑j.down (_ : ↑j.down < List.length L)

tactic: simp
state_before: case right.hα
L R : List PGame
⊢ ULift (Fin (List.length L)) = ULift (Fin (List.length (List.map (fun x => -x) L)))

tactic: intro a a' ha
state_before: case right.h
L R : List PGame
⊢ ∀ (a : ULift (Fin (List.length L))) (a' : ULift (Fin (List.length (List.map (fun x => -x) L)))),
    HEq a a' →
      HEq (-List.nthLe L ↑a.down (_ : ↑a.down < List.length L)) (-List.nthLe L ↑a'.down (_ : ↑a'.down < List.length L))

tactic: congr 2
state_before: case right.h
L R : List PGame
a : ULift (Fin (List.length L))
a' : ULift (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
⊢ HEq (-List.nthLe L ↑a.down (_ : ↑a.down < List.length L)) (-List.nthLe L ↑a'.down (_ : ↑a'.down < List.length L))

tactic: have :
  ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
    (b.down : ℕ) = ↑c.down := by
  rintro m n rfl b c
  simp only [heq_eq_eq]
  rintro rfl
  rfl
state_before: case right.h.h.e_a.e_n
L R : List PGame
a : ULift (Fin (List.length L))
a' : ULift (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
⊢ ↑a.down = ↑a'.down

tactic: exact this (List.length_map _ _).symm ha
state_before: case right.h.h.e_a.e_n
L R : List PGame
a : ULift (Fin (List.length L))
a' : ULift (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
this : ∀ {m n : ℕ}, m = n → ∀ {b : ULift (Fin m)} {c : ULift (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ ↑a.down = ↑a'.down

tactic: rintro m n rfl b c
state_before: L R : List PGame
a : ULift (Fin (List.length L))
a' : ULift (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
⊢ ∀ {m n : ℕ}, m = n → ∀ {b : ULift (Fin m)} {c : ULift (Fin n)}, HEq b c → ↑b.down = ↑c.down

tactic: simp only [heq_eq_eq]
state_before: L R : List PGame
a : ULift (Fin (List.length L))
a' : ULift (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
m : ℕ
b c : ULift (Fin m)
⊢ HEq b c → ↑b.down = ↑c.down

tactic: rintro rfl
state_before: L R : List PGame
a : ULift (Fin (List.length L))
a' : ULift (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
m : ℕ
b c : ULift (Fin m)
⊢ b = c → ↑b.down = ↑c.down

tactic: rfl
state_before: L R : List PGame
a : ULift (Fin (List.length L))
a' : ULift (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
m : ℕ
b : ULift (Fin m)
⊢ ↑b.down = ↑b.down
Theorem: List.sublists_cons_perm_append
File: Mathlib/Data/List/Sublists.lean

tactic: rw [sublists'_cons]
state_before: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ sublists' (a :: l) ~ sublists l ++ map (cons a) (sublists l)

tactic: exact Perm.append (sublists_perm_sublists' _).symm (Perm.map _ (sublists_perm_sublists' _).symm)
state_before: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ sublists' l ++ map (cons a) (sublists' l) ~ sublists l ++ map (cons a) (sublists l)
Theorem: eventually_abs_sub_lt
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [abs_sub_comm, mem_principal_self]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : OrderTopology α
l : Filter β
f g : β → α
a ε : α
hε : 0 < ε
⊢ {x | (fun x => abs (x - a) < ε) x} ∈ 𝓟 {b | abs (a - b) < ε}
Theorem: Rel.mul_edgeDensity_le_edgeDensity
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: have hst : (s₂.card : ℚ) * t₂.card ≠ 0 := by simp [hs₂.ne_empty, ht₂.ne_empty]
state_before: 𝕜 : Type ?u.28107
ι : Type ?u.28110
κ : Type ?u.28113
α : Type u_1
β : Type u_2
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₂ : Finset.Nonempty s₂
ht₂ : Finset.Nonempty t₂
⊢ ↑(card s₂) / ↑(card s₁) * (↑(card t₂) / ↑(card t₁)) * edgeDensity r s₂ t₂ ≤ edgeDensity r s₁ t₁

tactic: rw [edgeDensity, edgeDensity, div_mul_div_comm, mul_comm, div_mul_div_cancel _ hst]
state_before: 𝕜 : Type ?u.28107
ι : Type ?u.28110
κ : Type ?u.28113
α : Type u_1
β : Type u_2
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₂ : Finset.Nonempty s₂
ht₂ : Finset.Nonempty t₂
hst : ↑(card s₂) * ↑(card t₂) ≠ 0
⊢ ↑(card s₂) / ↑(card s₁) * (↑(card t₂) / ↑(card t₁)) * edgeDensity r s₂ t₂ ≤ edgeDensity r s₁ t₁

tactic: refine' div_le_div_of_le (by exact_mod_cast (s₁.card * t₁.card).zero_le) _
state_before: 𝕜 : Type ?u.28107
ι : Type ?u.28110
κ : Type ?u.28113
α : Type u_1
β : Type u_2
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₂ : Finset.Nonempty s₂
ht₂ : Finset.Nonempty t₂
hst : ↑(card s₂) * ↑(card t₂) ≠ 0
⊢ ↑(card (interedges r s₂ t₂)) / (↑(card s₁) * ↑(card t₁)) ≤ ↑(card (interedges r s₁ t₁)) / (↑(card s₁) * ↑(card t₁))

tactic: exact_mod_cast card_le_of_subset (interedges_mono hs ht)
state_before: 𝕜 : Type ?u.28107
ι : Type ?u.28110
κ : Type ?u.28113
α : Type u_1
β : Type u_2
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₂ : Finset.Nonempty s₂
ht₂ : Finset.Nonempty t₂
hst : ↑(card s₂) * ↑(card t₂) ≠ 0
⊢ ↑(card (interedges r s₂ t₂)) ≤ ↑(card (interedges r s₁ t₁))

tactic: simp [hs₂.ne_empty, ht₂.ne_empty]
state_before: 𝕜 : Type ?u.28107
ι : Type ?u.28110
κ : Type ?u.28113
α : Type u_1
β : Type u_2
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₂ : Finset.Nonempty s₂
ht₂ : Finset.Nonempty t₂
⊢ ↑(card s₂) * ↑(card t₂) ≠ 0

tactic: exact_mod_cast (s₁.card * t₁.card).zero_le
state_before: 𝕜 : Type ?u.28107
ι : Type ?u.28110
κ : Type ?u.28113
α : Type u_1
β : Type u_2
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₂ : Finset.Nonempty s₂
ht₂ : Finset.Nonempty t₂
hst : ↑(card s₂) * ↑(card t₂) ≠ 0
⊢ 0 ≤ ↑(card s₁) * ↑(card t₁)
Theorem: Submodule.annihilator_top_inter_nonZeroDivisors
File: Mathlib/Algebra/Module/Torsion.lean

tactic: obtain ⟨S, hS⟩ := ‹Module.Finite R M›.out
state_before: R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
⊢ ↑(annihilator ⊤) ∩ ↑R⁰ ≠ ∅

tactic: refine' Set.Nonempty.ne_empty ⟨_, _, (∏ x in S, (@hM x).choose : R⁰).prop⟩
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ↑(annihilator ⊤) ∩ ↑R⁰ ≠ ∅

tactic: rw [Submonoid.coe_finset_prod, SetLike.mem_coe, ← hS, mem_annihilator_span]
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ↑(∏ x in S, Exists.choose (_ : ∃ a, a • x = 0)) ∈ ↑(annihilator ⊤)

tactic: intro n
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ∀ (n : ↑↑S), (∏ i in S, ↑(Exists.choose (_ : ∃ a, a • i = 0))) • ↑n = 0

tactic: letI := Classical.decEq M
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
n : ↑↑S
⊢ (∏ i in S, ↑(Exists.choose (_ : ∃ a, a • i = 0))) • ↑n = 0

tactic: rw [← Finset.prod_erase_mul _ _ n.prop, mul_smul, ← Submonoid.smul_def, (@hM n).choose_spec,
  smul_zero]
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
n : ↑↑S
this : DecidableEq M := Classical.decEq M
⊢ (∏ i in S, ↑(Exists.choose (_ : ∃ a, a • i = 0))) • ↑n = 0
Theorem: ZMod.castHom_injective
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [injective_iff_map_eq_zero]
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
⊢ Injective ↑(castHom (_ : n ∣ n) R)

tactic: intro x
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
⊢ ∀ (a : ZMod n), ↑(castHom (_ : n ∣ n) R) a = 0 → a = 0

tactic: obtain ⟨k, rfl⟩ := ZMod.int_cast_surjective x
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
x : ZMod n
⊢ ↑(castHom (_ : n ∣ n) R) x = 0 → x = 0

tactic: rw [map_intCast, CharP.int_cast_eq_zero_iff R n, CharP.int_cast_eq_zero_iff (ZMod n) n]
state_before: case intro
n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
k : ℤ
⊢ ↑(castHom (_ : n ∣ n) R) ↑k = 0 → ↑k = 0

tactic: exact id
state_before: case intro
n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
k : ℤ
⊢ ↑n ∣ k → ↑n ∣ k
Theorem: Polynomial.natDegree_neg
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp [natDegree]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ natDegree (-p) = natDegree p
Theorem: UniformContinuousOn.tendstoUniformlyOn
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: set φ := fun q : α × β => ((x, q.2), q)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F✝ : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝¹ : UniformSpace α
inst✝ : UniformSpace γ
x : α
U : Set α
V : Set β
F : α → β → γ
hF : UniformContinuousOn (↿F) (U ×ˢ V)
hU : x ∈ U
⊢ TendstoUniformlyOn F (F x) (𝓝[U] x) V

tactic: rw [tendstoUniformlyOn_iff_tendsto]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F✝ : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝¹ : UniformSpace α
inst✝ : UniformSpace γ
x : α
U : Set α
V : Set β
F : α → β → γ
hF : UniformContinuousOn (↿F) (U ×ˢ V)
hU : x ∈ U
φ : α × β → (α × β) × α × β := fun q => ((x, q.snd), q)
⊢ TendstoUniformlyOn F (F x) (𝓝[U] x) V

tactic: change Tendsto (Prod.map (↿F) ↿F ∘ φ) (𝓝[U] x ×ˢ 𝓟 V) (𝓤 γ)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F✝ : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝¹ : UniformSpace α
inst✝ : UniformSpace γ
x : α
U : Set α
V : Set β
F : α → β → γ
hF : UniformContinuousOn (↿F) (U ×ˢ V)
hU : x ∈ U
φ : α × β → (α × β) × α × β := fun q => ((x, q.snd), q)
⊢ Tendsto (fun q => (F x q.snd, F q.fst q.snd)) (𝓝[U] x ×ˢ 𝓟 V) (𝓤 γ)

tactic: simp only [nhdsWithin, SProd.sprod, Filter.prod, comap_inf, inf_assoc, comap_principal,
  inf_principal]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F✝ : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝¹ : UniformSpace α
inst✝ : UniformSpace γ
x : α
U : Set α
V : Set β
F : α → β → γ
hF : UniformContinuousOn (↿F) (U ×ˢ V)
hU : x ∈ U
φ : α × β → (α × β) × α × β := fun q => ((x, q.snd), q)
⊢ Tendsto (Prod.map (↿F) ↿F ∘ φ) (𝓝[U] x ×ˢ 𝓟 V) (𝓤 γ)

tactic: refine hF.comp (Tendsto.inf ?_ <| tendsto_principal_principal.2 <| fun x hx => ⟨⟨hU, hx.2⟩, hx⟩)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F✝ : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝¹ : UniformSpace α
inst✝ : UniformSpace γ
x : α
U : Set α
V : Set β
F : α → β → γ
hF : UniformContinuousOn (↿F) (U ×ˢ V)
hU : x ∈ U
φ : α × β → (α × β) × α × β := fun q => ((x, q.snd), q)
⊢ Tendsto (Prod.map (↿F) ↿F ∘ fun q => ((x, q.snd), q)) (comap Prod.fst (𝓝 x) ⊓ 𝓟 (Prod.fst ⁻¹' U ∩ Prod.snd ⁻¹' V))
    (𝓤 γ)

tactic: exact tendsto_comap.prod_mk (tendsto_diag_uniformity _ _)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F✝ : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝¹ : UniformSpace α
inst✝ : UniformSpace γ
x : α
U : Set α
V : Set β
F : α → β → γ
hF : UniformContinuousOn (↿F) (U ×ˢ V)
hU : x ∈ U
φ : α × β → (α × β) × α × β := fun q => ((x, q.snd), q)
⊢ Tendsto (fun x_1 => ((x, x_1.fst), x_1.snd, x_1.snd)) (comap (fun x_1 => (x, x_1.fst)) (𝓤 α)) (𝓤 α ×ˢ 𝓤 β)
Theorem: Fin.preimage_insertNth_Icc_of_not_mem
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp only [mem_preimage, insertNth_mem_Icc, hx, false_and_iff, mem_empty_iff_false]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
q₁ q₂ : (j : Fin (n + 1)) → α j
hx : ¬x ∈ Icc (q₁ i) (q₂ i)
p : (j : Fin n) → α (↑(succAbove i) j)
⊢ p ∈ insertNth i x ⁻¹' Icc q₁ q₂ ↔ p ∈ ∅