symplectic topology – Properties of $I_{mu}$ for Lagrangian Floer Homology in the Cotangent bundle

Following the notation of the book “Lagrangian intersection Floer theory anomaly and obstruction” suppose we have that our symplectic manifold is a cotangent bundle $T^*M$ with the canonical symplectic form and our two Lagrangian subamifolds are $L_0=phi^1(T^*_{p}M)$ and $L_1=T_q^*M$ for some $p,qin M$ and $phi^t$ is an hamiltonian flow.

Now if we consider the equivalence relation that give us the Novikov Covering where we have elements of the form $(l_p,w) $ and $(l_q,w’)$, I am interested in seeing at what happens to it. That is consider the homomorphisms $I_{omega}$ and $I_{mu}$. It is easy to see that due to the fact the cotangent bundle is an exact symplectic manifold we will have that $I_{omega}(C)=0$ for any $C=bar w# w’$ and so half of the equivalence relation is always true for any elements $(l_p,w)$ and $(l_p,w’)$ that I consider. Now I am interest on seeing what happens with the other one part of the equivalence relation.

So my question is if anybody knows or has any suggestion on checking wether $I_{mu}(C)=0$? Or more generally if our triple $(M,L_0,L_1)$ will be monotone , i.e, if there exists a $lambda >0$ such that $I_{omega}=lambda I_{mu}$?

(I have tried to look for references of these but I could´t find anything). Any help is appreciated. Thanks in advance.

Hardcode per-instance properties into the shader in unity

I am using one of the packages from the asset store and using its Polyline feature for wire rendering. There are thousands of wires and its taking much fps/Batch counts. The reason of the lack of support for static batching. Now there is a workaround suggested by the author of the package.

if you don’t use polylines for anything other than that, and all your
shaders use the same properties, you could hardcode all per-instance
properties into the shader

enter image description here

Due to a lack of shader knowledge(I am developing the knowledge currently and it will take time) I am unable to hard code the above properties: I tried and here is the current scenario:

#define int _ScaleMode = 1
#define half4 _Color = (0,0,0,0)    
#define float4 _PointStart = (0,0,0,0)   
#define float4 _PointEnd = (0,0,0,0)   
#define half _Thickness = 0.5
#define int _ThicknessSpace = 1
#define half _DashSize = 1
#define half _DashOffset =1
#define int _Alignment =1

HOw do i correctly hard code above values?

ag.algebraic geometry – Properties of pointless projective curves over finite fields?

Probably not research level, feel free to downvote.

We got construction of bounded degree projective curves
with no points over finite fields. This construction generalizes to higher dimension.

One of the curves over $GF(5)$ triggered internal Magma error, suggesting reporting the bug.

Working over $GF(p)$, let $f(x),g(y)$ be polynomials with no roots.
Let $n>1$ be integer and $s$ element of $GF(p)$ which is not
$n$-th power. Let $F$ be the homogenization of $f(x)^n-s g(y)^n=0$.
Then $F$ has no projective points. To go to higher dimension
take $(h(z)f(x))^n-s g(y)^n=0$

Q1 What properties these pointless curves have, e.g.
do they have some extremal invariants too?

Q2 Are there theoretical reasons to explain why Magma
fails to compute the Zeta function of pointless curve
in this example online

p:=5;
K<x,y>:=AffineSpace(GF(p),2);
C:=Curve(K,x^8 + 2*y^8 - x^7 + x^6 - y^6 + 2*x^5 + 2*y^5 - 2*x^4 + 2*y^3 + 2*x^2 + y^2 - x - y + 2);
pc:=ProjectiveClosure(C);
Genus(pc);
Points(pc);
IrreducibleComponents(pc);
ZetaFunction(pc);//report a bug

Properties of the Solutions of y’ = y

In this section of my notes we take E(x) as a solution of the initial value problem y’=y , y(0)= 1
We show that E(x+r) is also a solution to this problem and show E(x+r)=E(x)E(r).
The notes then go on to prove that E(x)>0. It is done as the following:

Suppose E(s) = 0 for some
s ∈ R. Then, for arbitrary x, we have E(x + s) = E(x)E(s) = 0, so E(x) ≡ 0.
This contradicts E(0) = 1.

My question is, surely E(x) doesn’t have to be 0, surely it could be anything because for whatever value of E(x), since we’ve said E(s)=0 then E(x)E(s) will always be 0 no matter what the value of E(x). Also I’m a little confused why E(0)=1. How do we know this?

Thanks in advance!

sharepoint online – What are the requirements to retain custom document properties when exporting to PDF

SharePoint colums (metadata) add extra document properties to the Word document.
When I download such a document I can view the extra properties In Word with File>Info>Show All Properties.
When I export the file to PDF with File>Export>Create PDF/XPS, with document properties checked in Options, the extra document properties are not transferred or not visiable in the resulting PDF document.
What are the requirements to retain the custom properties in PDF and show them?
Do I need specific software or specific version, I use the latest version of Office 365 and SharePoint Online.

wpf – Intellisense will not show Attached Properties in C# Class Library

I wish to use attached properties in my application by making use of the code below (and taken from here). However, Intellisense in Visual Studio will not show the registered Attached Properties for some reason unknown to me. My application is an add-in and constrained to be a class library (.Net Framework 4.7.2)

Viewing the code below and taking cognizance of the definition for Attached Properties, I would think that the attached property would be defined as such

 public static readonly DependencyProperty ValueProperty = DependencyProperty.RegisterAttached(
            "Value", 
            typeof(Property), 
            **typeof(Parent)**, 
            new UIPropertyMetadata(
                default(Property),
                new PropertyChangedCallback(OnValuePropertyChanged),
                new CoerceValueCallback(OnValuePropertyUpdated)
                ));

and NOT as such

 public static readonly DependencyProperty ValueProperty = DependencyProperty.RegisterAttached(
            "Value", 
            typeof(Property), 
            **typeof(BaseAttachedProperty<Parent, Property>)**, 
            new UIPropertyMetadata(
                default(Property),
                new PropertyChangedCallback(OnValuePropertyChanged),
                new CoerceValueCallback(OnValuePropertyUpdated)
                ));

Notice the difference between typeof(Parent) and typeof(BaseAttachedProperty<Parent, Property>). However, when I use this code in a Visual Studio Class Library, Intellisense does not show the defined Attached Properties that are defined for example:

 public class IsBusyProperty : BaseAttachedProperty<IsBusyProperty, bool>
    {
    }

Intellisense show the cryptic message: local:BaseAttachedProperty`2.Value which I understand refers to the Base Class with two parameters. Is there some particular method to handle Generics and Base Classes with WPF? My goal is to ease the creation and consumption of Attached Properties in my application. I have done the cleaning, deletion of the bin folder to no avail. However, when I write an own AP for example:

public class IsBusyProperty
    {
        public static readonly DependencyProperty ValueProperty =
            DependencyProperty.RegisterAttached("Value", typeof(bool), typeof(IsBusyProperty), new PropertyMetadata(false));
        public static bool GetValue(DependencyObject obj)
        {
            return (bool)obj.GetValue(ValueProperty);
        }
        public static void SetValue(DependencyObject obj, bool value)
        {
            obj.SetValue(ValueProperty, value);
        }
    }

the code compiles without the dreaded error that the attached property is not found in the namespace local:... or the No implementation exception!
Here is the reference code taken from here.

using System;
using System.ComponentModel;
using System.Windows;
 
namespace Fasetto.Word
{
    /// <summary>
    /// A base attached property to replace the vanilla WPF attached property
    /// </summary>
    /// <typeparam name="Parent">The parent class to be the attached property</typeparam>
    /// <typeparam name="Property">The type of this attached property</typeparam>
    public abstract class BaseAttachedProperty<Parent, Property>
        where Parent : new()
    {
        #region Public Events
 
        /// <summary>
        /// Fired when the value changes
        /// </summary>
        public event Action<DependencyObject, DependencyPropertyChangedEventArgs> ValueChanged = (sender, e) => { };
 
        /// <summary>
        /// Fired when the value changes, even when the value is the same
        /// </summary>
        public event Action<DependencyObject, object> ValueUpdated = (sender, value) => { };
 
        #endregion
 
        #region Public Properties
 
        /// <summary>
        /// A singleton instance of our parent class
        /// </summary>
        public static Parent Instance { get; private set; } = new Parent();
 
        #endregion
 
        #region Attached Property Definitions
 
        /// <summary>
        /// The attached property for this class
        /// </summary>
        public static readonly DependencyProperty ValueProperty = DependencyProperty.RegisterAttached(
            "Value", 
            typeof(Property), 
            typeof(BaseAttachedProperty<Parent, Property>), 
            new UIPropertyMetadata(
                default(Property),
                new PropertyChangedCallback(OnValuePropertyChanged),
                new CoerceValueCallback(OnValuePropertyUpdated)
                ));
 
        /// <summary>
        /// The callback event when the <see cref="ValueProperty"/> is changed
        /// </summary>
        /// <param name="d">The UI element that had it's property changed</param>
        /// <param name="e">The arguments for the event</param>
        private static void OnValuePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            // Call the parent function
            (Instance as BaseAttachedProperty<Parent, Property>)?.OnValueChanged(d, e);
 
            // Call event listeners
            (Instance as BaseAttachedProperty<Parent, Property>)?.ValueChanged(d, e);
        }
 
        /// <summary>
        /// The callback event when the <see cref="ValueProperty"/> is changed, even if it is the same value
        /// </summary>
        /// <param name="d">The UI element that had it's property changed</param>
        /// <param name="e">The arguments for the event</param>
        private static object OnValuePropertyUpdated(DependencyObject d, object value)
        {
            // Call the parent function
            (Instance as BaseAttachedProperty<Parent, Property>)?.OnValueUpdated(d, value);
 
            // Call event listeners
            (Instance as BaseAttachedProperty<Parent, Property>)?.ValueUpdated(d, value);
 
            // Return the value
            return value;
        }
 
        /// <summary>
        /// Gets the attached property
        /// </summary>
        /// <param name="d">The element to get the property from</param>
        /// <returns></returns>
        public static Property GetValue(DependencyObject d) => (Property)d.GetValue(ValueProperty);
 
        /// <summary>
        /// Sets the attached property
        /// </summary>
        /// <param name="d">The element to get the property from</param>
        /// <param name="value">The value to set the property to</param>
        public static void SetValue(DependencyObject d, Property value) => d.SetValue(ValueProperty, value);
 
        #endregion
 
        #region Event Methods
 
        /// <summary>
        /// The method that is called when any attached property of this type is changed
        /// </summary>
        /// <param name="sender">The UI element that this property was changed for</param>
        /// <param name="e">The arguments for this event</param>
        public virtual void OnValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { }
 
        /// <summary>
        /// The method that is called when any attached property of this type is changed, even if the value is the same
        /// </summary>
        /// <param name="sender">The UI element that this property was changed for</param>
        /// <param name="e">The arguments for this event</param>
        public virtual void OnValueUpdated(DependencyObject sender, object value) { }
 
        #endregion
    }
} 

SharePoint : “edit properties” greyed out for folders but not files

In my SharePoint site, “edit properties” is greyed out , but only for folders , not for files.
I don’t know how to tell you what SharePoint version it is (if needed please guide me)
I am the owner of the site, which one of many sites of my company, so I have full control permission on the whole site

Regards

ds.dynamical systems – Is this pair of coupled sequences known, and what are their properties?

I was examining the following pair of ‘coupled’ sequences (I don’t know the correct terminology):
$a_{n+1}=a_n+b_n+frac{a_n}{b_n}$
$b_{n+1}=b_nleft(1+frac{b_n}{a_n}right)$
Both sequences grow without bound if $b_0>1$ and if $a_0=b_0=1$ but if $a_0>1$ then sequence $b$ approaches a limit. For instance, if $a_0=2$ then $b_n$ approaches $4.0894$ and if $a_0=3$ then the $b$ limit is $2.2109$; neither of those are exact.
Is this pair of sequences already known of, and if so, what things are known about it? Does this system have a name? Where could I find literature about it?

file format – Image properties for social media?

My experience of social media is extremely limited, but I have occasionally been asked by a group to send them an image for use on their media. Sometimes as non-technical people only used to mobile phone images they have failed to upload the pictures or butchered them in an effort to do so.
In darktable I have presets that I use for exporting files for different uses.
The settings I can imagine include (there may be more):

  1. pixel dimensions (ppi, file size)
  2. file type (png, jpg, tiff, etc)
  3. compression level (for smaller file size and less chance of reproductions)
  4. colour profile (sRGB, AdobeRGB, etc)
  5. styles (for adding modules to the pipeline – perhaps a crop, watermark and border)

What settings are optimal / most useful for the various platforms?

terminology – Do grammars with these properties have a name?

I’m interested in context-free grammars on a finite set of symbols where all the production rules replace a symbol by a string of length two. There is also one constraint: in the reductive direction the rules are deterministic. For example, $Ato BC$ and $Dto BC$ cannot both be in the set of rules.

In the reductive direction these grammars are like a general binary operation acting on a finite set, but where the operation may be undefined for some pairs of operands.

Whichever perspective (grammar or binary quasi-operation) is better known, I would like to know its name.