tasksource/leandojo huggingface dataset:
Theorem: GaloisInsertion.isCoatom_iff
File: Mathlib/Order/Atoms.lean

tactic: refine' ⟨fun hb => gi.isCoatom_of_image hb, fun hb => _⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
⊢ IsCoatom (u b) ↔ IsCoatom b

tactic: obtain ⟨a, ha, hab⟩ :=
  (eq_top_or_exists_le_coatom (u b)).resolve_left fun h =>
    hb.1 <| (gi.gc.u_top ▸ gi.l_u_eq ⊤ : l ⊤ = ⊤) ▸ gi.l_u_eq b ▸ congr_arg l h
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
⊢ IsCoatom (u b)

tactic: have : l a = b :=
  (hb.le_iff.mp (gi.l_u_eq b ▸ gi.gc.monotone_l hab : b ≤ l a)).resolve_left fun hla =>
    ha.1 (gi.gc.u_top ▸ h_coatom a ha ▸ congr_arg u hla)
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
a : α
ha : IsCoatom a
hab : u b ≤ a
⊢ IsCoatom (u b)

tactic: exact this ▸ (h_coatom a ha).symm ▸ ha
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
a : α
ha : IsCoatom a
hab : u b ≤ a
this : l a = b
⊢ IsCoatom (u b)
Theorem: CategoryTheory.Bicategory.leftUnitor_naturality
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ 𝟙 a ◁ η ≫ (λ_ g).hom = (λ_ f).hom ≫ η
Theorem: Polynomial.natTrailingDegree_neg
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: simp [natTrailingDegree]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ natTrailingDegree (-p) = natTrailingDegree p
Theorem: Subgroup.index_comap
File: Mathlib/GroupTheory/Index.lean

tactic: rfl
state_before: G : Type u_2
inst✝¹ : Group G
H K L : Subgroup G
G' : Type u_1
inst✝ : Group G'
f : G' →* G
⊢ comap f H = comap (MonoidHom.rangeRestrict f) (subgroupOf H (MonoidHom.range f))
Theorem: CategoryTheory.Iso.op_unop
File: Mathlib/CategoryTheory/Opposites.lean

tactic: (ext; rfl)
state_before: C : Type u₁
inst✝ : Category C
X✝ Y✝ X Y : C
f : X ≅ Y
⊢ unop (Iso.op f) = f

tactic: ext
state_before: C : Type u₁
inst✝ : Category C
X✝ Y✝ X Y : C
f : X ≅ Y
⊢ unop (Iso.op f) = f

tactic: rfl
state_before: case w
C : Type u₁
inst✝ : Category C
X✝ Y✝ X Y : C
f : X ≅ Y
⊢ (unop (Iso.op f)).hom = f.hom
Theorem: Nat.gcd_fib_add_self
File: Mathlib/Data/Nat/Fib.lean

tactic: cases' Nat.eq_zero_or_pos n with h h
state_before: m n : ℕ
⊢ gcd (fib m) (fib (n + m)) = gcd (fib m) (fib n)

tactic: replace h := Nat.succ_pred_eq_of_pos h
state_before: case inr
m n : ℕ
h : n > 0
⊢ gcd (fib m) (fib (n + m)) = gcd (fib m) (fib n)

tactic: rw [← h, succ_eq_add_one]
state_before: case inr
m n : ℕ
h : succ (pred n) = n
⊢ gcd (fib m) (fib (n + m)) = gcd (fib m) (fib n)

tactic: calc
  gcd (fib m) (fib (n.pred + 1 + m)) =
      gcd (fib m) (fib n.pred * fib m + fib (n.pred + 1) * fib (m + 1)) := by
      rw [← fib_add n.pred _]
      ring_nf
  _ = gcd (fib m) (fib (n.pred + 1) * fib (m + 1)) := by
      rw [add_comm, gcd_add_mul_right_right (fib m) _ (fib n.pred)]
  _ = gcd (fib m) (fib (n.pred + 1)) :=
    coprime.gcd_mul_right_cancel_right (fib (n.pred + 1)) (coprime.symm (fib_coprime_fib_succ m))
state_before: case inr
m n : ℕ
h : succ (pred n) = n
⊢ gcd (fib m) (fib (pred n + 1 + m)) = gcd (fib m) (fib (pred n + 1))

tactic: rw [h]
state_before: case inl
m n : ℕ
h : n = 0
⊢ gcd (fib m) (fib (n + m)) = gcd (fib m) (fib n)

tactic: simp
state_before: case inl
m n : ℕ
h : n = 0
⊢ gcd (fib m) (fib (0 + m)) = gcd (fib m) (fib 0)

tactic: rw [← fib_add n.pred _]
state_before: m n : ℕ
h : succ (pred n) = n
⊢ gcd (fib m) (fib (pred n + 1 + m)) = gcd (fib m) (fib (pred n) * fib m + fib (pred n + 1) * fib (m + 1))

tactic: ring_nf
state_before: m n : ℕ
h : succ (pred n) = n
⊢ gcd (fib m) (fib (pred n + 1 + m)) = gcd (fib m) (fib (pred n + m + 1))

tactic: rw [add_comm, gcd_add_mul_right_right (fib m) _ (fib n.pred)]
state_before: m n : ℕ
h : succ (pred n) = n
⊢ gcd (fib m) (fib (pred n) * fib m + fib (pred n + 1) * fib (m + 1)) = gcd (fib m) (fib (pred n + 1) * fib (m + 1))
Theorem: Nat.measurable_ceil
File: Mathlib/MeasureTheory/Function/Floor.lean

tactic: cases' eq_or_ne ⌈n⌉₊ 0 with h h <;> simp_all [h, Nat.preimage_ceil_of_ne_zero]
state_before: α : Type ?u.11637
R : Type u_1
inst✝⁶ : MeasurableSpace α
inst✝⁵ : LinearOrderedSemiring R
inst✝⁴ : FloorSemiring R
inst✝³ : TopologicalSpace R
inst✝² : OrderTopology R
inst✝¹ : MeasurableSpace R
inst✝ : OpensMeasurableSpace R
f : α → R
n : R
⊢ MeasurableSet (ceil ⁻¹' {⌈n⌉₊})
Theorem: TopCat.Sheaf.interUnionPullbackConeLift_left
File: Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean

tactic: erw [Category.assoc]
state_before: C : Type u
inst✝ : Category C
X : TopCat
F : Sheaf C X
U V : Opens ↑X
s : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
⊢ interUnionPullbackConeLift F U V s ≫ F.val.map (homOfLE (_ : U ≤ U ⊔ V)).op = PullbackCone.fst s

tactic: simp_rw [← F.1.map_comp]
state_before: C : Type u
inst✝ : Category C
X : TopCat
F : Sheaf C X
U V : Opens ↑X
s : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
⊢ IsLimit.lift
        (Nonempty.some
          (_ :
            Nonempty
              (IsLimit ((presheaf F).mapCone (Cocone.op (Pairwise.cocone fun j => WalkingPair.casesOn j.down U V))))))
        { pt := s.pt,
          π :=
            NatTrans.mk fun X_1 =>
              Opposite.casesOn X_1 fun unop =>
                Pairwise.casesOn unop
                  (fun a =>
                    ULift.casesOn a fun down => WalkingPair.casesOn down (PullbackCone.fst s) (PullbackCone.snd s))
                  fun a a_1 =>
                  ULift.casesOn a fun down =>
                    WalkingPair.casesOn down
                      (PullbackCone.fst s ≫
                        F.val.map (homOfLE (_ : U ⊓ (fun j => WalkingPair.casesOn j.down U V) a_1 ≤ U)).op)
                      (PullbackCone.snd s ≫
                        F.val.map (homOfLE (_ : V ⊓ (fun j => WalkingPair.casesOn j.down U V) a_1 ≤ V)).op) } ≫
      F.val.map (eqToHom (_ : U ⊔ V = ⨆ (j : ULift WalkingPair), WalkingPair.casesOn j.down U V)).op ≫
        F.val.map (homOfLE (_ : U ≤ U ⊔ V)).op =
    PullbackCone.fst s

tactic: exact
  (F.presheaf.isSheaf_iff_isSheafPairwiseIntersections.mp F.2 _).some.fac _ <|
    op <| Pairwise.single <| ULift.up WalkingPair.left
state_before: C : Type u
inst✝ : Category C
X : TopCat
F : Sheaf C X
U V : Opens ↑X
s : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
⊢ IsLimit.lift
        (Nonempty.some
          (_ :
            Nonempty
              (IsLimit ((presheaf F).mapCone (Cocone.op (Pairwise.cocone fun j => WalkingPair.casesOn j.down U V))))))
        { pt := s.pt,
          π :=
            NatTrans.mk fun X_1 =>
              Pairwise.rec (fun a => WalkingPair.rec (PullbackCone.fst s) (PullbackCone.snd s) a.down)
                (fun a a_1 =>
                  WalkingPair.rec
                    (PullbackCone.fst s ≫ F.val.map (homOfLE (_ : U ⊓ WalkingPair.rec U V a_1.down ≤ U)).op)
                    (PullbackCone.snd s ≫ F.val.map (homOfLE (_ : V ⊓ WalkingPair.rec U V a_1.down ≤ V)).op) a.down)
                X_1.unop } ≫
      F.val.map
        ((eqToHom (_ : U ⊔ V = ⨆ (j : ULift WalkingPair), WalkingPair.casesOn j.down U V)).op ≫
          (homOfLE (_ : U ≤ U ⊔ V)).op) =
    PullbackCone.fst s
Theorem: MonoidHom.pi_ext
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: cases nonempty_fintype ι
state_before: F : Type ?u.241399
ι : Type u_1
α : Type ?u.241405
β : Type ?u.241408
γ : Type u_3
f✝ : α → β → β
op : α → α → α
inst✝⁴ : Monoid β
inst✝³ : Monoid γ
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), ↑f (Pi.mulSingle i x) = ↑g (Pi.mulSingle i x)
⊢ f = g

tactic: ext x
state_before: case intro
F : Type ?u.241399
ι : Type u_1
α : Type ?u.241405
β : Type ?u.241408
γ : Type u_3
f✝ : α → β → β
op : α → α → α
inst✝⁴ : Monoid β
inst✝³ : Monoid γ
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), ↑f (Pi.mulSingle i x) = ↑g (Pi.mulSingle i x)
val✝ : Fintype ι
⊢ f = g

tactic: rw [← noncommProd_mul_single x, univ.noncommProd_map, univ.noncommProd_map]
state_before: case intro.h
F : Type ?u.241399
ι : Type u_1
α : Type ?u.241405
β : Type ?u.241408
γ : Type u_3
f✝ : α → β → β
op : α → α → α
inst✝⁴ : Monoid β
inst✝³ : Monoid γ
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), ↑f (Pi.mulSingle i x) = ↑g (Pi.mulSingle i x)
val✝ : Fintype ι
x : (i : ι) → M i
⊢ ↑f x = ↑g x

tactic: congr 1 with i
state_before: case intro.h
F : Type ?u.241399
ι : Type u_1
α : Type ?u.241405
β : Type ?u.241408
γ : Type u_3
f✝ : α → β → β
op : α → α → α
inst✝⁴ : Monoid β
inst✝³ : Monoid γ
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), ↑f (Pi.mulSingle i x) = ↑g (Pi.mulSingle i x)
val✝ : Fintype ι
x : (i : ι) → M i
⊢ noncommProd univ (fun i => ↑f (Pi.mulSingle i (x i)))
      (_ :
        ∀ (x_1 : ι),
          x_1 ∈ ↑univ →
            ∀ (y : ι), y ∈ ↑univ → x_1 ≠ y → Commute (↑f (Pi.mulSingle x_1 (x x_1))) (↑f (Pi.mulSingle y (x y)))) =
    noncommProd univ (fun i => ↑g (Pi.mulSingle i (x i)))
      (_ :
        ∀ (x_1 : ι),
          x_1 ∈ ↑univ →
            ∀ (y : ι), y ∈ ↑univ → x_1 ≠ y → Commute (↑g (Pi.mulSingle x_1 (x x_1))) (↑g (Pi.mulSingle y (x y))))

tactic: exact h i (x i)
state_before: case intro.h.e_f.h
F : Type ?u.241399
ι : Type u_1
α : Type ?u.241405
β : Type ?u.241408
γ : Type u_3
f✝ : α → β → β
op : α → α → α
inst✝⁴ : Monoid β
inst✝³ : Monoid γ
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), ↑f (Pi.mulSingle i x) = ↑g (Pi.mulSingle i x)
val✝ : Fintype ι
x : (i : ι) → M i
i : ι
⊢ ↑f (Pi.mulSingle i (x i)) = ↑g (Pi.mulSingle i (x i))
Theorem: List.nil_bind
File: Std/Data/List/Init/Lemmas.lean

tactic: simp [join, List.bind]
state_before: α : Type u_1
β : Type u_2
f : α → List β
⊢ List.bind [] f = []
Theorem: Denumerable.list_ofNat_zero
File: Mathlib/Logic/Equiv/List.lean

tactic: rw [← @encode_list_nil α, ofNat_encode]
state_before: α : Type u_1
β : Type ?u.38944
inst✝¹ : Denumerable α
inst✝ : Denumerable β
⊢ ofNat (List α) 0 = []
Theorem: MeasureTheory.Measure.AbsolutelyContinuous.map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simpa [hf, hs] using @h _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.398294
δ : Type ?u.398297
ι : Type ?u.398300
R : Type ?u.398303
R' : Type ?u.398306
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
h : μ ≪ ν
f : α → β
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ↑↑(map f ν) s = 0 → ↑↑(map f μ) s = 0
Theorem: LinearMap.range_eq_top_of_cancel
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: have h₁ : (0 : M₂ →ₗ[R₂] M₂ ⧸ (range f)).comp f = 0 := zero_comp _
state_before: R : Type u_1
M : Type u_3
R₂ : Type u_2
M₂ : Type u_4
R₃ : Type ?u.429644
M₃ : Type ?u.429647
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : M₂ →ₗ[R₂] M₂ ⧸ range f), comp u f = comp v f → u = v
⊢ range f = ⊤

tactic: rw [← Submodule.ker_mkQ (range f), ← h 0 f.range.mkQ (Eq.trans h₁ (range_mkQ_comp _).symm)]
state_before: R : Type u_1
M : Type u_3
R₂ : Type u_2
M₂ : Type u_4
R₃ : Type ?u.429644
M₃ : Type ?u.429647
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : M₂ →ₗ[R₂] M₂ ⧸ range f), comp u f = comp v f → u = v
h₁ : comp 0 f = 0
⊢ range f = ⊤

tactic: exact ker_zero
state_before: R : Type u_1
M : Type u_3
R₂ : Type u_2
M₂ : Type u_4
R₃ : Type ?u.429644
M₃ : Type ?u.429647
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : M₂ →ₗ[R₂] M₂ ⧸ range f), comp u f = comp v f → u = v
h₁ : comp 0 f = 0
⊢ ker 0 = ⊤
Theorem: padicValRat.one
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValRat]
state_before: p : ℕ
⊢ padicValRat p 1 = 0
Theorem: Stream'.WSeq.bind_assoc
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [bind]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
f : α → WSeq β
g : β → WSeq γ
⊢ bind (bind s f) g ~ʷ bind s fun x => bind (f x) g

tactic: erw [← map_comp f (map g), map_comp (map g ∘ f) join]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
f : α → WSeq β
g : β → WSeq γ
⊢ join (join (map (map g) (map f s))) ~ʷ join (map (fun x => join (map g (f x))) s)

tactic: apply join_join
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
f : α → WSeq β
g : β → WSeq γ
⊢ join (join (map (map g ∘ f) s)) ~ʷ join (map join (map (map g ∘ f) s))
Theorem: CategoryTheory.Abelian.Pseudoelement.pseudoApply_aux
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: rw [reassoc_of% comm]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
a b : Over P
x✝ : a ≈ b
R : C
p : R ⟶ a.left
q : R ⟶ b.left
ep : Epi p
Eq : Epi q
comm : p ≫ a.hom = q ≫ b.hom
⊢ p ≫ a.hom ≫ f = q ≫ b.hom ≫ f
Theorem: QuasiconvexOn.convex_lt
File: Mathlib/Analysis/Convex/Quasiconvex.lean

tactic: refine' fun x hx y hy a b ha hb hab => _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.20104
β : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrderedAddCommMonoid β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
hf : QuasiconvexOn 𝕜 s f
r : β
⊢ Convex 𝕜 {x | x ∈ s ∧ f x < r}

tactic: have h := hf _ ⟨hx.1, le_max_left _ _⟩ ⟨hy.1, le_max_right _ _⟩ ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.20104
β : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrderedAddCommMonoid β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
hf : QuasiconvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ {x | x ∈ s ∧ f x < r}

tactic: exact ⟨h.1, h.2.trans_lt <| max_lt hx.2 hy.2⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.20104
β : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrderedAddCommMonoid β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
hf : QuasiconvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
h : a • x + b • y ∈ {x_1 | x_1 ∈ s ∧ f x_1 ≤ max (f x) (f y)}
⊢ a • x + b • y ∈ {x | x ∈ s ∧ f x < r}
Theorem: IsFractionRing.num_mul_den_eq_num_iff_eq'
File: Mathlib/RingTheory/Localization/NumDen.lean

tactic: simpa only [eq_comm, mk'_num_den] using eq_mk'_iff_mul_eq.mpr h
state_before: R : Type ?u.103667
inst✝⁹ : CommRing R
M : Submonoid R
S : Type ?u.103873
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type ?u.104127
inst✝⁶ : CommRing P
A : Type u_2
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_1
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x y : K
h : y * ↑(algebraMap A K) ↑(den A x) = ↑(algebraMap A K) (num A x)
⊢ x = y

tactic: rw [h, mk'_num_den]
state_before: R : Type ?u.103667
inst✝⁹ : CommRing R
M : Submonoid R
S : Type ?u.103873
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type ?u.104127
inst✝⁶ : CommRing P
A : Type u_2
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_1
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x y : K
h : x = y
⊢ y = mk' K (num A x) (den A x)
Theorem: deriv_add_const
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simp only [deriv, fderiv_add_const]
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 : Filter 𝕜
c : F
⊢ deriv (fun y => f y + c) x = deriv f x
Theorem: CategoryTheory.obj_μ_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: rw [← associativity_app_assoc]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₂ m₃).app ((F.obj m₁).obj X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (m₂ ⊗ m₃)).app X ≫
        (F.map (α_ m₁ m₂ m₃).inv).app X ≫ (MonoidalFunctor.μIso F (m₁ ⊗ m₂) m₃).inv.app X

tactic: dsimp [endofunctorMonoidalCategory]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) =
    (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (m₁ ⊗ m₂) m₃).app X ≫
        (F.map (α_ m₁ m₂ m₃).hom).app X ≫
          (F.map (α_ m₁ m₂ m₃).inv).app X ≫ (MonoidalFunctor.μIso F (m₁ ⊗ m₂) m₃).inv.app X

tactic: simp
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) =
    (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (m₁ ⊗ m₂) m₃).app X ≫
        (F.map (α_ m₁ m₂ m₃).hom).app X ≫
          (F.map (α_ m₁ m₂ m₃).inv).app X ≫ (MonoidalFunctor.μIso F (m₁ ⊗ m₂) m₃).inv.app X

tactic: dsimp [endofunctorMonoidalCategory]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) =
    (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) ≫ 𝟙 ((F.obj (m₁ ⊗ m₂) ⊗ F.obj m₃).obj X)

tactic: simp
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) =
    (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) ≫
      𝟙 ((F.obj m₃).obj ((F.obj (m₁ ⊗ m₂)).obj X))
Theorem: Finset.card_le_mul_card_image_of_maps_to
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: simp [mul_comm]
state_before: ι : Type ?u.97925
α : Type u_1
β : Type u_2
M : Type ?u.97934
N : Type ?u.97937
G : Type ?u.97940
k : Type ?u.97943
R : Type ?u.97946
inst✝ : DecidableEq β
f : α → β
s : Finset α
t : Finset β
Hf : ∀ (a : α), a ∈ s → f a ∈ t
n : ℕ
hn : ∀ (a : β), a ∈ t → card (filter (fun x => f x = a) s) ≤ n
⊢ ∑ _a in t, n = n * card t
Theorem: Representation.asModuleEquiv_symm_map_smul
File: Mathlib/RepresentationTheory/Basic.lean

tactic: apply_fun ρ.asModuleEquiv
state_before: k : Type u_2
G : Type u_3
V : Type u_1
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
r : k
x : V
⊢ ↑(AddEquiv.symm (asModuleEquiv ρ)) (r • x) =
    ↑(algebraMap k (MonoidAlgebra k G)) r • ↑(AddEquiv.symm (asModuleEquiv ρ)) x

tactic: simp
state_before: k : Type u_2
G : Type u_3
V : Type u_1
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
r : k
x : V
⊢ ↑(asModuleEquiv ρ) (↑(AddEquiv.symm (asModuleEquiv ρ)) (r • x)) =
    ↑(asModuleEquiv ρ) (↑(algebraMap k (MonoidAlgebra k G)) r • ↑(AddEquiv.symm (asModuleEquiv ρ)) x)
Theorem: Path.reparam_id
File: Mathlib/Topology/PathConnected.lean

tactic: ext
state_before: X : Type u_1
Y : Type ?u.527477
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.527492
γ✝ γ : Path x y
⊢ reparam γ id (_ : Continuous id) (_ : id 0 = id 0) (_ : id 1 = id 1) = γ

tactic: rfl
state_before: case a.h
X : Type u_1
Y : Type ?u.527477
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.527492
γ✝ γ : Path x y
x✝ : ↑I
⊢ ↑(reparam γ id (_ : Continuous id) (_ : id 0 = id 0) (_ : id 1 = id 1)) x✝ = ↑γ x✝
Theorem: FiberPrebundle.continuous_totalSpaceMk
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: letI := a.totalSpaceTopology
state_before: ι : Type ?u.62801
B : Type u_2
F : Type u_3
X : Type ?u.62810
inst✝³ : TopologicalSpace X
E : B → Type u_1
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
⊢ Continuous (totalSpaceMk b)

tactic: let e := a.trivializationOfMemPretrivializationAtlas (a.pretrivialization_mem_atlas b)
state_before: ι : Type ?u.62801
B : Type u_2
F : Type u_3
X : Type ?u.62810
inst✝³ : TopologicalSpace X
E : B → Type u_1
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
this : TopologicalSpace (TotalSpace E) := totalSpaceTopology a
⊢ Continuous (totalSpaceMk b)

tactic: rw [e.toLocalHomeomorph.continuous_iff_continuous_comp_left
    (a.totalSpaceMk_preimage_source b)]
state_before: ι : Type ?u.62801
B : Type u_2
F : Type u_3
X : Type ?u.62810
inst✝³ : TopologicalSpace X
E : B → Type u_1
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ : Pretrivialization F TotalSpace.proj
b : B
this : TopologicalSpace (TotalSpace E) := totalSpaceTopology a
e : Trivialization F TotalSpace.proj :=
  trivializationOfMemPretrivializationAtlas a (_ : pretrivializationAt a b ∈ a.pretrivializationAtlas)
⊢ Continuous (totalSpaceMk b)

tactic: exact continuous_iff_le_induced.mpr (le_antisymm_iff.mp (a.totalSpaceMk_inducing b).induced).1
state_before: ι : Type ?u.62801
B : Type u_2
F : Type u_3
X : Type ?u.62810
inst✝³ : TopologicalSpace X
E : B → Type u_1
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ : Pretrivialization F TotalSpace.proj
b : B
this : TopologicalSpace (TotalSpace E) := totalSpaceTopology a
e : Trivialization F TotalSpace.proj :=
  trivializationOfMemPretrivializationAtlas a (_ : pretrivializationAt a b ∈ a.pretrivializationAtlas)
⊢ Continuous (↑e.toLocalHomeomorph ∘ totalSpaceMk b)