tasksource/leandojo huggingface dataset:
Theorem: CompleteLattice.sSup_continuous'
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: lift s to Set (α →o β) using fun f hf => (hc f hf).to_monotone
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α → β)
hc : ∀ (f : α → β), f ∈ s → Continuous' f
⊢ Continuous' (sSup s)

tactic: simp only [Set.ball_image_iff, continuous'_coe] at hc
state_before: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ (f : α → β), f ∈ (fun x x_1 => x '' x_1) OrderHom.toFun s → Continuous' f
⊢ Continuous' (sSup ((fun x x_1 => x '' x_1) OrderHom.toFun s))

tactic: rw [sSup_image]
state_before: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ (x : α →o β), x ∈ s → Continuous x
⊢ Continuous' (sSup ((fun x x_1 => x '' x_1) OrderHom.toFun s))

tactic: norm_cast
state_before: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ (x : α →o β), x ∈ s → Continuous x
⊢ Continuous' (⨆ (a : α →o β) (_ : a ∈ s), ↑a)

tactic: exact iSup_continuous fun f => iSup_continuous fun hf => hc f hf
state_before: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ (x : α →o β), x ∈ s → Continuous x
⊢ Continuous (⨆ (i : α →o β) (_ : i ∈ s), i)
Theorem: padicValNat_dvd_iff
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
a : ℕ
⊢ p ^ n ∣ a ↔ a = 0 ∨ n ≤ padicValNat p a

tactic: exact iff_of_true (dvd_zero _) (Or.inl rfl)
state_before: case inl
p n : ℕ
hp : Fact (Nat.Prime p)
⊢ p ^ n ∣ 0 ↔ 0 = 0 ∨ n ≤ padicValNat p 0

tactic: rw [padicValNat_dvd_iff_le ha, or_iff_right ha]
state_before: case inr
p n : ℕ
hp : Fact (Nat.Prime p)
a : ℕ
ha : a ≠ 0
⊢ p ^ n ∣ a ↔ a = 0 ∨ n ≤ padicValNat p a
Theorem: Finset.upShadow_image_compl
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: ext s
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ image compl ((∂⁺ ) 𝒜) = (∂ ) (image compl 𝒜)

tactic: simp only [mem_image, exists_prop, mem_shadow_iff, mem_upShadow_iff]
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ s ∈ image compl ((∂⁺ ) 𝒜) ↔ s ∈ (∂ ) (image compl 𝒜)

tactic: constructor
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ a, (∃ t, t ∈ 𝒜 ∧ ∃ a_1, ¬a_1 ∈ t ∧ insert a_1 t = a) ∧ aᶜ = s) ↔
    ∃ t, (∃ a, a ∈ 𝒜 ∧ aᶜ = t) ∧ ∃ a, a ∈ t ∧ erase t a = s

tactic: rintro ⟨_, ⟨s, hs, a, ha, rfl⟩, rfl⟩
state_before: case a.mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ a, (∃ t, t ∈ 𝒜 ∧ ∃ a_1, ¬a_1 ∈ t ∧ insert a_1 t = a) ∧ aᶜ = s) →
    ∃ t, (∃ a, a ∈ 𝒜 ∧ aᶜ = t) ∧ ∃ a, a ∈ t ∧ erase t a = s

tactic: exact ⟨sᶜ, ⟨s, hs, rfl⟩, a, mem_compl.2 ha, compl_insert.symm⟩
state_before: case a.mp.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a✝ : α
k r : ℕ
s : Finset α
hs : s ∈ 𝒜
a : α
ha : ¬a ∈ s
⊢ ∃ t, (∃ a, a ∈ 𝒜 ∧ aᶜ = t) ∧ ∃ a_1, a_1 ∈ t ∧ erase t a_1 = insert a sᶜ

tactic: rintro ⟨_, ⟨s, hs, rfl⟩, a, ha, rfl⟩
state_before: case a.mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ t, (∃ a, a ∈ 𝒜 ∧ aᶜ = t) ∧ ∃ a, a ∈ t ∧ erase t a = s) →
    ∃ a, (∃ t, t ∈ 𝒜 ∧ ∃ a_1, ¬a_1 ∈ t ∧ insert a_1 t = a) ∧ aᶜ = s

tactic: exact ⟨insert a s, ⟨s, hs, a, mem_compl.1 ha, rfl⟩, compl_insert⟩
state_before: case a.mpr.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a✝ : α
k r : ℕ
s : Finset α
hs : s ∈ 𝒜
a : α
ha : a ∈ sᶜ
⊢ ∃ a_1, (∃ t, t ∈ 𝒜 ∧ ∃ a, ¬a ∈ t ∧ insert a t = a_1) ∧ a_1ᶜ = erase (sᶜ) a
Theorem: Multiset.map_add_right_Icc
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: simp_rw [add_comm _ c]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => x + c) (Icc a b) = Icc (a + c) (b + c)

tactic: exact map_add_left_Icc _ _ _
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Icc a b) = Icc (c + a) (c + b)
Theorem: MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group
File: Mathlib/GroupTheory/GroupAction/Quotient.lean

tactic: rw [← Fintype.card_prod, ← Fintype.card_sigma,
  Fintype.card_congr (sigmaFixedByEquivOrbitsProdGroup α β)]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁵ inst✝⁴ : Group α
inst✝³ : MulAction α β
x : β
inst✝² : Fintype α
inst✝¹ : (a : α) → Fintype ↑(fixedBy α β a)
inst✝ : Fintype (Quotient (orbitRel α β))
⊢ ∑ a : α, Fintype.card ↑(fixedBy α β a) = Fintype.card (Quotient (orbitRel α β)) * Fintype.card α
Theorem: CategoryTheory.Limits.pullbackAssoc_hom_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [← Iso.eq_inv_comp, pullbackAssoc_inv_fst_fst]
state_before: C : Type u
inst✝⁷ : Category C
D : Type u₂
inst✝⁶ : Category D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.fst = pullback.fst ≫ pullback.fst
Theorem: LinearPMap.le_closure
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

tactic: by_cases hf : f.IsClosable
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
⊢ f ≤ closure f

tactic: rw [closure_def' hf]
state_before: case neg
R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : ¬IsClosable f
⊢ f ≤ closure f

tactic: refine' le_of_le_graph _
state_before: case pos
R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : IsClosable f
⊢ f ≤ closure f

tactic: rw [← hf.graph_closure_eq_closure_graph]
state_before: case pos
R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : IsClosable f
⊢ graph f ≤ graph (closure f)

tactic: exact (graph f).le_topologicalClosure
state_before: case pos
R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : IsClosable f
⊢ graph f ≤ Submodule.topologicalClosure (graph f)
Theorem: ENNReal.inv_le_one
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [inv_le_iff_inv_le, inv_one]
state_before: α : Type ?u.270131
β : Type ?u.270134
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a⁻¹ ≤ 1 ↔ 1 ≤ a
Theorem: Nat.isCoprime_iff_coprime
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: rw [Int.isCoprime_iff_gcd_eq_one, Int.coe_nat_gcd]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
⊢ IsCoprime ↑m ↑n ↔ coprime m n
Theorem: deriv_div_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simp only [div_eq_mul_inv, deriv_mul_const_field]
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d✝ : 𝕜 → 𝕜'
c' d' d : 𝕜'
⊢ deriv (fun x => c x / d) x = deriv c x / d
Theorem: CategoryTheory.Abelian.pseudoEqual_refl
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: simp
state_before: C : Type u
inst✝ : Category C
P : C
f : Over P
⊢ 𝟙 f.left ≫ f.hom = 𝟙 f.left ≫ f.hom
Theorem: Tuple.eq_sort_iff
File: Mathlib/Data/Fin/Tuple/Sort.lean

tactic: rw [eq_sort_iff']
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
⊢ σ = sort f ↔ Monotone (f ∘ ↑σ) ∧ ∀ (i j : Fin n), i < j → f (↑σ i) = f (↑σ j) → ↑σ i < ↑σ j

tactic: refine' ⟨fun h => ⟨(monotone_proj f).comp h.monotone, fun i j hij hfij => _⟩, fun h i j hij => _⟩
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
⊢ StrictMono ↑(σ.trans (graphEquiv₁ f)) ↔ Monotone (f ∘ ↑σ) ∧ ∀ (i j : Fin n), i < j → f (↑σ i) = f (↑σ j) → ↑σ i < ↑σ j

tactic: exact (((Prod.Lex.lt_iff _ _).1 <| h hij).resolve_left hfij.not_lt).2
state_before: case refine'_1
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : StrictMono ↑(σ.trans (graphEquiv₁ f))
i j : Fin n
hij : i < j
hfij : f (↑σ i) = f (↑σ j)
⊢ ↑σ i < ↑σ j

tactic: obtain he | hl := (h.1 hij.le).eq_or_lt <;> apply (Prod.Lex.lt_iff _ _).2
state_before: case refine'_2
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : Monotone (f ∘ ↑σ) ∧ ∀ (i j : Fin n), i < j → f (↑σ i) = f (↑σ j) → ↑σ i < ↑σ j
i j : Fin n
hij : i < j
⊢ ↑(σ.trans (graphEquiv₁ f)) i < ↑(σ.trans (graphEquiv₁ f)) j

tactic: exacts [Or.inr ⟨he, h.2 i j hij he⟩, Or.inl hl]
state_before: case refine'_2.inl
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : Monotone (f ∘ ↑σ) ∧ ∀ (i j : Fin n), i < j → f (↑σ i) = f (↑σ j) → ↑σ i < ↑σ j
i j : Fin n
hij : i < j
he : (f ∘ ↑σ) i = (f ∘ ↑σ) j
⊢ (f (↑σ i), ↑σ i).fst < (f (↑σ j), ↑σ j).fst ∨
    (f (↑σ i), ↑σ i).fst = (f (↑σ j), ↑σ j).fst ∧ (f (↑σ i), ↑σ i).snd < (f (↑σ j), ↑σ j).snd

case refine'_2.inr
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : Monotone (f ∘ ↑σ) ∧ ∀ (i j : Fin n), i < j → f (↑σ i) = f (↑σ j) → ↑σ i < ↑σ j
i j : Fin n
hij : i < j
hl : (f ∘ ↑σ) i < (f ∘ ↑σ) j
⊢ (f (↑σ i), ↑σ i).fst < (f (↑σ j), ↑σ j).fst ∨
    (f (↑σ i), ↑σ i).fst = (f (↑σ j), ↑σ j).fst ∧ (f (↑σ i), ↑σ i).snd < (f (↑σ j), ↑σ j).snd
Theorem: FirstOrder.Language.Hom.range_eq_top
File: Mathlib/ModelTheory/Substructures.lean

tactic: rw [SetLike.ext'_iff, range_coe, coe_top, Set.range_iff_surjective]
state_before: L : Language
M : Type w
N : Type u_1
P : Type ?u.972917
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
f : M →[L] N
⊢ range f = ⊤ ↔ Function.Surjective ↑f
Theorem: mul_left_eq_self₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [one_mul]
state_before: α : Type ?u.10218
M₀ : Type u_1
G₀ : Type ?u.10224
M₀' : Type ?u.10227
G₀' : Type ?u.10230
F : Type ?u.10233
F' : Type ?u.10236
inst✝ : CancelMonoidWithZero M₀
a b c : M₀
⊢ a * b = b ↔ a * b = 1 * b
Theorem: CategoryTheory.MorphismProperty.StableUnderComposition.inverseImage
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: simpa only [← F.map_comp] using h (F.map f) (F.map g) hf hg
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : StableUnderComposition P
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : MorphismProperty.inverseImage P F f
hg : MorphismProperty.inverseImage P F g
⊢ MorphismProperty.inverseImage P F (f ≫ g)
Theorem: Int.units_inv_eq_self
File: Mathlib/Data/Int/Order/Units.lean

tactic: rw [inv_eq_iff_mul_eq_one, units_mul_self]
state_before: u : ℤˣ
⊢ u⁻¹ = u
Theorem: AlgebraicTopology.DoldKan.Q_idem
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

tactic: ext n
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ Q q ≫ Q q = Q q

tactic: exact Q_f_idem q n
state_before: case h
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ HomologicalComplex.Hom.f (Q q ≫ Q q) n = HomologicalComplex.Hom.f (Q q) n
Theorem: Ordnode.Valid'.eraseMin_aux
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: have := H.dual.eraseMax_aux
state_before: α : Type u_1
inst✝ : Preorder α
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
H : Valid' o₁ (Ordnode.node s l x r) o₂
⊢ Valid' (↑(findMin' l x)) (eraseMin (Ordnode.node' l x r)) o₂ ∧
    size (Ordnode.node' l x r) = size (eraseMin (Ordnode.node' l x r)) + 1

tactic: rwa [← dual_node', size_dual, ← dual_eraseMin, size_dual, ← Valid'.dual_iff, findMax'_dual]
  at this
state_before: α : Type u_1
inst✝ : Preorder α
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
H : Valid' o₁ (Ordnode.node s l x r) o₂
this :
  Valid' o₂ (eraseMax (Ordnode.node' (Ordnode.dual r) x (Ordnode.dual l))) ↑(findMax' x (Ordnode.dual l)) ∧
    size (Ordnode.node' (Ordnode.dual r) x (Ordnode.dual l)) =
      size (eraseMax (Ordnode.node' (Ordnode.dual r) x (Ordnode.dual l))) + 1
⊢ Valid' (↑(findMin' l x)) (eraseMin (Ordnode.node' l x r)) o₂ ∧
    size (Ordnode.node' l x r) = size (eraseMin (Ordnode.node' l x r)) + 1
Theorem: Multiset.mem_Icc
File: Mathlib/Order/LocallyFinite.lean

tactic: rw [Icc, ← Finset.mem_def, Finset.mem_Icc]
state_before: α : Type u_1
β : Type ?u.32105
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b x : α
⊢ x ∈ Icc a b ↔ a ≤ x ∧ x ≤ b
Theorem: MeasureTheory.ProbabilityMeasure.apply_mono
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [← coeFn_comp_toFiniteMeasure_eq_coeFn]
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
s₁ s₂ : Set Ω
h : s₁ ⊆ s₂
⊢ (fun s => ENNReal.toNNReal (↑↑↑μ s)) s₁ ≤ (fun s => ENNReal.toNNReal (↑↑↑μ s)) s₂

tactic: exact MeasureTheory.FiniteMeasure.apply_mono _ h
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
s₁ s₂ : Set Ω
h : s₁ ⊆ s₂
⊢ (fun s => ENNReal.toNNReal (↑↑↑(toFiniteMeasure μ) s)) s₁ ≤ (fun s => ENNReal.toNNReal (↑↑↑(toFiniteMeasure μ) s)) s₂
Theorem: MonoidHom.map_cyclic
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: obtain ⟨h, hG⟩ := IsCyclic.exists_generator (α := G)
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h : IsCyclic G
σ : G →* G
⊢ ∃ m, ∀ (g : G), ↑σ g = g ^ m

tactic: obtain ⟨m, hm⟩ := hG (σ h)
state_before: case intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
⊢ ∃ m, ∀ (g : G), ↑σ g = g ^ m

tactic: refine' ⟨m, fun g => _⟩
state_before: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x x_1 => x ^ x_1) h m = ↑σ h
⊢ ∃ m, ∀ (g : G), ↑σ g = g ^ m

tactic: obtain ⟨n, rfl⟩ := hG g
state_before: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x x_1 => x ^ x_1) h m = ↑σ h
g : G
⊢ ↑σ g = g ^ m

tactic: rw [MonoidHom.map_zpow, ← hm, ← zpow_mul, ← zpow_mul']
state_before: case intro.intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x x_1 => x ^ x_1) h m = ↑σ h
n : ℤ
⊢ ↑σ ((fun x x_1 => x ^ x_1) h n) = (fun x x_1 => x ^ x_1) h n ^ m
Theorem: FirstOrder.Language.Theory.exists_model_card_eq
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: cases h with
| intro M MI =>
  haveI := MI
  obtain ⟨N, hN, rfl⟩ := exists_elementarilyEquivalent_card_eq L M κ h1 h2
  haveI : Nonempty N := hN.nonempty
  exact ⟨hN.theory_model.bundled, rfl⟩
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
h : ∃ M, Infinite ↑M
κ : Cardinal
h1 : ℵ₀ ≤ κ
h2 : lift (card L) ≤ lift κ
⊢ ∃ N, (#↑N) = κ

tactic: haveI := MI
state_before: case intro
L : Language
T : Theory L
α : Type w
n : ℕ
κ : Cardinal
h1 : ℵ₀ ≤ κ
h2 : lift (card L) ≤ lift κ
M : ModelType T
MI : Infinite ↑M
⊢ ∃ N, (#↑N) = κ

tactic: obtain ⟨N, hN, rfl⟩ := exists_elementarilyEquivalent_card_eq L M κ h1 h2
state_before: case intro
L : Language
T : Theory L
α : Type w
n : ℕ
κ : Cardinal
h1 : ℵ₀ ≤ κ
h2 : lift (card L) ≤ lift κ
M : ModelType T
MI this : Infinite ↑M
⊢ ∃ N, (#↑N) = κ

tactic: haveI : Nonempty N := hN.nonempty
state_before: case intro.intro.intro
L : Language
T : Theory L
α : Type w
n : ℕ
M : ModelType T
MI this : Infinite ↑M
N : Bundled (Structure L)
hN : ↑M ≅[L] ↑N
h1 : ℵ₀ ≤ (#↑N)
h2 : lift (card L) ≤ lift (#↑N)
⊢ ∃ N_1, (#↑N_1) = (#↑N)

tactic: exact ⟨hN.theory_model.bundled, rfl⟩
state_before: case intro.intro.intro
L : Language
T : Theory L
α : Type w
n : ℕ
M : ModelType T
MI this✝ : Infinite ↑M
N : Bundled (Structure L)
hN : ↑M ≅[L] ↑N
h1 : ℵ₀ ≤ (#↑N)
h2 : lift (card L) ≤ lift (#↑N)
this : Nonempty ↑N
⊢ ∃ N_1, (#↑N_1) = (#↑N)
Theorem: LocalizedModule.mk_cancel_common_left
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: simp only [mul_smul, one_smul]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s' s : { x // x ∈ S }
m : M
⊢ 1 • s • s' • m = 1 • (s' * s) • m

tactic: rw [smul_comm]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s' s : { x // x ∈ S }
m : M
⊢ s • s' • m = s' • s • m
Theorem: midpoint_eq_left_iff
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint_eq_iff, pointReflection_self]
state_before: R : Type u_2
V : Type u_3
V' : Type ?u.91272
P : Type u_1
P' : Type ?u.91278
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ midpoint R x y = x ↔ x = y
Theorem: LinearMap.injective_of_iterate_injective
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [← Nat.succ_pred_eq_of_pos (pos_iff_ne_zero.mpr hn), iterate_succ, coe_comp] at h
state_before: R : Type u_2
R₁ : Type ?u.217519
R₂ : Type ?u.217522
R₃ : Type ?u.217525
R₄ : Type ?u.217528
S : Type ?u.217531
K : Type ?u.217534
K₂ : Type ?u.217537
M : Type u_1
M' : Type ?u.217543
M₁ : Type ?u.217546
M₂ : Type ?u.217549
M₃ : Type ?u.217552
M₄ : Type ?u.217555
N : Type ?u.217558
N₂ : Type ?u.217561
ι : Type ?u.217564
V : Type ?u.217567
V₂ : Type ?u.217570
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
n : ℕ
hn : n ≠ 0
h : Injective ↑(f' ^ n)
⊢ Injective ↑f'

tactic: exact h.of_comp
state_before: R : Type u_2
R₁ : Type ?u.217519
R₂ : Type ?u.217522
R₃ : Type ?u.217525
R₄ : Type ?u.217528
S : Type ?u.217531
K : Type ?u.217534
K₂ : Type ?u.217537
M : Type u_1
M' : Type ?u.217543
M₁ : Type ?u.217546
M₂ : Type ?u.217549
M₃ : Type ?u.217552
M₄ : Type ?u.217555
N : Type ?u.217558
N₂ : Type ?u.217561
ι : Type ?u.217564
V : Type ?u.217567
V₂ : Type ?u.217570
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
n : ℕ
hn : n ≠ 0
h : Injective (↑(f' ^ Nat.pred n) ∘ ↑f')
⊢ Injective ↑f'
Theorem: Int.subNatNat_add_right
File: Std/Data/Int/Lemmas.lean

tactic: simp [subNatNat, Nat.add_assoc, Nat.add_sub_cancel_left]
state_before: m n : Nat
⊢ subNatNat m (m + n + 1) = -[n+1]
Theorem: Path.map_coe
File: Mathlib/Topology/PathConnected.lean

tactic: ext t
state_before: X : Type u_1
Y✝ : Type ?u.299257
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y✝
x y z : X
ι : Type ?u.299272
γ✝ γ : Path x y
Y : Type u_2
inst✝ : TopologicalSpace Y
f : X → Y
h : Continuous f
⊢ ↑(map γ h) = f ∘ ↑γ

tactic: rfl
state_before: case h
X : Type u_1
Y✝ : Type ?u.299257
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y✝
x y z : X
ι : Type ?u.299272
γ✝ γ : Path x y
Y : Type u_2
inst✝ : TopologicalSpace Y
f : X → Y
h : Continuous f
t : ↑I
⊢ ↑(map γ h) t = (f ∘ ↑γ) t
Theorem: Filter.mem_closure
File: Mathlib/Topology/Filter.lean

tactic: simp only [closure_eq_compl_interior_compl, Filter.mem_interior, mem_compl_iff, not_exists,
  not_forall, Classical.not_not, exists_prop, not_and, and_comm, subset_def, mem_Iic,
  le_principal_iff]
state_before: ι : Sort ?u.15925
α : Type u_1
β : Type ?u.15931
X : Type ?u.15934
Y : Type ?u.15937
s : Set (Filter α)
l : Filter α
⊢ l ∈ closure s ↔ ∀ (t : Set α), t ∈ l → ∃ l', l' ∈ s ∧ t ∈ l'
Theorem: Sym2.other_eq_other'
File: Mathlib/Data/Sym/Sym2.lean

tactic: rw [← congr_right, other_spec' h, other_spec]
state_before: α : Type u_1
β : Type ?u.105253
γ : Type ?u.105256
inst✝ : DecidableEq α
a : α
z : Sym2 α
h : a ∈ z
⊢ Mem.other h = Mem.other' h